.

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

@@ -96,14 +96,10 @@ export class IssuedInvoice
   }
 
   static create(props: IIssuedInvoiceCreateProps, id?: UniqueID): Result<IssuedInvoice, Error> {
-    if (!props.recipient) {
+    const validationResult = IssuedInvoice.validateCreateProps(props);
-      return Result.fail(
+
-        new DomainValidationError(
+    if (validationResult.isFailure) {
-          "MISSING_RECIPIENT",
+      return Result.fail(validationResult.error);
-          "recipient",
-          "Issued invoice requires recipient"
-        )
-      );
     }
 
     const internalItems = IssuedInvoiceItems.create({
@@ -132,6 +128,20 @@ export class IssuedInvoice
     return Result.ok(issuedInvoice);
   }
 
+  private static validateCreateProps(props: IIssuedInvoiceCreateProps): Result<void, Error> {
+    if (!props.recipient) {
+      return Result.fail(
+        new DomainValidationError(
+          "MISSING_RECIPIENT",
+          "recipient",
+          "Issued invoice requires recipient"
+        )
+      );
+    }
+
+    return Result.ok();
+  }
+
   // Rehidratación desde persistencia
   static rehydrate(
     props: InternalIssuedInvoiceProps,

modules/customer-invoices/src/api/domain/proformas/aggregates/proforma.aggregate.ts

@@ -116,6 +116,12 @@ export class Proforma extends AggregateRoot<InternalProformaProps> implements IP
 
   // Creación funcional
   static create(props: IProformaCreateProps, id?: UniqueID): Result<Proforma, Error> {
+    const validationResult = Proforma.validateCreateProps(props);
+
+    if (validationResult.isFailure) {
+      return Result.fail(validationResult.error);
+    }
+
     const internalItems = ProformaItems.create({
       items: [],
       languageCode: props.languageCode,
@@ -141,6 +147,10 @@ export class Proforma extends AggregateRoot<InternalProformaProps> implements IP
     return Result.ok(proforma);
   }
 
+  private static validateCreateProps(props: IProformaCreateProps): Result<void, Error> {
+    return Result.ok();
+  }
+
   // Rehidratación desde persistencia
   static rehydrate(props: InternalProformaProps, items: ProformaItems, id: UniqueID): Proforma {
     return new Proforma(props, items, id);

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

@@ -99,6 +99,12 @@ type CustomerInternalProps = Omit<ICustomerCreateProps, "address" | "defaultTaxe
 
 export class Customer extends AggregateRoot<CustomerInternalProps> implements ICustomer {
   static create(props: ICustomerCreateProps, id?: UniqueID): Result<Customer, Error> {
+    const validationResult = Customer.validateCreateProps(props);
+
+    if (validationResult.isFailure) {
+      return Result.fail(validationResult.error);
+    }
+
     const { address, defaultTaxes, ...internalProps } = props;
 
     const postalAddressResult = PostalAddress.create(address);
@@ -132,6 +138,10 @@ export class Customer extends AggregateRoot<CustomerInternalProps> implements IC
     return Result.ok(contact);
   }
 
+  private static validateCreateProps(props: ICustomerCreateProps): Result<void, Error> {
+    return Result.ok();
+  }
+
   // Rehidratación desde persistencia
   static rehydrate(props: CustomerInternalProps, id: UniqueID): Customer {
     return new Customer(props, id);

modules/customers/src/api/index.ts

@@ -1,16 +1,11 @@
 import type { IModuleServer } from "@erp/core/api";
 
-import { type CustomerPublicServices, customersRouter, models } from "./infrastructure";
+import type { ICustomerPublicServices } from "./application";
-import {
+import { customersRouter, models } from "./infrastructure";
-  type CustomersInternalDeps,
+import { buildCustomerPublicServices, buildCustomersDependencies } from "./infrastructure/di";
-  buildCustomerPublicServices,
-  buildCustomersDependencies,
-} from "./infrastructure/di";
 
 export * from "./infrastructure/sequelize";
 
-export type { CustomerPublicServices };
-
 export const customersAPIModule: IModuleServer = {
   name: "customers",
   version: "1.0.0",
@@ -30,7 +25,10 @@ export const customersAPIModule: IModuleServer = {
     const internal = buildCustomersDependencies(params);
 
     // 2) Servicios públicos (Application Services)
-    const customersServices: CustomerPublicServices = buildCustomerPublicServices(params, internal);
+    const customersServices: ICustomerPublicServices = buildCustomerPublicServices(
+      params,
+      internal
+    );
 
     logger.info("🚀 Customers module dependencies registered", {
       label: this.name,
@@ -60,11 +58,8 @@ export const customersAPIModule: IModuleServer = {
   async start(params) {
     const { app, baseRoutePath, logger, getInternal } = params;
 
-    // Recuperamos el dominio interno del módulo
-    const customersInternalDeps = getInternal<CustomersInternalDeps>("customers");
-
     // Registro de rutas HTTP
-    customersRouter(params, customersInternalDeps);
+    customersRouter(params);
 
     logger.info("🚀 Customers module started", {
       label: this.name,

modules/customers/src/api/infrastructure/express/customers.routes.ts

@@ -1,5 +1,5 @@
 import { mockUser, requireAuthenticated, requireCompanyContext } from "@erp/auth/api";
-import { type ModuleParams, type RequestWithAuth, validateRequest } from "@erp/core/api";
+import { type RequestWithAuth, type StartParams, validateRequest } from "@erp/core/api";
 import { type NextFunction, type Request, type Response, Router } from "express";
 
 import {
@@ -18,11 +18,16 @@ import {
   UpdateCustomerController,
 } from "./controllers";
 
-export const customersRouter = (params: ModuleParams, deps: CustomersInternalDeps) => {
+export const customersRouter = (params: StartParams) => {
-  const { app, config } = params;
+  const { app, config, getInternal } = params;
+
+  // Recuperamos el dominio interno del módulo
+  const deps = getInternal<CustomersInternalDeps>("customers");
 
   const router: Router = Router({ mergeParams: true });
 
+  // ----------------------------------------------
+
   // 🔐 Autenticación + Tenancy para TODO el router
   if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "production") {
     router.use(

modules/factuges/src/api/index.ts

@@ -46,7 +46,7 @@ export const factugesAPIModule: IModuleServer = {
    * - NO construye dominio
    */
   async start(params) {
-    const { app, baseRoutePath, logger, getInternal, getService, listServices } = params;
+    const { logger } = params;
 
     // Registro de rutas HTTP
     factugesRouter(params);