modules/customer-invoices/src/api/domain/aggregates/customer-invoice.ts

@@ -1,13 +1,6 @@
-import {
+import { AggregateRoot, UniqueID, UtcDate } from "@repo/rdx-ddd";
-  AggregateRoot,
+import { Collection, Result } from "@repo/rdx-utils";
-  CurrencyCode,
+import { CustomerInvoiceCustomer, CustomerInvoiceItem, CustomerInvoiceItems } from "../entities";
-  LanguageCode,
-  TextValue,
-  UniqueID,
-  UtcDate,
-} from "@repo/rdx-ddd";
-import { Maybe, Result } from "@repo/rdx-utils";
-import { CustomerInvoiceItems } from "../entities";
 import {
   CustomerInvoiceNumber,
   CustomerInvoiceSerie,
@@ -15,19 +8,20 @@ import {
 } from "../value-objects";
 
 export interface CustomerInvoiceProps {
-  companyId: UniqueID;
-  status: CustomerInvoiceStatus;
-  series: Maybe<CustomerInvoiceSerie>;
   invoiceNumber: CustomerInvoiceNumber;
+  invoiceSeries: CustomerInvoiceSerie;
+
+  status: CustomerInvoiceStatus;
 
   issueDate: UtcDate;
-  operationDate: Maybe<UtcDate>;
+  operationDate: UtcDate;
-
-  notes: Maybe<TextValue>;
 
   //dueDate: UtcDate; // ? --> depende de la forma de pago
 
   //tax: Tax; // ? --> detalles?
+  currency: string;
+
+  //language: Language;
 
   //purchareOrderNumber: string;
   //notes: Note;
@@ -37,27 +31,53 @@ export interface CustomerInvoiceProps {
   //paymentInstructions: Note;
   //paymentTerms: string;
 
-  languageCode: LanguageCode;
+  customer?: CustomerInvoiceCustomer;
-  currencyCode: CurrencyCode;
-
-  //customer?: CustomerInvoiceCustomer;
   items?: CustomerInvoiceItems;
 }
 
-export type CustomerInvoicePatchProps = Partial<Omit<CustomerInvoiceProps, "companyId">>;
+export interface ICustomerInvoice {
+  id: UniqueID;
+  invoiceNumber: CustomerInvoiceNumber;
+  invoiceSeries: CustomerInvoiceSerie;
 
-export class CustomerInvoice extends AggregateRoot<CustomerInvoiceProps> {
+  status: CustomerInvoiceStatus;
-  private _items!: CustomerInvoiceItems;
+
+  issueDate: UtcDate;
+  operationDate: UtcDate;
+
+  //senderId: UniqueID;
+
+  customer?: CustomerInvoiceCustomer;
+
+  //dueDate
+
+  //tax: Tax;
+  //language: Language;
+  currency: string;
+
+  //purchareOrderNumber: string;
+  //notes: Note;
+
+  //paymentInstructions: Note;
+  //paymentTerms: string;
+
+  items: CustomerInvoiceItems;
+
+  calculateSubtotal: () => MoneyValue;
+  calculateTaxTotal: () => MoneyValue;
+  calculateTotal: () => MoneyValue;
+}
+
+export class CustomerInvoice
+  extends AggregateRoot<CustomerInvoiceProps>
+  implements ICustomerInvoice
+{
+  private _items!: Collection<CustomerInvoiceItem>;
   //protected _status: CustomerInvoiceStatus;
 
   protected constructor(props: CustomerInvoiceProps, id?: UniqueID) {
     super(props, id);
-    this._items =
+    this._items = props.items || CustomerInvoiceItems.create();
-      props.items ||
-      CustomerInvoiceItems.create({
-        languageCode: props.languageCode,
-        currencyCode: props.currencyCode,
-      });
   }
 
   static create(props: CustomerInvoiceProps, id?: UniqueID): Result<CustomerInvoice, Error> {
@@ -74,55 +94,50 @@ export class CustomerInvoice extends AggregateRoot<CustomerInvoiceProps> {
     return Result.ok(customerInvoice);
   }
 
-  public update(partialInvoice: CustomerInvoicePatchProps): Result<CustomerInvoice, Error> {
+  get invoiceNumber() {
-    throw new Error("Not implemented");
-  }
-
-  public get companyId(): UniqueID {
-    return this.props.companyId;
-  }
-
-  public get series(): Maybe<CustomerInvoiceSerie> {
-    return this.props.series;
-  }
-
-  public get invoiceNumber() {
     return this.props.invoiceNumber;
   }
 
-  public get issueDate(): UtcDate {
+  get invoiceSeries() {
+    return this.props.invoiceSeries;
+  }
+
+  get issueDate() {
     return this.props.issueDate;
   }
 
-  public get operationDate(): Maybe<UtcDate> {
-    return this.props.operationDate;
-  }
-
-  public get notes(): Maybe<TextValue> {
-    return this.props.notes;
-  }
-
-  public get languageCode(): LanguageCode {
-    return this.props.languageCode;
-  }
-
-  public get currencyCode(): CurrencyCode {
-    return this.props.currencyCode;
-  }
-
-  // Method to get the complete list of line items
-  get lineItems(): CustomerInvoiceItems {
-    return this._items;
-  }
-
   /*get senderId(): UniqueID {
     return this.props.senderId;
   }*/
 
-  /* get customer(): CustomerInvoiceCustomer | undefined {
+  get customer(): CustomerInvoiceCustomer | undefined {
     return this.props.customer;
+  }
+
+  get operationDate() {
+    return this.props.operationDate;
+  }
+
+  /*get language() {
+    return this.props.language;
   }*/
 
+  get dueDate() {
+    return undefined;
+  }
+
+  get tax() {
+    return undefined;
+  }
+
+  get status() {
+    return this.props.status;
+  }
+
+  get items() {
+    return this._items;
+  }
+
   /*get purchareOrderNumber() {
     return this.props.purchareOrderNumber;
   }
@@ -143,7 +158,19 @@ export class CustomerInvoice extends AggregateRoot<CustomerInvoiceProps> {
     return this.props.shipTo;
   }*/
 
-  /*
+  get currency() {
+    return this.props.currency;
+  }
+
+  /*get notes() {
+    return this.props.notes;
+  }*/
+
+  // Method to get the complete list of line items
+  /*get lineItems(): CustomerInvoiceLineItem[] {
+    return this._lineItems;
+  }
+
   addLineItem(lineItem: CustomerInvoiceLineItem, position?: number): void {
     if (position === undefined) {
       this._lineItems.push(lineItem);
@@ -152,7 +179,7 @@ export class CustomerInvoice extends AggregateRoot<CustomerInvoiceProps> {
     }
   }*/
 
-  /*calculateSubtotal(): MoneyValue {
+  calculateSubtotal(): MoneyValue {
     const customerInvoiceSubtotal = MoneyValue.create({
       amount: 0,
       currency_code: this.props.currency,
@@ -162,10 +189,10 @@ export class CustomerInvoice extends AggregateRoot<CustomerInvoiceProps> {
     return this._items.getAll().reduce((subtotal, item) => {
       return subtotal.add(item.calculateTotal());
     }, customerInvoiceSubtotal);
-  }*/
+  }
 
   // Method to calculate the total tax in the customerInvoice
-  /*calculateTaxTotal(): MoneyValue {
+  calculateTaxTotal(): MoneyValue {
     const taxTotal = MoneyValue.create({
       amount: 0,
       currency_code: this.props.currency,
@@ -173,10 +200,10 @@ export class CustomerInvoice extends AggregateRoot<CustomerInvoiceProps> {
     }).data;
 
     return taxTotal;
-  }*/
+  }
 
   // Method to calculate the total customerInvoice amount, including taxes
-  /*calculateTotal(): MoneyValue {
+  calculateTotal(): MoneyValue {
     return this.calculateSubtotal().add(this.calculateTaxTotal());
-  }*/
+  }
 }

modules/customer-invoices/src/api/domain/entities/invoice-items/customer-invoice-item.ts

@@ -1,102 +0,0 @@
-import { CurrencyCode, DomainEntity, LanguageCode, UniqueID } from "@repo/rdx-ddd";
-import { Maybe, Result } from "@repo/rdx-utils";
-import {
-  CustomerInvoiceItemDescription,
-  CustomerInvoiceItemDiscount,
-  CustomerInvoiceItemQuantity,
-  CustomerInvoiceItemSubtotalPrice,
-  CustomerInvoiceItemTotalPrice,
-  CustomerInvoiceItemUnitPrice,
-} from "../../value-objects";
-
-export interface CustomerInvoiceItemProps {
-  description: Maybe<CustomerInvoiceItemDescription>;
-  quantity: Maybe<CustomerInvoiceItemQuantity>; // Cantidad de unidades
-  unitPrice: Maybe<CustomerInvoiceItemUnitPrice>; // Precio unitario en la moneda de la factura
-  discount: Maybe<CustomerInvoiceItemDiscount>; // % descuento
-
-  languageCode: LanguageCode;
-  currencyCode: CurrencyCode;
-}
-
-export class CustomerInvoiceItem extends DomainEntity<CustomerInvoiceItemProps> {
-  private _subtotalPrice!: CustomerInvoiceItemSubtotalPrice;
-  private _totalPrice!: CustomerInvoiceItemTotalPrice;
-
-  public static create(
-    props: CustomerInvoiceItemProps,
-    id?: UniqueID
-  ): Result<CustomerInvoiceItem, Error> {
-    const item = new CustomerInvoiceItem(props, id);
-
-    // Reglas de negocio / validaciones
-    // ...
-    // ...
-
-    // 🔹 Disparar evento de dominio "CustomerInvoiceItemCreatedEvent"
-    //const { customerInvoice } = props;
-    //user.addDomainEvent(new CustomerInvoiceAuthenticatedEvent(id, customerInvoice.toString()));
-
-    return Result.ok(item);
-  }
-
-  get description(): Maybe<CustomerInvoiceItemDescription> {
-    return this.props.description;
-  }
-
-  get quantity(): Maybe<CustomerInvoiceItemQuantity> {
-    return this.props.quantity;
-  }
-
-  get unitPrice(): Maybe<CustomerInvoiceItemUnitPrice> {
-    return this.props.unitPrice;
-  }
-
-  get subtotalPrice(): CustomerInvoiceItemSubtotalPrice {
-    if (!this._subtotalPrice) {
-      this._subtotalPrice = this.calculateSubtotal();
-    }
-    return this._subtotalPrice;
-  }
-
-  get discount(): Maybe<CustomerInvoiceItemDiscount> {
-    return this.props.discount;
-  }
-
-  get totalPrice(): CustomerInvoiceItemTotalPrice {
-    if (!this._totalPrice) {
-      this._totalPrice = this.calculateTotal();
-    }
-    return this._totalPrice;
-  }
-
-  public get languageCode(): LanguageCode {
-    return this.props.languageCode;
-  }
-
-  public get currencyCode(): CurrencyCode {
-    return this.props.currencyCode;
-  }
-
-  getValue(): CustomerInvoiceItemProps {
-    return this.props;
-  }
-
-  toPrimitive() {
-    return this.getValue();
-  }
-
-  calculateSubtotal(): CustomerInvoiceItemSubtotalPrice {
-    throw new Error("Not implemented");
-
-    /*const unitPrice = this.unitPrice.isSome()
-      ? this.unitPrice.unwrap()
-      : CustomerInvoiceItemUnitPrice.zero();
-    return this.unitPrice.multiply(this.quantity.toNumber()); // Precio unitario * Cantidad*/
-  }
-
-  calculateTotal(): CustomerInvoiceItemTotalPrice {
-    throw new Error("Not implemented");
-    //return this.subtotalPrice.subtract(this.subtotalPrice.percentage(this.discount.toNumber()));
-  }
-}

modules/customer-invoices/src/api/domain/entities/invoice-items/customer-invoice-items.ts

@@ -1,25 +0,0 @@
-import { CurrencyCode, LanguageCode } from "@repo/rdx-ddd";
-import { Collection } from "@repo/rdx-utils";
-import { CustomerInvoiceItem } from "./customer-invoice-item";
-
-export interface CustomerInvoiceItemsProps {
-  items?: CustomerInvoiceItem[];
-  languageCode: LanguageCode;
-  currencyCode: CurrencyCode;
-}
-
-export class CustomerInvoiceItems extends Collection<CustomerInvoiceItem> {
-  private _languageCode!: LanguageCode;
-  private _currencyCode!: CurrencyCode;
-
-  constructor(props: CustomerInvoiceItemsProps) {
-    const { items, languageCode, currencyCode } = props;
-    super(items);
-    this._languageCode = languageCode;
-    this._currencyCode = currencyCode;
-  }
-
-  public static create(props: CustomerInvoiceItemsProps): CustomerInvoiceItems {
-    return new CustomerInvoiceItems(props);
-  }
-}

modules/customer-invoices/src/api/domain/entities/invoice-items/index.ts

@@ -1,2 +1,2 @@
-export * from "./customer-invoice-item";
+export * from "./invoice-item";
-export * from "./customer-invoice-items";
+export * from "./invoice-items";

modules/customer-invoices/src/api/domain/entities/invoice-items/invoice-item.test.ts

@@ -1,4 +1,4 @@
-import { CurrencyCode, LanguageCode, MoneyValue, Percentage, Quantity } from "@repo/rdx-ddd";
+import { MoneyValue, Percentage, Quantity } from "@/core/common/domain";
 import { CustomerInvoiceItemDescription } from "../../value-objects";
 import { CustomerInvoiceItem } from "./customer-invoice-item";
 
@@ -9,8 +9,6 @@ describe("CustomerInvoiceItem", () => {
       quantity: Quantity.create({ amount: 200, scale: 2 }),
       unitPrice: MoneyValue.create(50),
       discount: Percentage.create(0),
-      languageCode: LanguageCode.create("es"),
-      currencyCode: CurrencyCode.create("EUR"),
     };
 
     const result = CustomerInvoiceItem.create(props);

modules/customer-invoices/src/api/domain/entities/invoice-items/invoice-item.ts

@@ -0,0 +1,107 @@
+import { DomainEntity, UniqueID } from "@repo/rdx-ddd";
+import { Result } from "@repo/rdx-utils";
+import {
+  CustomerInvoiceItemDescription,
+  CustomerInvoiceItemDiscount,
+  CustomerInvoiceItemQuantity,
+  CustomerInvoiceItemSubtotalPrice,
+  CustomerInvoiceItemTotalPrice,
+  CustomerInvoiceItemUnitPrice,
+} from "../../value-objects";
+
+export interface ICustomerInvoiceItemProps {
+  description: CustomerInvoiceItemDescription;
+  quantity: CustomerInvoiceItemQuantity; // Cantidad de unidades
+  unitPrice: CustomerInvoiceItemUnitPrice; // Precio unitario en la moneda de la factura
+  //subtotalPrice?: MoneyValue; // Precio unitario * Cantidad
+  discount: CustomerInvoiceItemDiscount; // % descuento
+  //totalPrice?: MoneyValue;
+}
+
+export interface ICustomerInvoiceItem {
+  id: UniqueID;
+  description: CustomerInvoiceItemDescription;
+  quantity: CustomerInvoiceItemQuantity;
+  unitPrice: CustomerInvoiceItemUnitPrice;
+  subtotalPrice: CustomerInvoiceItemSubtotalPrice;
+  discount: CustomerInvoiceItemDiscount;
+  totalPrice: CustomerInvoiceItemTotalPrice;
+}
+
+export class CustomerInvoiceItem
+  extends DomainEntity<ICustomerInvoiceItemProps>
+  implements ICustomerInvoiceItem
+{
+  private _subtotalPrice!: CustomerInvoiceItemSubtotalPrice;
+  private _totalPrice!: CustomerInvoiceItemTotalPrice;
+
+  public static create(
+    props: ICustomerInvoiceItemProps,
+    id?: UniqueID
+  ): Result<CustomerInvoiceItem, Error> {
+    const item = new CustomerInvoiceItem(props, id);
+
+    // Reglas de negocio / validaciones
+    // ...
+    // ...
+
+    // 🔹 Disparar evento de dominio "CustomerInvoiceItemCreatedEvent"
+    //const { customerInvoice } = props;
+    //user.addDomainEvent(new CustomerInvoiceAuthenticatedEvent(id, customerInvoice.toString()));
+
+    return Result.ok(item);
+  }
+
+  get description(): CustomerInvoiceItemDescription {
+    return this.props.description;
+  }
+
+  get quantity(): CustomerInvoiceItemQuantity {
+    return this.props.quantity;
+  }
+
+  get unitPrice(): CustomerInvoiceItemUnitPrice {
+    return this.props.unitPrice;
+  }
+
+  get subtotalPrice(): CustomerInvoiceItemSubtotalPrice {
+    if (!this._subtotalPrice) {
+      this._subtotalPrice = this.calculateSubtotal();
+    }
+    return this._subtotalPrice;
+  }
+
+  get discount(): CustomerInvoiceItemDiscount {
+    return this.props.discount;
+  }
+
+  get totalPrice(): CustomerInvoiceItemTotalPrice {
+    if (!this._totalPrice) {
+      this._totalPrice = this.calculateTotal();
+    }
+    return this._totalPrice;
+  }
+
+  getValue() {
+    return this.props;
+  }
+
+  toPrimitive() {
+    return {
+      description: this.description.toPrimitive(),
+      quantity: this.quantity.toPrimitive(),
+      unit_price: this.unitPrice.toPrimitive(),
+      subtotal_price: this.subtotalPrice.toPrimitive(),
+      discount: this.discount.toPrimitive(),
+      total_price: this.totalPrice.toPrimitive(),
+    };
+  }
+
+  calculateSubtotal(): CustomerInvoiceItemSubtotalPrice {
+    return this.unitPrice.multiply(this.quantity.toNumber()); // Precio unitario * Cantidad
+  }
+
+  calculateTotal(): CustomerInvoiceItemTotalPrice {
+    return this.subtotalPrice.subtract(this.subtotalPrice.percentage(this.discount.toNumber()));
+  }
+}

modules/customer-invoices/src/api/domain/entities/invoice-items/invoice-items.ts

@@ -0,0 +1,8 @@
+import { Collection } from "@repo/rdx-utils";
+import { CustomerInvoiceItem } from "./customer-invoice-item";
+
+export class CustomerInvoiceItems extends Collection<CustomerInvoiceItem> {
+  public static create(items?: CustomerInvoiceItem[]): CustomerInvoiceItems {
+    return new CustomerInvoiceItems(items);
+  }
+}

modules/customer-invoices/src/api/domain/repositories/customer-invoice-repository.interface.ts

@@ -3,15 +3,12 @@ import { UniqueID } from "@repo/rdx-ddd";
 import { Collection, Result } from "@repo/rdx-utils";
 import { CustomerInvoice } from "../aggregates";
 
-/**
- * Interfaz del repositorio para el agregado `CustomerInvoice`.
- * El escopado multitenant está representado por `companyId`.
- */
 export interface ICustomerInvoiceRepository {
+  existsById(id: UniqueID, transaction?: any): Promise<Result<boolean, Error>>;
+
   /**
    *
    * Persiste una nueva factura o actualiza una existente.
-   * Retorna el objeto actualizado tras la operación.
    *
    * @param invoice - El agregado a guardar.
    * @param transaction - Transacción activa para la operación.
@@ -20,55 +17,34 @@ export interface ICustomerInvoiceRepository {
   save(invoice: CustomerInvoice, transaction: any): Promise<Result<CustomerInvoice, Error>>;
 
   /**
-   * Comprueba si existe una factura con un `id` dentro de una `company`.
+   *
+   * Busca una factura por su identificador único.
+   * @param id - UUID de la factura.
+   * @param transaction - Transacción activa para la operación.
+   * @returns Result<CustomerInvoice, Error>
    */
-  existsByIdInCompany(
+  findById(id: UniqueID, transaction: any): Promise<Result<CustomerInvoice, Error>>;
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction?: any
-  ): Promise<Result<boolean, Error>>;
-
-  /**
-   * Recupera una factura por su ID y companyId.
-   * Devuelve un `NotFoundError` si no se encuentra.
-   */
-  getByIdInCompany(
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction?: any
-  ): Promise<Result<CustomerInvoice, Error>>;
 
   /**
    *
-   * Consulta facturas dentro de una empresa usando un
+   * Consulta facturas usando un objeto Criteria (filtros, orden, paginación).
-   * objeto Criteria (filtros, orden, paginación).
-   * El resultado está encapsulado en un objeto `Collection<T>`.
-   *
-   * @param companyId - ID de la empresa.
    * @param criteria - Criterios de búsqueda.
    * @param transaction - Transacción activa para la operación.
    * @returns Result<CustomerInvoice[], Error>
    *
    * @see Criteria
    */
-  findByCriteriaInCompany(
+  findByCriteria(
-    companyId: UniqueID,
     criteria: Criteria,
     transaction: any
   ): Promise<Result<Collection<CustomerInvoice>, Error>>;
 
   /**
    *
-   * Elimina o marca como eliminada una factura dentro de una empresa.
+   * Elimina o marca como eliminada una factura.
-   *
-   * @param companyId - ID de la empresa.
    * @param id - UUID de la factura a eliminar.
    * @param transaction - Transacción activa para la operación.
    * @returns Result<void, Error>
    */
-  deleteByIdInCompany(
+  deleteById(id: UniqueID, transaction: any): Promise<Result<void, Error>>;
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction: any
-  ): Promise<Result<void, Error>>;
 }

modules/customer-invoices/src/api/domain/value-objects/customer-invoice-address-type.ts

@@ -14,10 +14,10 @@ export class CustomerInvoiceAddressType extends ValueObject<ICustomerInvoiceAddr
   private static readonly ALLOWED_TYPES = ["shipping", "billing"];
 
   static create(value: string): Result<CustomerInvoiceAddressType, Error> {
-    if (!CustomerInvoiceAddressType.ALLOWED_TYPES.includes(value)) {
+    if (!this.ALLOWED_TYPES.includes(value)) {
       return Result.fail(
         new Error(
-          `Invalid address type: ${value}. Allowed types are: ${CustomerInvoiceAddressType.ALLOWED_TYPES.join(", ")}`
+          `Invalid address type: ${value}. Allowed types are: ${this.ALLOWED_TYPES.join(", ")}`
         )
       );
     }

modules/customer-invoices/src/api/domain/value-objects/customer-invoice-item-description.ts

@@ -3,11 +3,11 @@ import { ValueObject } from "@repo/rdx-ddd";
 import { Maybe, Result } from "@repo/rdx-utils";
 import * as z from "zod/v4";
 
-interface CustomerInvoiceItemDescriptionProps {
+interface ICustomerInvoiceItemDescriptionProps {
   value: string;
 }
 
-export class CustomerInvoiceItemDescription extends ValueObject<CustomerInvoiceItemDescriptionProps> {
+export class CustomerInvoiceItemDescription extends ValueObject<ICustomerInvoiceItemDescriptionProps> {
   private static readonly MAX_LENGTH = 255;
   private static readonly FIELD = "invoiceItemDescription";
   private static readonly ERROR_CODE = "INVALID_INVOICE_ITEM_DESCRIPTION";
@@ -23,10 +23,10 @@ export class CustomerInvoiceItemDescription extends ValueObject<CustomerInvoiceI
   }
 
   static create(value: string) {
-    const valueIsValid = CustomerInvoiceItemDescription.validate(value);
+    const result = CustomerInvoiceItemDescription.validate(value);
 
-    if (!valueIsValid.success) {
+    if (!result.success) {
-      const detail = valueIsValid.error.message;
+      const detail = result.error.message;
       return Result.fail(
         new DomainValidationError(
           CustomerInvoiceItemDescription.ERROR_CODE,

modules/customer-invoices/src/api/domain/value-objects/customer-invoice-item-unit-price.ts

@@ -11,13 +11,4 @@ export class CustomerInvoiceItemUnitPrice extends MoneyValue {
     };
     return MoneyValue.create(props);
   }
-
-  static zero(currency_code: string, scale: number = CustomerInvoiceItemUnitPrice.DEFAULT_SCALE) {
-    const props: MoneyValueProps = {
-      amount: 0,
-      scale,
-      currency_code,
-    };
-    return MoneyValue.create(props);
-  }
 }

modules/customer-invoices/src/api/domain/value-objects/customer-invoice-number.ts

@@ -23,10 +23,10 @@ export class CustomerInvoiceNumber extends ValueObject<ICustomerInvoiceNumberPro
   }
 
   static create(value: string) {
-    const valueIsValid = CustomerInvoiceNumber.validate(value);
+    const result = CustomerInvoiceNumber.validate(value);
 
-    if (!valueIsValid.success) {
+    if (!result.success) {
-      const detail = valueIsValid.error.message;
+      const detail = result.error.message;
       return Result.fail(
         new DomainValidationError(
           CustomerInvoiceNumber.ERROR_CODE,

modules/customer-invoices/src/api/domain/value-objects/customer-invoice-serie.ts

@@ -23,10 +23,10 @@ export class CustomerInvoiceSerie extends ValueObject<ICustomerInvoiceSerieProps
   }
 
   static create(value: string) {
-    const valueIsValid = CustomerInvoiceSerie.validate(value);
+    const result = CustomerInvoiceSerie.validate(value);
 
-    if (!valueIsValid.success) {
+    if (!result.success) {
-      const detail = valueIsValid.error.message;
+      const detail = result.error.message;
       return Result.fail(
         new DomainValidationError(
           CustomerInvoiceSerie.ERROR_CODE,

modules/customer-invoices/src/api/index.ts

@@ -4,18 +4,18 @@ import { customerInvoicesRouter, models } from "./infrastructure";
 export const customerInvoicesAPIModule: IModuleServer = {
   name: "customer-invoices",
   version: "1.0.0",
-  dependencies: ["customers"],
+  dependencies: [],
 
   async init(params: ModuleParams) {
     // const contacts = getService<ContactsService>("contacts");
     const { logger } = params;
     customerInvoicesRouter(params);
-    logger.info("🚀 CustomerInvoices module initialized", { label: this.name });
+    logger.info("🚀 CustomerInvoices module initialized", { label: "customer-invoices" });
   },
   async registerDependencies(params) {
     const { database, logger } = params;
     logger.info("🚀 CustomerInvoices module dependencies registered", {
-      label: this.name,
+      label: "customer-invoices",
     });
     return {
       models,

modules/customer-invoices/src/api/infrastructure/dependencies.ts

@@ -8,8 +8,6 @@ import {
   GetCustomerInvoiceUseCase,
   ListCustomerInvoicesAssembler,
   ListCustomerInvoicesUseCase,
-  UpdateCustomerInvoiceAssembler,
-  UpdateCustomerInvoiceUseCase,
 } from "../application";
 import { CustomerInvoiceService, ICustomerInvoiceService } from "../domain";
 import { CustomerInvoiceMapper } from "./mappers";
@@ -24,13 +22,13 @@ type InvoiceDeps = {
     list: ListCustomerInvoicesAssembler;
     get: GetCustomerInvoiceAssembler;
     create: CreateCustomerInvoicesAssembler;
-    update: UpdateCustomerInvoiceAssembler;
+    //update: UpdateCustomerInvoiceAssembler;
   };
   build: {
     list: () => ListCustomerInvoicesUseCase;
     get: () => GetCustomerInvoiceUseCase;
     create: () => CreateCustomerInvoiceUseCase;
-    update: () => UpdateCustomerInvoiceUseCase;
+    //update: () => UpdateCustomerInvoiceUseCase;
     delete: () => DeleteCustomerInvoiceUseCase;
   };
   presenters: {
@@ -56,7 +54,7 @@ export function getInvoiceDependencies(params: ModuleParams): InvoiceDeps {
       list: new ListCustomerInvoicesAssembler(), // transforma domain → ListDTO
       get: new GetCustomerInvoiceAssembler(), // transforma domain → DetailDTO
       create: new CreateCustomerInvoicesAssembler(), // transforma domain → CreatedDTO
-      update: new UpdateCustomerInvoiceAssembler(), // transforma domain -> UpdateDTO
+      //update: new UpdateCustomerInvoiceAssembler(), // transforma domain -> UpdateDTO
     };
   }
 
@@ -72,8 +70,8 @@ export function getInvoiceDependencies(params: ModuleParams): InvoiceDeps {
       get: () => new GetCustomerInvoiceUseCase(_service!, transactionManager!, _assemblers!.get),
       create: () =>
         new CreateCustomerInvoiceUseCase(_service!, transactionManager!, _assemblers!.create),
-      update: () =>
+      /*update: () =>
-        new UpdateCustomerInvoiceUseCase(_service!, transactionManager!, _assemblers!.update),
+        new UpdateCustomerInvoiceUseCase(_service!, transactionManager!, _assemblers!.update),*/
       delete: () => new DeleteCustomerInvoiceUseCase(_service!, transactionManager!),
     },
     presenters: {

modules/customer-invoices/src/api/infrastructure/mappers/customer-invoice.mapper.ts

@@ -1,17 +1,9 @@
-import {
+import { ISequelizeMapper, MapperParamsType, SequelizeMapper } from "@erp/core/api";
-  ISequelizeMapper,
+import { UniqueID, UtcDate } from "@repo/rdx-ddd";
-  MapperParamsType,
-  SequelizeMapper,
-  ValidationErrorCollection,
-  ValidationErrorDetail,
-  extractOrPushError,
-} from "@erp/core/api";
-import { CurrencyCode, LanguageCode, UniqueID, UtcDate, maybeFromNullableVO } from "@repo/rdx-ddd";
 import { Result } from "@repo/rdx-utils";
 import {
   CustomerInvoice,
   CustomerInvoiceNumber,
-  CustomerInvoiceProps,
   CustomerInvoiceSerie,
   CustomerInvoiceStatus,
 } from "../../domain";
@@ -40,75 +32,50 @@ export class CustomerInvoiceMapper
     source: CustomerInvoiceModel,
     params?: MapperParamsType
   ): Result<CustomerInvoice, Error> {
-    const errors: ValidationErrorDetail[] = [];
+    const idOrError = UniqueID.create(source.id);
+    const statusOrError = CustomerInvoiceStatus.create(source.invoice_status);
+    const customerInvoiceSeriesOrError = CustomerInvoiceSerie.create(source.invoice_series);
+    const customerInvoiceNumberOrError = CustomerInvoiceNumber.create(source.invoice_number);
+    const issueDateOrError = UtcDate.createFromISO(source.issue_date);
+    const operationDateOrError = UtcDate.createFromISO(source.operation_date);
 
-    const invoiceId = extractOrPushError(UniqueID.create(source.id), "id", errors);
+    const result = Result.combine([
-    const companyId = extractOrPushError(UniqueID.create(source.company_id), "company_id", errors);
+      idOrError,
+      statusOrError,
+      customerInvoiceSeriesOrError,
+      customerInvoiceNumberOrError,
+      issueDateOrError,
+      operationDateOrError,
+    ]);
 
-    const status = extractOrPushError(
+    if (result.isFailure) {
-      CustomerInvoiceStatus.create(source.status),
+      return Result.fail(result.error);
-      "status",
-      errors
-    );
-    const series = extractOrPushError(CustomerInvoiceSerie.create(source.series), "series", errors);
-    const invoiceNumber = extractOrPushError(
-      CustomerInvoiceNumber.create(source.invoice_number),
-      "invoice_number",
-      errors
-    );
-    const issueDate = extractOrPushError(
-      UtcDate.createFromISO(source.issue_date),
-      "issue_date",
-      errors
-    );
-
-    const operationDate = extractOrPushError(
-      maybeFromNullableVO(source.operation_date, (value) => UtcDate.createFromISO(value)),
-      "operation_date",
-      errors
-    );
-
-    const languageCode = extractOrPushError(
-      LanguageCode.create(source.language_code),
-      "language_code",
-      errors
-    );
-
-    const currencyCode = extractOrPushError(
-      CurrencyCode.create(source.currency_code),
-      "currency_code",
-      errors
-    );
-
-    if (errors.length > 0) {
-      return Result.fail(
-        new ValidationErrorCollection("Customer invoice props mapping failed", errors)
-      );
     }
 
     // Mapear los items de la factura
-    /*const itemsOrErrors = this.customerInvoiceItemMapper.mapArrayToDomain(source.items, {
+    const itemsOrErrors = this.customerInvoiceItemMapper.mapArrayToDomain(source.items, {
       sourceParent: source,
       ...params,
     });
 
     if (itemsOrErrors.isFailure) {
       return Result.fail(itemsOrErrors.error);
-    }*/
+    }
 
-    const invoiceProps: CustomerInvoiceProps = {
+    const customerInvoiceCurrency = source.invoice_currency || "EUR";
-      status: status!,
-      series: series!,
-      invoiceNumber: invoiceNumber!,
-      issueDate: issueDate!,
-      operationDate: operationDate!,
 
-      languageCode: languageCode!,
+    return CustomerInvoice.create(
-      currencyCode: currencyCode!,
+      {
-      //items: itemsOrErrors.data,
+        status: statusOrError.data,
-    };
+        invoiceSeries: customerInvoiceSeriesOrError.data,
-
+        invoiceNumber: customerInvoiceNumberOrError.data,
-    return CustomerInvoice.create(invoiceProps, invoiceId);
+        issueDate: issueDateOrError.data,
+        operationDate: operationDateOrError.data,
+        currency: customerInvoiceCurrency,
+        items: itemsOrErrors.data,
+      },
+      idOrError.data
+    );
   }
 
   public mapToPersistence(

modules/customer-invoices/src/api/infrastructure/sequelize/customer-invoice-item.model.ts

@@ -1,4 +1,5 @@
 import {
+  CreationOptional,
   DataTypes,
   InferAttributes,
   InferCreationAttributes,
@@ -20,26 +21,26 @@ export class CustomerInvoiceItemModel extends Model<
   declare item_id: string;
   declare invoice_id: string;
 
-  declare parent_id: string;
+  declare parent_id: CreationOptional<string>;
   declare position: number;
   declare item_type: string;
 
-  declare description: string;
+  declare description: CreationOptional<string>;
 
-  declare quantity_amount: number;
+  declare quantity_amount: CreationOptional<number>;
-  declare quantity_scale: number;
+  declare quantity_scale: CreationOptional<number>;
 
-  declare unit_price_amount: number;
+  declare unit_price_amount: CreationOptional<number>;
-  declare unit_price_scale: number;
+  declare unit_price_scale: CreationOptional<number>;
 
-  declare subtotal_amount: number;
+  declare subtotal_amount: CreationOptional<number>;
-  declare subtotal_scale: number;
+  declare subtotal_scale: CreationOptional<number>;
 
-  declare discount_amount: number;
+  declare discount_amount: CreationOptional<number>;
-  declare discount_scale: number;
+  declare discount_scale: CreationOptional<number>;
 
-  declare total_amount: number;
+  declare total_amount: CreationOptional<number>;
-  declare total_scale: number;
+  declare total_scale: CreationOptional<number>;
 
   declare invoice: NonAttribute<CustomerInvoiceModel>;
 
@@ -64,14 +65,14 @@ export default (database: Sequelize) => {
       },
       invoice_id: {
         type: new DataTypes.UUID(),
-        allowNull: false,
+        primaryKey: true,
       },
       parent_id: {
         type: new DataTypes.UUID(),
         allowNull: true, // Puede ser nulo para elementos de nivel superior
       },
       position: {
-        type: new DataTypes.MEDIUMINT().UNSIGNED,
+        type: new DataTypes.MEDIUMINT(),
         autoIncrement: false,
         allowNull: false,
       },
@@ -83,7 +84,6 @@ export default (database: Sequelize) => {
       description: {
         type: new DataTypes.TEXT(),
         allowNull: true,
-        defaultValue: null,
       },
 
       quantity_amount: {
@@ -160,16 +160,8 @@ export default (database: Sequelize) => {
     },
     {
       sequelize: database,
-      tableName: "customer_invoice_items",
-
       underscored: true,
-
+      tableName: "customer_invoice_items",
-      indexes: [
-        { name: "invoice_idx", fields: ["invoice_id"], unique: false },
-        { name: "parent_idx", fields: ["parent_id"], unique: false },
-      ],
-
-      whereMergeStrategy: "and", // <- cómo tratar el merge de un scope
 
       defaultScope: {},
 

modules/customer-invoices/src/api/infrastructure/sequelize/customer-invoice.model.ts

@@ -1,4 +1,5 @@
 import {
+  CreationOptional,
   DataTypes,
   InferAttributes,
   InferCreationAttributes,
@@ -23,23 +24,22 @@ export class CustomerInvoiceModel extends Model<
   InferCreationAttributes<CustomerInvoiceModel, { omit: "items" }>
 > {
   declare id: string;
-  declare company_id: string;
 
-  declare status: string;
+  declare invoice_status: string;
-  declare series: string;
+  declare invoice_series: CreationOptional<string>;
-  declare invoice_number: string;
+  declare invoice_number: CreationOptional<string>;
-  declare issue_date: string;
+  declare issue_date: CreationOptional<string>;
-  declare operation_date: string;
+  declare operation_date: CreationOptional<string>;
-  declare language_code: string;
+  declare invoice_language: string;
-  declare currency_code: string;
+  declare invoice_currency: string;
 
   // Subtotal
-  declare subtotal_amount: number;
+  declare subtotal_amount: CreationOptional<number>;
-  declare subtotal_scale: number;
+  declare subtotal_scale: CreationOptional<number>;
 
   // Total
-  declare total_amount: number;
+  declare total_amount: CreationOptional<number>;
-  declare total_scale: number;
+  declare total_scale: CreationOptional<number>;
 
   // Relaciones
   declare items: NonAttribute<CustomerInvoiceItemModel[]>;
@@ -59,14 +59,14 @@ export class CustomerInvoiceModel extends Model<
 
   static hooks(database: Sequelize) {
     // Soft-cascade manual: al borrar una factura, marcamos items como borrados (paranoid).
-    /*CustomerInvoiceModel.addHook("afterDestroy", async (invoice, options) => {
+    CustomerInvoiceModel.addHook("afterDestroy", async (invoice, options) => {
       if (!invoice?.id) return;
       await CustomerInvoiceItemModel.destroy({
-        where: { invoice_id: invoice.id },
+        where: { invoiceId: invoice.id },
         individualHooks: true,
         transaction: options.transaction,
       });
-    });*/
+    });
   }
 }
 
@@ -78,18 +78,12 @@ export default (database: Sequelize) => {
         primaryKey: true,
       },
 
-      company_id: {
+      invoice_status: {
-        type: DataTypes.UUID,
-        allowNull: false,
-      },
-
-      status: {
         type: new DataTypes.STRING(),
         allowNull: false,
-        defaultValue: "draft",
       },
 
-      series: {
+      invoice_series: {
         type: new DataTypes.STRING(),
         allowNull: true,
         defaultValue: null,
@@ -113,16 +107,14 @@ export default (database: Sequelize) => {
         defaultValue: null,
       },
 
-      language_code: {
+      invoice_language: {
-        type: DataTypes.STRING(2),
+        type: new DataTypes.STRING(),
         allowNull: false,
-        defaultValue: "es",
       },
 
-      currency_code: {
+      invoice_currency: {
-        type: new DataTypes.STRING(3),
+        type: new DataTypes.STRING(3), // ISO 4217
         allowNull: false,
-        defaultValue: "EUR",
       },
 
       subtotal_amount: {
@@ -159,11 +151,7 @@ export default (database: Sequelize) => {
       updatedAt: "updated_at",
       deletedAt: "deleted_at",
 
-      indexes: [
+      indexes: [{ unique: true, fields: ["invoice_number"] }],
-        { name: "company_idx", fields: ["company_id"], unique: false },
-        { name: "idx_company_idx", fields: ["id", "company_id"], unique: true },
-        { unique: true, fields: ["invoice_number"] },
-      ],
 
       whereMergeStrategy: "and", // <- cómo tratar el merge de un scope
 

modules/customer-invoices/src/api/infrastructure/sequelize/customer-invoice.repository.ts

@@ -1,4 +1,4 @@
-import { EntityNotFoundError, SequelizeRepository, translateSequelizeError } from "@erp/core/api";
+import { SequelizeRepository } from "@erp/core/api";
 import { Criteria, CriteriaToSequelizeConverter } from "@repo/rdx-criteria/server";
 import { UniqueID } from "@repo/rdx-ddd";
 import { Collection, Result } from "@repo/rdx-utils";
@@ -11,6 +11,7 @@ export class CustomerInvoiceRepository
   extends SequelizeRepository<CustomerInvoice>
   implements ICustomerInvoiceRepository
 {
+  //private readonly model: typeof CustomerInvoiceModel;
   private readonly mapper!: ICustomerInvoiceMapper;
 
   constructor(mapper: ICustomerInvoiceMapper) {
@@ -51,6 +52,16 @@ export class CustomerInvoiceRepository
     };
   } */
 
+  async existsById(id: UniqueID, transaction?: Transaction): Promise<Result<boolean, Error>> {
+    try {
+      const result = await this._exists(CustomerInvoiceModel, "id", id.toString(), transaction);
+
+      return Result.ok(Boolean(result));
+    } catch (err: unknown) {
+      return Result.fail(translateSequelizeError(err));
+    }
+  }
+
   /**
    *
    * Persiste una nueva factura o actualiza una existente.
@@ -65,64 +76,29 @@ export class CustomerInvoiceRepository
   ): Promise<Result<CustomerInvoice, Error>> {
     try {
       const data = this.mapper.mapToPersistence(invoice);
-      const [instance] = await CustomerInvoiceModel.upsert(data, { transaction, returning: true });
+      await CustomerInvoiceModel.upsert(data, { transaction });
-      const savedInvoice = this.mapper.mapToDomain(instance);
+      return Result.ok(invoice);
-      return savedInvoice;
     } catch (err: unknown) {
       return Result.fail(translateSequelizeError(err));
     }
   }
 
-  /**
-   * Comprueba si existe una factura con un `id` dentro de una `company`.
-   *
-   * @param companyId - Identificador UUID de la empresa a la que pertenece la factura.
-   * @param id - Identificador UUID de la factura.
-   * @param transaction - Transacción activa para la operación.
-   * @returns Result<boolean, Error>
-   */
-  async existsByIdInCompany(
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction?: Transaction
-  ): Promise<Result<boolean, Error>> {
-    try {
-      const count = await CustomerInvoiceModel.count({
-        where: { id: id.toString(), company_id: companyId.toString() },
-        transaction,
-      });
-      return Result.ok(Boolean(count > 0));
-    } catch (error: any) {
-      return Result.fail(translateSequelizeError(error));
-    }
-  }
-
   /**
    *
    * Busca una factura por su identificador único.
-   *
-   * @param companyId - Identificador UUID de la empresa a la que pertenece la factura.
    * @param id - UUID de la factura.
    * @param transaction - Transacción activa para la operación.
    * @returns Result<CustomerInvoice, Error>
    */
-  async getByIdInCompany(
+  async findById(id: UniqueID, transaction: Transaction): Promise<Result<CustomerInvoice, Error>> {
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction: Transaction
-  ): Promise<Result<CustomerInvoice, Error>> {
     try {
-      const row = await CustomerInvoiceModel.findOne({
+      const rawData = await this._findById(CustomerInvoiceModel, id.toString(), { transaction });
-        where: { id: id.toString(), company_id: companyId.toString() },
-        transaction,
-      });
 
-      if (!row) {
+      if (!rawData) {
-        return Result.fail(new EntityNotFoundError("CustomerInvoice", "id", id.toString()));
+        return Result.fail(new Error(`Invoice with id ${id} not found.`));
       }
 
-      const customer = this.mapper.mapToDomain(row);
+      return this.mapper.mapToDomain(rawData);
-      return customer;
     } catch (err: unknown) {
       return Result.fail(translateSequelizeError(err));
     }
@@ -131,16 +107,13 @@ export class CustomerInvoiceRepository
   /**
    *
    * Consulta facturas usando un objeto Criteria (filtros, orden, paginación).
-   *
-   * @param companyId - Identificador UUID de la empresa a la que pertenece el cliente.
    * @param criteria - Criterios de búsqueda.
    * @param transaction - Transacción activa para la operación.
    * @returns Result<CustomerInvoice[], Error>
    *
    * @see Criteria
    */
-  public async findByCriteriaInCompany(
+  public async findByCriteria(
-    companyId: UniqueID,
     criteria: Criteria,
     transaction: Transaction
   ): Promise<Result<Collection<CustomerInvoice>, Error>> {
@@ -148,11 +121,6 @@ export class CustomerInvoiceRepository
       const converter = new CriteriaToSequelizeConverter();
       const query = converter.convert(criteria);
 
-      query.where = {
-        ...query.where,
-        company_id: companyId.toString(),
-      };
-
       const instances = await CustomerInvoiceModel.findAll({
         ...query,
         transaction,
@@ -167,23 +135,13 @@ export class CustomerInvoiceRepository
   /**
    *
    * Elimina o marca como eliminada una factura.
-   *
-   * @param companyId - Identificador UUID de la empresa a la que pertenece el cliente.
    * @param id - UUID de la factura a eliminar.
    * @param transaction - Transacción activa para la operación.
    * @returns Result<void, Error>
    */
-  async deleteByIdInCompany(
+  async deleteById(id: UniqueID, transaction: any): Promise<Result<void, Error>> {
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction: any
-  ): Promise<Result<void, Error>> {
     try {
-      const deleted = await CustomerInvoiceModel.destroy({
+      await this._deleteById(CustomerInvoiceModel, id, false, transaction);
-        where: { id: id.toString(), company_id: companyId.toString() },
-        transaction,
-      });
-
       return Result.ok<void>();
     } catch (err: unknown) {
       return Result.fail(translateSequelizeError(err));

modules/customers/src/api/domain/aggregates/customer.ts

@@ -7,6 +7,7 @@ import {
   PhoneNumber,
   PostalAddress,
   PostalAddressPatchProps,
+  PostalAddressSnapshot,
   TINNumber,
   TaxCode,
   TextValue,
@@ -40,6 +41,32 @@ export interface CustomerProps {
   currencyCode: CurrencyCode;
 }
 
+export interface CustomerSnapshot {
+  id: string;
+  companyId: string;
+  status: string;
+  reference: string | null;
+
+  isCompany: boolean;
+  name: string;
+  tradeName: string | null;
+
+  tin: string | null;
+
+  address: PostalAddressSnapshot; // snapshot serializable del VO PostalAddress
+
+  email: string | null;
+  phone: string | null;
+  fax: string | null;
+  website: string | null;
+
+  legalRecord: string | null;
+  defaultTaxes: string[];
+
+  languageCode: string;
+  currencyCode: string;
+}
+
 export type CustomerPatchProps = Partial<Omit<CustomerProps, "companyId" | "address">> & {
   address?: PostalAddressPatchProps;
 };

modules/customers/src/api/domain/repositories/customer-repository.interface.ts

@@ -4,7 +4,8 @@ import { Collection, Result } from "@repo/rdx-utils";
 import { Customer } from "../aggregates";
 
 /**
- * Interfaz del repositorio para el agregado `Customer`.
+ * Contrato del repositorio de Customers.
+ * Define la interfaz de persistencia para el agregado `Customer`.
  * El escopado multitenant está representado por `companyId`.
  */
 export interface ICustomerRepository {
@@ -34,8 +35,7 @@ export interface ICustomerRepository {
   ): Promise<Result<Customer, Error>>;
 
   /**
-   * Recupera múltiples customers dentro de una empresa
+   * Recupera múltiples customers dentro de una empresa según un criterio dinámico (búsqueda, paginación, etc.).
-   * según un criterio dinámico (búsqueda, paginación, etc.).
    * El resultado está encapsulado en un objeto `Collection<T>`.
    */
   findByCriteriaInCompany(
@@ -47,11 +47,6 @@ export interface ICustomerRepository {
   /**
    * Elimina un Customer por su ID, dentro de una empresa.
    * Retorna `void` si se elimina correctamente, o `NotFoundError` si no existía.
-   *
    */
-  deleteByIdInCompany(
+  deleteByIdInCompany(companyId: UniqueID, id: UniqueID, transaction: any): Promise<Result<void>>;
-    companyId: UniqueID,
-    id: UniqueID,
-    transaction: any
-  ): Promise<Result<void, Error>>;
 }

modules/customers/src/api/index.ts

@@ -10,12 +10,12 @@ export const customersAPIModule: IModuleServer = {
     // const contacts = getService<ContactsService>("contacts");
     const { logger } = params;
     customersRouter(params);
-    logger.info("🚀 Customers module initialized", { label: this.name });
+    logger.info("🚀 Customers module initialized", { label: "customers" });
   },
   async registerDependencies(params) {
     const { database, logger } = params;
     logger.info("🚀 Customers module dependencies registered", {
-      label: this.name,
+      label: "customers",
     });
     return {
       models,

modules/customers/src/api/infrastructure/express/controllers/update-customer.controller.ts

@@ -17,7 +17,7 @@ export class UpdateCustomerController extends ExpressController {
     const result = await this.useCase.execute({ customer_id, companyId, dto });
 
     return result.match(
-      (data) => this.ok(data),
+      (data) => this.created(data),
       (err) => this.handleError(err)
     );
   }

modules/customers/src/api/infrastructure/mappers/customer-item.mapper.ts

@@ -0,0 +1,128 @@
+import { ISequelizeMapper, MapperParamsType, SequelizeMapper } from "@erp/core/api";
+import { UniqueID } from "@repo/rdx-ddd";
+import { Result } from "@repo/rdx-utils";
+import { InferCreationAttributes } from "sequelize";
+import {
+  Customer,
+  CustomerItem,
+  CustomerItemDescription,
+  CustomerItemDiscount,
+  CustomerItemQuantity,
+  CustomerItemUnitPrice,
+} from "../../domain";
+import { CustomerItemCreationAttributes, CustomerItemModel, CustomerModel } from "../sequelize";
+
+export interface ICustomerItemMapper
+  extends ISequelizeMapper<CustomerItemModel, CustomerItemCreationAttributes, CustomerItem> {}
+
+export class CustomerItemMapper
+  extends SequelizeMapper<CustomerItemModel, CustomerItemCreationAttributes, CustomerItem>
+  implements ICustomerItemMapper
+{
+  public mapToDomain(
+    source: CustomerItemModel,
+    params?: MapperParamsType
+  ): Result<CustomerItem, Error> {
+    const { sourceParent } = params as { sourceParent: CustomerModel };
+
+    // Validación y creación de ID único
+    const idOrError = UniqueID.create(source.item_id);
+    if (idOrError.isFailure) {
+      return Result.fail(idOrError.error);
+    }
+
+    // Validación y creación de descripción
+    const descriptionOrError = CustomerItemDescription.create(source.description || "");
+    if (descriptionOrError.isFailure) {
+      return Result.fail(descriptionOrError.error);
+    }
+
+    // Validación y creación de cantidad
+    const quantityOrError = CustomerItemQuantity.create({
+      amount: source.quantity_amount,
+      scale: source.quantity_scale,
+    });
+    if (quantityOrError.isFailure) {
+      return Result.fail(quantityOrError.error);
+    }
+
+    // Validación y creación de precio unitario
+    const unitPriceOrError = CustomerItemUnitPrice.create({
+      amount: source.unit_price_amount,
+      scale: source.unit_price_scale,
+      currency_code: sourceParent.invoice_currency,
+    });
+    if (unitPriceOrError.isFailure) {
+      return Result.fail(unitPriceOrError.error);
+    }
+
+    // Validación y creación de descuento
+    const discountOrError = CustomerItemDiscount.create({
+      amount: source.discount_amount || 0,
+      scale: source.discount_scale || 0,
+    });
+    if (discountOrError.isFailure) {
+      return Result.fail(discountOrError.error);
+    }
+
+    // Combinación de resultados
+    const result = Result.combine([
+      idOrError,
+      descriptionOrError,
+      quantityOrError,
+      unitPriceOrError,
+      discountOrError,
+    ]);
+
+    if (result.isFailure) {
+      return Result.fail(result.error);
+    }
+
+    // Creación del objeto de dominio
+    return CustomerItem.create(
+      {
+        description: descriptionOrError.data,
+        quantity: quantityOrError.data,
+        unitPrice: unitPriceOrError.data,
+        discount: discountOrError.data,
+      },
+      idOrError.data
+    );
+  }
+
+  public mapToPersistence(
+    source: CustomerItem,
+    params?: MapperParamsType
+  ): InferCreationAttributes<CustomerItemModel, {}> {
+    const { index, sourceParent } = params as {
+      index: number;
+      sourceParent: Customer;
+    };
+
+    const lineData = {
+      parent_id: undefined,
+      invoice_id: sourceParent.id.toPrimitive(),
+      item_type: "simple",
+      position: index,
+
+      item_id: source.id.toPrimitive(),
+      description: source.description.toPrimitive(),
+
+      quantity_amount: source.quantity.toPrimitive().amount,
+      quantity_scale: source.quantity.toPrimitive().scale,
+
+      unit_price_amount: source.unitPrice.toPrimitive().amount,
+      unit_price_scale: source.unitPrice.toPrimitive().scale,
+
+      subtotal_amount: source.subtotalPrice.toPrimitive().amount,
+      subtotal_scale: source.subtotalPrice.toPrimitive().scale,
+
+      discount_amount: source.discount.toPrimitive().amount,
+      discount_scale: source.discount.toPrimitive().scale,
+
+      total_amount: source.totalPrice.toPrimitive().amount,
+      total_scale: source.totalPrice.toPrimitive().scale,
+    };
+    return lineData;
+  }
+}

modules/customers/src/api/infrastructure/sequelize/customer.model.ts

@@ -171,7 +171,6 @@ export default (database: Sequelize) => {
       sequelize: database,
       tableName: "customers",
 
-      underscored: true,
       paranoid: true, // softs deletes
       timestamps: true,
 

modules/customers/src/api/infrastructure/sequelize/customer.repository.ts

@@ -11,6 +11,7 @@ export class CustomerRepository
   extends SequelizeRepository<Customer>
   implements ICustomerRepository
 {
+  //private readonly model: typeof CustomerModel;
   private readonly mapper!: ICustomerMapper;
 
   constructor(mapper: ICustomerMapper) {
@@ -148,6 +149,7 @@ export class CustomerRepository
 
       return Result.ok<void>();
     } catch (err: unknown) {
+      // , `Error deleting customer ${id} in company ${companyId}`
       return Result.fail(translateSequelizeError(err));
     }
   }