src/modules/erp/pricing/
├── pricing-engine.module.ts         # Módulo raíz del engine
├── pricing-engine.service.ts        # Motor de precios (core)
├── pricing-engine.controller.ts     # Endpoints del engine
│
├── exchange/                        # Sub-módulo de cotizaciones
│   ├── exchange.module.ts
│   ├── exchange.service.ts          # Sync, conversión y consulta de tasas
│   ├── exchange.controller.ts       # Endpoints de exchange
│   ├── exchange.scheduler.ts        # Cron de sincronización automática
│   ├── dto/
│   │   └── sync-exchange.dto.ts
│   └── interfaces/
│       └── dolar-api.interface.ts   # Shape de respuesta de dolarapi.com
│
└── product-pricing/                 # Sub-módulo de precios de producto
    ├── product-pricing.module.ts
    ├── product-pricing.service.ts   # CRUD de precios base
    ├── product-pricing-facade.service.ts  # Fachada pública
    ├── product-pricing.controller.ts      # Endpoints de pricing (facade)
    ├── product-price.controller.ts        # Endpoints CRUD de precios base
    ├── dto/
    │   ├── create-product-price.dto.ts
    │   └── update-product-price.dto.ts
    └── interfaces/

graph TD
    A[ProductPricingController] --> B[ProductPricingFacadeService]
    B --> C[PricingEngineService]
    B --> D[ExchangeService]
    C --> D
    C --> E[(PrismaService)]
    D --> E
    D --> F[dolarapi.com]
    G[ExchangeScheduler] -->|Cron cada hora 10-15hs| D
    H[ProductPriceController] --> I[ProductPriceService]
    I --> E
    J[PricingEngineController] --> C
    K[ExchangeController] --> D

interface ResolvedItemTax {
  tax_id: string;
  tax_rate: number;
  tax_amount: number;
  calculation_level: string;   // 'line' | ...
  is_included_in_price: boolean;
}

interface ResolvedItem {
  product_id: string;
  quantity: number;
  currency: string;
  original_currency: string;
  original_unit_price: number;
  unit_price: number;
  converted_unit_price: number;
  exchange_rate: number;
  price: number;               // unit_price * quantity
  exempt_amount: number;       // price * (exemption_rate / 100)
  taxable_base: number;        // price - exempt_amount
  taxes: ResolvedItemTax[];
  total_taxes: number;
  total: number;               // taxable_base + total_taxes
}

{
  product_id: string;
  currency: string;
  original_currency: string;
  original_price: number;      // redondeado a 2 decimales
  exchange_rate: number;       // redondeado a 6 decimales
  converted_price: number;     // redondeado a 2 decimales
  exemption_rate: number;
}

{
  amount: number;
  from: string;
  to: string;
  rate_type: CurrencyRateType;
  rate: number;               // 6 decimales
  converted_amount: number;   // 6 decimales
  inverse?: boolean;
  effective_date?: Date;
}

// dolar-api.interface.ts
interface DolarApiQuote {
  moneda: string;
  casa: string;
  nombre: string;
  compra: number;
  venta: number;
  fechaActualizacion: string;
  variacion?: number;
}

{
  product_id: string;      // UUID — requerido
  currency_id: string;     // UUID — requerido
  price: number;           // >= 0 — requerido
  exemption_rate?: number; // >= 0 — opcional (default 0)
}

POST /pricing/cart  { currency: "ARS", items: [{productId: "abc", quantity: 2}] }
  └→ ProductPricingFacadeService.calculateCart()
       └→ PricingEngineService.resolveItemWithTaxes("abc", 2, "ARS")
            ├→ [si no override] resolveProductPrice("abc", "ARS")
            │    ├→ prisma.product_price.findFirst()          ← precio base en BD
            │    └→ ExchangeService.convertAmount()           ← conversión si aplica
            ├→ Calcula price = unit_price × quantity
            ├→ Calcula exempt_amount = price × exemption_rate%
            ├→ Calcula taxable_base = price - exempt_amount
            └→ Para cada tax activo del producto:
                 └→ tax_amount = taxable_base × tax_rate%  (si es 'line' y no incluido)

round2(value: number): number  // Math.round(value * 100) / 100
round6(value: number): number  // Math.round(value * 1_000_000) / 1_000_000