rust_projects:
  GIRO-D:
    path: GIRO/apps/desktop/src-tauri/
    stack: Tauri 2.0 + SQLx (SQLite)
    purpose: Desktop PDV/Enterprise backend
  LICENSE:
    path: giro-license-server/backend/
    stack: Axum + SQLx (PostgreSQL)
    purpose: License API server

shared_patterns:
  - SQLx for compile-time checked queries
  - Repository pattern for data access
  - thiserror for error handling
  - serde for serialization
  - tracing for logging

apps/desktop/src-tauri/
├── src/
│   ├── main.rs              # Entry point, setup Tauri
│   ├── lib.rs               # Exports públicos
│   ├── commands/            # Tauri commands (IPC)
│   │   ├── mod.rs
│   │   ├── products.rs
│   │   ├── sales.rs
│   │   └── ...
│   ├── services/            # Business logic
│   │   ├── mod.rs
│   │   └── ...
│   ├── repositories/        # Data access (SQLx)
│   │   ├── mod.rs
│   │   └── ...
│   ├── hardware/            # Device drivers
│   │   ├── mod.rs
│   │   ├── printer.rs
│   │   ├── scale.rs
│   │   └── ...
│   ├── models/              # Domain models
│   └── database/            # DB connection pool
├── Cargo.toml
└── tauri.conf.json

use tauri::command;
use crate::services::ProductService;
use crate::models::{Product, ProductFilter};

/// Lista produtos com filtros opcionais
#[command]
pub async fn get_products(
    filter: ProductFilter,
    state: tauri::State<'_, AppState>,
) -> Result<Vec<Product>, String> {
    let service = ProductService::new(state.pool.clone());

    service
        .list(filter)
        .await
        .map_err(|e| e.to_string())
}

pub struct ProductRepository {
    pool: Pool<Sqlite>,
}

impl ProductRepository {
    pub fn new(pool: Pool<Sqlite>) -> Self {
        Self { pool }
    }

    pub async fn find_by_barcode(&self, barcode: &str) -> Result<Option<Product>, sqlx::Error> {
        sqlx::query_as!(
            Product,
            r#"
            SELECT id, barcode, name, sale_price, current_stock
            FROM products
            WHERE barcode = ? AND is_active = true
            "#,
            barcode
        )
        .fetch_optional(&self.pool)
        .await
    }
}

use thiserror::Error;

#[derive(Error, Debug)]
pub enum AppError {
    #[error("Produto não encontrado")]
    ProductNotFound,

    #[error("Estoque insuficiente: {available} disponível, {requested} solicitado")]
    InsufficientStock { available: f64, requested: f64 },

    #[error("Erro de banco: {0}")]
    Database(#[from] sqlx::Error),
}

impl From<AppError> for String {
    fn from(error: AppError) -> Self {
        error.to_string()
    }
}