@cosmneo/onion-lasagna 0.1.0

package/dist/backend/core/onion-layers.cjs

@@ -0,0 +1,2302 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backend/core/onion-layers/index.ts
+var onion_layers_exports = {};
+__export(onion_layers_exports, {
+  AccessDeniedError: () => AccessDeniedError,
+  BaseAggregateRoot: () => BaseAggregateRoot,
+  BaseAuditByVo: () => BaseAuditByVo,
+  BaseAuditInfoVo: () => BaseAuditInfoVo,
+  BaseAuditOnVo: () => BaseAuditOnVo,
+  BaseController: () => BaseController,
+  BaseDomainEvent: () => BaseDomainEvent,
+  BaseEmailVo: () => BaseEmailVo,
+  BaseEntity: () => BaseEntity,
+  BaseInboundAdapter: () => BaseInboundAdapter,
+  BaseLongTextVo: () => BaseLongTextVo,
+  BaseMediumTextVo: () => BaseMediumTextVo,
+  BaseOutboundAdapter: () => BaseOutboundAdapter,
+  BasePaginationVo: () => BasePaginationVo,
+  BaseShortTextVo: () => BaseShortTextVo,
+  BaseUuidV4Vo: () => BaseUuidV4Vo,
+  BaseUuidV7Vo: () => BaseUuidV7Vo,
+  BaseValueObject: () => BaseValueObject,
+  ConflictError: () => ConflictError,
+  ControllerError: () => ControllerError,
+  DbError: () => DbError,
+  DomainError: () => DomainError,
+  ExternalServiceError: () => ExternalServiceError,
+  GuardedController: () => GuardedController,
+  InfraError: () => InfraError,
+  InvalidRequestError: () => InvalidRequestError,
+  InvariantViolationError: () => InvariantViolationError,
+  Money: () => Money,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  Order: () => Order,
+  OrderAlreadyShippedError: () => OrderAlreadyShippedError,
+  OrderCancelledEvent: () => OrderCancelledEvent,
+  OrderId: () => OrderId,
+  OrderItem: () => OrderItem,
+  OrderItemId: () => OrderItemId,
+  OrderPlacedEvent: () => OrderPlacedEvent,
+  OrderStatus: () => OrderStatus,
+  PartialLoadError: () => PartialLoadError,
+  SKIP_VALUE_OBJECT_VALIDATION: () => SKIP_VALUE_OBJECT_VALIDATION,
+  TimeoutError: () => TimeoutError,
+  UnprocessableError: () => UnprocessableError,
+  UseCaseError: () => UseCaseError,
+  assertHttpResponse: () => assertHttpResponse,
+  canAddOrderItem: () => canAddOrderItem,
+  canCancelOrder: () => canCancelOrder,
+  computeRoutePath: () => computeRoutePath,
+  defaultOrderStatus: () => defaultOrderStatus,
+  defineSystemMetadata: () => defineSystemMetadata,
+  isHttpResponse: () => isHttpResponse
+});
+module.exports = __toCommonJS(onion_layers_exports);
+
+// src/backend/core/global/exceptions/coded-error.error.ts
+var CodedError = class extends Error {
+  /** Machine-readable error code for programmatic handling. */
+  code;
+  /**
+   * Creates a new CodedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error message
+   * @param options.code - Machine-readable error code from ErrorCodes registry or custom string
+   * @param options.cause - Optional underlying error that caused this error
+   */
+  constructor({
+    message,
+    code,
+    cause
+  }) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    if (cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: cause,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+    }
+  }
+  /**
+   * Factory method to create a typed error from a caught error.
+   *
+   * Subclasses should override this to provide proper error transformation.
+   * Designed for use with {@link wrapErrorAsync} and {@link wrapError}.
+   *
+   * @param _cause - The original caught error
+   * @returns A new CodedError instance
+   * @throws {Error} If not overridden by subclass
+   *
+   * @example
+   * ```typescript
+   * class NotFoundError extends UseCaseError {
+   *   static override fromError(cause: unknown): NotFoundError {
+   *     return new NotFoundError({
+   *       message: 'Resource not found',
+   *       cause,
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  static fromError(_cause) {
+    throw new Error(`${this.name}.fromError() must be implemented by subclass`);
+  }
+};
+
+// src/backend/core/global/exceptions/error-codes.const.ts
+var ErrorCodes = {
+  /**
+   * Domain layer error codes.
+   * Used for business rule violations and invariant failures.
+   */
+  Domain: {
+    /** Generic domain error */
+    DOMAIN_ERROR: "DOMAIN_ERROR",
+    /** Business invariant was violated */
+    INVARIANT_VIOLATION: "INVARIANT_VIOLATION",
+    /** Aggregate was partially loaded (missing required relations) */
+    PARTIAL_LOAD: "PARTIAL_LOAD"
+  },
+  /**
+   * Application layer (use case) error codes.
+   * Used for orchestration failures and business operation errors.
+   */
+  App: {
+    /** Generic use case error */
+    USE_CASE_ERROR: "USE_CASE_ERROR",
+    /** Requested resource was not found */
+    NOT_FOUND: "NOT_FOUND",
+    /** Resource state conflict (e.g., duplicate, already exists) */
+    CONFLICT: "CONFLICT",
+    /** Request is valid but cannot be processed due to business rules */
+    UNPROCESSABLE: "UNPROCESSABLE"
+  },
+  /**
+   * Infrastructure layer error codes.
+   * Used for data access, external services, and I/O failures.
+   */
+  Infra: {
+    /** Generic infrastructure error */
+    INFRA_ERROR: "INFRA_ERROR",
+    /** Database operation failed */
+    DB_ERROR: "DB_ERROR",
+    /** Network connectivity or communication error */
+    NETWORK_ERROR: "NETWORK_ERROR",
+    /** Operation timed out */
+    TIMEOUT_ERROR: "TIMEOUT_ERROR",
+    /** External/third-party service error */
+    EXTERNAL_SERVICE_ERROR: "EXTERNAL_SERVICE_ERROR"
+  },
+  /**
+   * Presentation layer error codes.
+   * Used for controller, request handling, and authorization errors.
+   */
+  Presentation: {
+    /** Generic controller error */
+    CONTROLLER_ERROR: "CONTROLLER_ERROR",
+    /** Request denied due to authorization failure */
+    ACCESS_DENIED: "ACCESS_DENIED",
+    /** Request validation failed (malformed input) */
+    INVALID_REQUEST: "INVALID_REQUEST"
+  },
+  /**
+   * Global/cross-cutting error codes.
+   * Used for validation and other cross-layer concerns.
+   */
+  Global: {
+    /** Object/schema validation failed */
+    OBJECT_VALIDATION_ERROR: "OBJECT_VALIDATION_ERROR"
+  }
+};
+
+// src/backend/core/global/exceptions/object-validation.error.ts
+var ObjectValidationError = class _ObjectValidationError extends CodedError {
+  /**
+   * Array of field-level validation errors.
+   *
+   * Each entry contains:
+   * - `field`: Dot-notation path to the invalid field (e.g., 'user.email')
+   * - `message`: Human-readable validation failure message
+   */
+  validationErrors;
+  /**
+   * Creates a new ObjectValidationError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable summary message
+   * @param options.code - Machine-readable error code (default: 'OBJECT_VALIDATION_ERROR')
+   * @param options.cause - Optional underlying error from validation library
+   * @param options.validationErrors - Array of field-level validation errors
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Global.OBJECT_VALIDATION_ERROR,
+    cause,
+    validationErrors
+  }) {
+    super({ message, code, cause });
+    this.validationErrors = validationErrors;
+  }
+  /**
+   * Creates an ObjectValidationError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ObjectValidationError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ObjectValidationError({
+      message: cause instanceof Error ? cause.message : "Validation failed",
+      cause,
+      validationErrors: []
+    });
+  }
+};
+
+// src/backend/core/global/utils/wrap-error.util.ts
+function wrapErrorUnless(fn, errorFactory, passthroughTypes) {
+  try {
+    return fn();
+  } catch (error) {
+    if (passthroughTypes.some((Type) => error instanceof Type)) {
+      throw error;
+    }
+    throw errorFactory(error);
+  }
+}
+async function wrapErrorUnlessAsync(fn, errorFactory, passthroughTypes) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (passthroughTypes.some((Type) => error instanceof Type)) {
+      throw error;
+    }
+    throw errorFactory(error);
+  }
+}
+
+// src/backend/core/onion-layers/app/exceptions/use-case.error.ts
+var UseCaseError = class _UseCaseError extends CodedError {
+  /**
+   * Creates a new UseCaseError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'USE_CASE_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.USE_CASE_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a UseCaseError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new UseCaseError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _UseCaseError({
+      message: cause instanceof Error ? cause.message : "Use case error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/domain/exceptions/domain.error.ts
+var DomainError = class _DomainError extends CodedError {
+  /**
+   * Creates a new DomainError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'DOMAIN_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Domain.DOMAIN_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a DomainError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new DomainError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _DomainError({
+      message: cause instanceof Error ? cause.message : "Domain error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/infra/exceptions/infra.error.ts
+var InfraError = class _InfraError extends CodedError {
+  /**
+   * Creates a new InfraError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'INFRA_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Infra.INFRA_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an InfraError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new InfraError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _InfraError({
+      message: cause instanceof Error ? cause.message : "Infrastructure error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/app/classes/base-inbound-adapter.class.ts
+var BaseInboundAdapter = class {
+  /**
+   * Executes the use case with error boundary protection.
+   *
+   * Known error types are re-thrown as-is to preserve error semantics.
+   * Unknown errors are wrapped in a UseCaseError to maintain error hierarchy.
+   *
+   * @param input - Validated input DTO
+   * @returns Promise resolving to the output DTO
+   * @throws {ObjectValidationError} For validation failures (propagated to controller)
+   * @throws {UseCaseError} For use case failures or wrapped unknown errors
+   * @throws {DomainError} For domain invariant violations
+   * @throws {InfraError} For infrastructure failures
+   */
+  async execute(input) {
+    return wrapErrorUnlessAsync(
+      () => this.handle(input),
+      (cause) => new UseCaseError({ message: "Unexpected use case handler error", cause }),
+      [ObjectValidationError, UseCaseError, DomainError, InfraError]
+    );
+  }
+};
+
+// src/backend/core/onion-layers/app/exceptions/not-found.error.ts
+var NotFoundError = class _NotFoundError extends UseCaseError {
+  /**
+   * Creates a new NotFoundError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of what was not found
+   * @param options.code - Machine-readable error code (default: 'NOT_FOUND')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.NOT_FOUND,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a NotFoundError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new NotFoundError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _NotFoundError({
+      message: cause instanceof Error ? cause.message : "Resource not found",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/app/exceptions/conflict.error.ts
+var ConflictError = class _ConflictError extends UseCaseError {
+  /**
+   * Creates a new ConflictError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the conflict
+   * @param options.code - Machine-readable error code (default: 'CONFLICT')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.CONFLICT,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a ConflictError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ConflictError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ConflictError({
+      message: cause instanceof Error ? cause.message : "Conflict error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/app/exceptions/unprocessable.error.ts
+var UnprocessableError = class _UnprocessableError extends UseCaseError {
+  /**
+   * Creates a new UnprocessableError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why the request cannot be processed
+   * @param options.code - Machine-readable error code (default: 'UNPROCESSABLE')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.UNPROCESSABLE,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an UnprocessableError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new UnprocessableError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _UnprocessableError({
+      message: cause instanceof Error ? cause.message : "Unprocessable request",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/domain/classes/base-entity.class.ts
+var BaseEntity = class {
+  _id;
+  _props;
+  _version;
+  /**
+   * Creates a new Entity instance.
+   *
+   * @param id - The unique identifier for this entity
+   * @param props - The entity's properties/state (should be composed of Value Objects)
+   * @param version - Optional version number for optimistic locking (defaults to 0)
+   */
+  constructor(id, props, version = 0) {
+    this._id = id;
+    this._props = props;
+    this._version = version;
+  }
+  /**
+   * The unique identifier for this entity.
+   *
+   * @returns The entity's ID of type TId
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * The entity's properties/state.
+   *
+   * Protected to encourage encapsulation via specific getters.
+   * Subclasses should expose individual properties as needed.
+   *
+   * @returns The entity's properties of type TProps
+   */
+  get props() {
+    return this._props;
+  }
+  /**
+   * The version number for optimistic locking.
+   *
+   * Use this to detect concurrent modifications:
+   * - Load entity with version N
+   * - Attempt to save with "WHERE version = N"
+   * - If rows affected = 0, another process modified the entity
+   *
+   * @returns The current version number
+   */
+  get version() {
+    return this._version;
+  }
+  /**
+   * Compares this Entity with another for equality.
+   *
+   * Entities are equal if they have the same identity (ID).
+   * This differs from Value Objects which compare by value.
+   *
+   * @param other - The Entity to compare with
+   * @returns `true` if the IDs are equal, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * const user1 = User.create(PersonName.create('John'), Email.create('john@example.com'));
+   * const user2 = User.fromPersistence(user1.id, { name: PersonName.create('John Updated'), ... }, 1);
+   * user1.equals(user2); // true - same ID, different state
+   * ```
+   */
+  equals(other) {
+    if (this === other) return true;
+    return this.idEquals(this._id, other._id);
+  }
+  /**
+   * Compares two IDs for equality.
+   *
+   * Since TId must extend BaseValueObject, we use the value object's
+   * `equals` method for comparison.
+   *
+   * @param a - First ID to compare
+   * @param b - Second ID to compare
+   * @returns `true` if IDs are equal, `false` otherwise
+   */
+  idEquals(a, b) {
+    if (a === b) return true;
+    return a.equals(b);
+  }
+  /**
+   * Returns the next version number.
+   *
+   * Call this when persisting changes to implement optimistic locking.
+   * The repository should save with version + 1.
+   *
+   * @returns The next version number (current + 1)
+   *
+   * @example
+   * ```typescript
+   * // In repository
+   * async save(entity: User): Promise<void> {
+   *   await this.db.update({
+   *     ...entity.toPersistence(),
+   *     version: entity.nextVersion(),
+   *   }).where({ id: entity.id, version: entity.version });
+   * }
+   * ```
+   */
+  nextVersion() {
+    return this._version + 1;
+  }
+};
+
+// src/backend/core/onion-layers/domain/classes/base-aggregate-root.class.ts
+var BaseAggregateRoot = class extends BaseEntity {
+  _domainEvents = [];
+  /**
+   * Creates a new Aggregate Root instance.
+   *
+   * @param id - The unique identifier for this aggregate
+   * @param props - The aggregate's properties/state (should be composed of Value Objects)
+   * @param version - Optional version number for optimistic locking (defaults to 0)
+   */
+  constructor(id, props, version) {
+    super(id, props, version);
+  }
+  /**
+   * Adds a domain event to be published after persistence.
+   *
+   * Call this method when a significant domain action occurs.
+   * Events are collected and should be published by the repository
+   * after successfully persisting the aggregate.
+   *
+   * @param event - The domain event to add
+   *
+   * @example
+   * ```typescript
+   * confirm(): void {
+   *   this._props.status = OrderStatus.confirmed();
+   *   this.addDomainEvent(new OrderConfirmedEvent({
+   *     orderId: this.id.value,
+   *     confirmedAt: new Date(),
+   *   }));
+   * }
+   * ```
+   */
+  addDomainEvent(event) {
+    this._domainEvents.push(event);
+  }
+  /**
+   * Returns and clears all pending domain events.
+   *
+   * This method should be called by the repository after successfully
+   * persisting the aggregate. The events are cleared to prevent
+   * duplicate publishing.
+   *
+   * @returns Array of domain events that were pending
+   *
+   * @example
+   * ```typescript
+   * // In repository
+   * async save(order: Order): Promise<void> {
+   *   await this.db.transaction(async (tx) => {
+   *     await tx.orders.upsert(order.toPersistence());
+   *   });
+   *
+   *   // Only publish after successful persistence
+   *   const events = order.pullDomainEvents();
+   *   for (const event of events) {
+   *     await this.eventBus.publish(event);
+   *   }
+   * }
+   * ```
+   */
+  pullDomainEvents() {
+    const events = [...this._domainEvents];
+    this._domainEvents = [];
+    return events;
+  }
+  /**
+   * Returns pending domain events without clearing them.
+   *
+   * Useful for inspection or testing without affecting the event queue.
+   *
+   * @returns Array of pending domain events
+   */
+  peekDomainEvents() {
+    return [...this._domainEvents];
+  }
+  /**
+   * Checks if there are any pending domain events.
+   *
+   * @returns `true` if there are events waiting to be published
+   *
+   * @example
+   * ```typescript
+   * if (order.hasDomainEvents) {
+   *   const events = order.pullDomainEvents();
+   *   await eventBus.publishAll(events);
+   * }
+   * ```
+   */
+  get hasDomainEvents() {
+    return this._domainEvents.length > 0;
+  }
+  /**
+   * Clears all pending domain events without returning them.
+   *
+   * Use with caution - this discards events that haven't been published.
+   * Useful in testing or when intentionally discarding events.
+   */
+  clearDomainEvents() {
+    this._domainEvents = [];
+  }
+};
+
+// src/backend/core/onion-layers/domain/classes/base-domain-event.class.ts
+var BaseDomainEvent = class _BaseDomainEvent {
+  _eventId;
+  _eventName;
+  _aggregateId;
+  _occurredOn;
+  _payload;
+  /**
+   * Deep clones an object, handling Date objects specially.
+   *
+   * @param obj - The object to clone
+   * @returns A deep copy of the object
+   */
+  static deepClone(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (obj instanceof Date) {
+      return new Date(obj.getTime());
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => _BaseDomainEvent.deepClone(item));
+    }
+    const cloned = {};
+    for (const key of Object.keys(obj)) {
+      cloned[key] = _BaseDomainEvent.deepClone(obj[key]);
+    }
+    return cloned;
+  }
+  /**
+   * Recursively freezes an object and all nested objects.
+   *
+   * @param obj - The object to deep freeze
+   * @returns The frozen object
+   */
+  static deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => _BaseDomainEvent.deepFreeze(item));
+      return Object.freeze(obj);
+    }
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+      if (value !== null && typeof value === "object") {
+        _BaseDomainEvent.deepFreeze(value);
+      }
+    }
+    return Object.freeze(obj);
+  }
+  /**
+   * Creates an immutable copy of the payload.
+   *
+   * Clones the payload first to avoid mutating the original object,
+   * then deep-freezes the clone to ensure immutability.
+   *
+   * @param payload - The payload to clone and freeze
+   * @returns An immutable copy of the payload
+   */
+  static cloneAndFreeze(payload) {
+    const cloned = _BaseDomainEvent.deepClone(payload);
+    return _BaseDomainEvent.deepFreeze(cloned);
+  }
+  /**
+   * Creates a new Domain Event.
+   *
+   * The payload is cloned and deep-frozen to ensure immutability. The original
+   * object passed in remains unmodified. Any attempt to modify the event's
+   * payload after creation will throw a TypeError in strict mode.
+   *
+   * @param eventName - The name of the event (e.g., 'OrderPlaced', 'UserRegistered')
+   * @param aggregateId - The ID of the aggregate that raised this event
+   * @param payload - The event-specific data (will be cloned and deep-frozen)
+   * @param eventId - Optional custom event ID (defaults to crypto.randomUUID())
+   * @param occurredOn - Optional timestamp (defaults to now)
+   */
+  constructor(eventName, aggregateId, payload, eventId, occurredOn) {
+    this._eventId = eventId ?? crypto.randomUUID();
+    this._eventName = eventName;
+    this._aggregateId = aggregateId;
+    this._occurredOn = occurredOn ?? /* @__PURE__ */ new Date();
+    this._payload = _BaseDomainEvent.cloneAndFreeze(payload);
+  }
+  /**
+   * Unique identifier for this event instance.
+   *
+   * Useful for idempotency checks and event deduplication.
+   */
+  get eventId() {
+    return this._eventId;
+  }
+  /**
+   * The name/type of this event.
+   *
+   * Used for routing events to appropriate handlers.
+   * Should be in PastTense format (e.g., 'OrderPlaced', 'UserRegistered').
+   */
+  get eventName() {
+    return this._eventName;
+  }
+  /**
+   * The ID of the aggregate that raised this event.
+   *
+   * Useful for event sourcing and aggregate-specific event streams.
+   */
+  get aggregateId() {
+    return this._aggregateId;
+  }
+  /**
+   * Timestamp when this event occurred.
+   *
+   * Represents the moment the domain action happened.
+   */
+  get occurredOn() {
+    return this._occurredOn;
+  }
+  /**
+   * The event-specific data payload.
+   *
+   * Contains all information needed by event handlers.
+   */
+  get payload() {
+    return this._payload;
+  }
+  /**
+   * Serializes the event to a plain object for persistence or messaging.
+   *
+   * @returns A plain object representation of the event
+   *
+   * @example
+   * ```typescript
+   * const event = new OrderPlacedEvent({ orderId: '123', ... });
+   * const serialized = event.toJSON();
+   * // {
+   * //   eventId: 'uuid',
+   * //   eventName: 'OrderPlaced',
+   * //   aggregateId: '123',
+   * //   occurredOn: '2024-01-15T10:30:00.000Z',
+   * //   payload: { orderId: '123', ... }
+   * // }
+   * ```
+   */
+  toJSON() {
+    return {
+      eventId: this._eventId,
+      eventName: this._eventName,
+      aggregateId: this._aggregateId,
+      occurredOn: this._occurredOn.toISOString(),
+      payload: this._payload
+    };
+  }
+};
+
+// src/backend/core/onion-layers/domain/classes/base-value-object.class.ts
+var SKIP_VALUE_OBJECT_VALIDATION = "skip value object validation";
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || a === void 0 || b === null || b === void 0) {
+    return a === b;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEquals(item, b[index]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => deepEquals(aObj[key], bObj[key]));
+  }
+  return false;
+}
+var BaseValueObject = class {
+  _value;
+  /**
+   * Creates a new Value Object instance.
+   *
+   * @param value - The raw value to wrap
+   * @param validator - A bound validator or SKIP_VALUE_OBJECT_VALIDATION to bypass
+   * @throws {ObjectValidationError} When validation fails
+   */
+  constructor(value, validator) {
+    this._value = validator === SKIP_VALUE_OBJECT_VALIDATION ? value : validator.validate(value);
+  }
+  /**
+   * Compares this Value Object with another for equality.
+   *
+   * Uses deep equality comparison to handle nested objects, arrays, and dates.
+   * Two Value Objects are equal if their underlying values are deeply equal.
+   *
+   * @param other - The Value Object to compare with
+   * @returns `true` if the values are deeply equal, `false` otherwise
+   */
+  equals(other) {
+    if (this === other) return true;
+    return deepEquals(this.value, other.value);
+  }
+  /**
+   * The underlying immutable value.
+   *
+   * @returns The wrapped value of type T
+   */
+  get value() {
+    return this._value;
+  }
+};
+
+// src/backend/core/onion-layers/domain/exceptions/invariant-violation.error.ts
+var InvariantViolationError = class _InvariantViolationError extends DomainError {
+  /**
+   * Creates a new InvariantViolationError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the violated invariant
+   * @param options.code - Machine-readable error code (default: 'INVARIANT_VIOLATION')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Domain.INVARIANT_VIOLATION,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an InvariantViolationError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new InvariantViolationError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _InvariantViolationError({
+      message: cause instanceof Error ? cause.message : "Invariant violation",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/domain/exceptions/partial-load.error.ts
+var PartialLoadError = class _PartialLoadError extends DomainError {
+  /**
+   * Creates a new PartialLoadError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of what was not loaded
+   * @param options.code - Machine-readable error code (default: 'PARTIAL_LOAD')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Domain.PARTIAL_LOAD,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a PartialLoadError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new PartialLoadError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _PartialLoadError({
+      message: cause instanceof Error ? cause.message : "Partial load error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-audit-by.vo.ts
+var BaseAuditByVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseAuditByVo instance.
+   *
+   * @param value - The user tracking values
+   * @param value.createdBy - User who created the entity (optional for system ops)
+   * @param value.updatedBy - User who last updated the entity (optional)
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * The user ID who created the entity.
+   * Returns `undefined` for system-created entities.
+   */
+  get createdBy() {
+    return this.value.createdBy;
+  }
+  /**
+   * The user ID who last updated the entity.
+   * Returns `undefined` for system-updated entities.
+   */
+  get updatedBy() {
+    return this.value.updatedBy;
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-audit-info.vo.ts
+var BaseAuditInfoVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseAuditInfoVo instance.
+   *
+   * @param value - Composite value containing audit by and on VOs
+   * @param value.by - User tracking value object
+   * @param value.on - Timestamp tracking value object
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * The user ID who created the entity.
+   * Returns `undefined` for system-created entities.
+   */
+  get createdBy() {
+    return this.value.by.createdBy;
+  }
+  /**
+   * The timestamp when the entity was created.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get createdAt() {
+    return new Date(this.value.on.createdAt.getTime());
+  }
+  /**
+   * The user ID who last updated the entity.
+   * Returns `undefined` for system-updated entities.
+   */
+  get updatedBy() {
+    return this.value.by.updatedBy;
+  }
+  /**
+   * The timestamp when the entity was last updated.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get updatedAt() {
+    return new Date(this.value.on.updatedAt.getTime());
+  }
+  /**
+   * Whether the entity has been modified since creation.
+   *
+   * Compares both timestamps and user IDs. Returns `true` if either:
+   * - The updatedAt timestamp differs from createdAt
+   * - The updatedBy user differs from createdBy
+   *
+   * Note: When both createdBy and updatedBy are undefined (system-created
+   * entities), this correctly returns false for the user comparison.
+   */
+  get isModified() {
+    const timestampChanged = this.updatedAt.getTime() !== this.createdAt.getTime();
+    const userChanged = this.updatedBy?.value !== this.createdBy?.value;
+    return timestampChanged || userChanged;
+  }
+  /**
+   * Alias for `updatedBy` for semantic clarity.
+   */
+  get lastModifiedBy() {
+    return this.updatedBy;
+  }
+  /**
+   * Alias for `updatedAt` for semantic clarity.
+   */
+  get lastModifiedAt() {
+    return this.updatedAt;
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-audit-on.vo.ts
+var BaseAuditOnVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseAuditOnVo instance.
+   *
+   * @param value - The timestamp values
+   * @param value.createdAt - When the entity was created
+   * @param value.updatedAt - When the entity was last updated
+   * @param validator - Bound validator or skip validation symbol
+   * @throws {InvariantViolationError} When `updatedAt < createdAt`
+   */
+  constructor(value, validator) {
+    if (value.updatedAt < value.createdAt) {
+      throw new InvariantViolationError({
+        message: "UpdatedAt cannot be earlier than createdAt",
+        code: "INVALID_AUDIT_TIMESTAMPS"
+      });
+    }
+    super(value, validator);
+  }
+  /**
+   * When the entity was created.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get createdAt() {
+    return new Date(this.value.createdAt);
+  }
+  /**
+   * When the entity was last updated.
+   * Returns a cloned Date to prevent mutation.
+   */
+  get updatedAt() {
+    return new Date(this.value.updatedAt);
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-email.vo.ts
+var BaseEmailVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseEmailVo instance.
+   *
+   * @param value - The email address string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-long-text.vo.ts
+var BaseLongTextVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseLongTextVo instance.
+   *
+   * @param value - The long text string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-medium-text.vo.ts
+var BaseMediumTextVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseMediumTextVo instance.
+   *
+   * @param value - The medium text string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-pagination.vo.ts
+var BasePaginationVo = class extends BaseValueObject {
+  /**
+   * Creates a new BasePaginationVo instance.
+   *
+   * @param value - The pagination parameters
+   * @param value.page - The page number (typically 1-indexed)
+   * @param value.pageSize - The number of items per page
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * The current page number.
+   */
+  get page() {
+    return this.value.page;
+  }
+  /**
+   * The number of items per page.
+   */
+  get pageSize() {
+    return this.value.pageSize;
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-short-text.vo.ts
+var BaseShortTextVo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseShortTextVo instance.
+   *
+   * @param value - The short text string
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-uuid-v4.vo.ts
+var import_uuid = require("uuid");
+var BaseUuidV4Vo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseUuidV4Vo instance.
+   *
+   * @param value - The UUID v4 string value
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * Generates a new UUID v4 value object.
+   *
+   * Creates a random UUID, skipping validation since the
+   * `uuid` library guarantees format.
+   *
+   * @returns A new BaseUuidV4Vo with a freshly generated UUID
+   */
+  static generate() {
+    return new this((0, import_uuid.v4)(), SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a UUID v4 value object from an existing string.
+   *
+   * **Important:** This base implementation skips validation and accepts
+   * any string value. Subclasses should override this method with a
+   * validator to ensure UUID format correctness.
+   *
+   * @param value - The UUID v4 string value (not validated at base level)
+   * @returns A new BaseUuidV4Vo with the provided value
+   *
+   * @example Subclass with validation (recommended)
+   * ```typescript
+   * class UserId extends BaseUuidV4Vo {
+   *   static override create(value: string): UserId {
+   *     return new UserId(value, uuidV4Validator);
+   *   }
+   * }
+   * ```
+   *
+   * @see generate - For creating new UUIDs (always valid)
+   */
+  static create(value) {
+    return new this(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+};
+
+// src/backend/core/onion-layers/domain/value-objects/base-uuid-v7.vo.ts
+var import_uuid2 = require("uuid");
+var BaseUuidV7Vo = class extends BaseValueObject {
+  /**
+   * Creates a new BaseUuidV7Vo instance.
+   *
+   * @param value - The UUID v7 string value
+   * @param validator - Bound validator or skip validation symbol
+   */
+  constructor(value, validator) {
+    super(value, validator);
+  }
+  /**
+   * Generates a new UUID v7 value object.
+   *
+   * Creates a time-ordered UUID using the current timestamp,
+   * skipping validation since the `uuid` library guarantees format.
+   *
+   * @returns A new BaseUuidV7Vo with a freshly generated UUID
+   */
+  static generate() {
+    return new this((0, import_uuid2.v7)(), SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a UUID v7 value object from an existing string.
+   *
+   * **Important:** This base implementation skips validation and accepts
+   * any string value. Subclasses should override this method with a
+   * validator to ensure UUID format correctness.
+   *
+   * @param value - The UUID v7 string value (not validated at base level)
+   * @returns A new BaseUuidV7Vo with the provided value
+   *
+   * @example Subclass with validation (recommended)
+   * ```typescript
+   * class OrderId extends BaseUuidV7Vo {
+   *   static override create(value: string): OrderId {
+   *     return new OrderId(value, uuidV7Validator);
+   *   }
+   * }
+   * ```
+   *
+   * @see generate - For creating new UUIDs (always valid)
+   */
+  static create(value) {
+    return new this(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/value-objects/money.vo.ts
+var Money = class _Money extends BaseValueObject {
+  /**
+   * Creates a Money instance with USD currency.
+   *
+   * @param amount - The monetary amount
+   */
+  static usd(amount) {
+    return new _Money({ amount, currency: "USD" }, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a Money instance with EUR currency.
+   *
+   * @param amount - The monetary amount
+   */
+  static eur(amount) {
+    return new _Money({ amount, currency: "EUR" }, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a zero amount in the specified currency.
+   *
+   * @param currency - The currency code (default: 'USD')
+   */
+  static zero(currency = "USD") {
+    return new _Money({ amount: 0, currency }, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Reconstitutes a Money from a persisted value.
+   *
+   * @param value - The money value from persistence
+   */
+  static fromPersistence(value) {
+    return new _Money(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * The monetary amount.
+   */
+  get amount() {
+    return this.value.amount;
+  }
+  /**
+   * The currency code.
+   */
+  get currency() {
+    return this.value.currency;
+  }
+  /**
+   * Adds another Money value to this one.
+   *
+   * @param other - The Money to add
+   * @throws {InvariantViolationError} If currencies don't match
+   */
+  add(other) {
+    this.assertSameCurrency(other);
+    return new _Money(
+      { amount: this.amount + other.amount, currency: this.currency },
+      SKIP_VALUE_OBJECT_VALIDATION
+    );
+  }
+  /**
+   * Subtracts another Money value from this one.
+   *
+   * @param other - The Money to subtract
+   * @throws {InvariantViolationError} If currencies don't match
+   */
+  subtract(other) {
+    this.assertSameCurrency(other);
+    return new _Money(
+      { amount: this.amount - other.amount, currency: this.currency },
+      SKIP_VALUE_OBJECT_VALIDATION
+    );
+  }
+  /**
+   * Multiplies this Money by a factor.
+   *
+   * @param factor - The multiplication factor
+   */
+  multiply(factor) {
+    return new _Money(
+      { amount: this.amount * factor, currency: this.currency },
+      SKIP_VALUE_OBJECT_VALIDATION
+    );
+  }
+  /**
+   * Checks if this Money is greater than another.
+   *
+   * @param other - The Money to compare with
+   * @throws {InvariantViolationError} If currencies don't match
+   */
+  isGreaterThan(other) {
+    this.assertSameCurrency(other);
+    return this.amount > other.amount;
+  }
+  /**
+   * Checks if this Money is less than another.
+   *
+   * @param other - The Money to compare with
+   * @throws {InvariantViolationError} If currencies don't match
+   */
+  isLessThan(other) {
+    this.assertSameCurrency(other);
+    return this.amount < other.amount;
+  }
+  /**
+   * Checks if this Money represents zero.
+   */
+  isZero() {
+    return this.amount === 0;
+  }
+  /**
+   * Asserts that two Money values have the same currency.
+   * @internal
+   */
+  assertSameCurrency(other) {
+    if (this.currency !== other.currency) {
+      throw new InvariantViolationError({
+        message: `Cannot operate on different currencies: ${this.currency} vs ${other.currency}`,
+        code: "CURRENCY_MISMATCH"
+      });
+    }
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/value-objects/order-id.vo.ts
+var OrderId = class extends BaseUuidV7Vo {
+};
+
+// src/backend/core/onion-layers/domain/example-domain/value-objects/order-status.vo.ts
+var OrderStatus = class _OrderStatus extends BaseValueObject {
+  /**
+   * Creates a new OrderStatus with 'pending' value.
+   * Use when creating new orders.
+   */
+  static pending() {
+    return new _OrderStatus("pending", SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a new OrderStatus with 'confirmed' value.
+   * Use when payment is received.
+   */
+  static confirmed() {
+    return new _OrderStatus("confirmed", SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a new OrderStatus with 'shipped' value.
+   * Use when order is dispatched.
+   */
+  static shipped() {
+    return new _OrderStatus("shipped", SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Creates a new OrderStatus with 'cancelled' value.
+   * Use when order is cancelled by customer or system.
+   */
+  static cancelled() {
+    return new _OrderStatus("cancelled", SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Reconstitutes an OrderStatus from a persisted value.
+   *
+   * @param value - The status value from persistence
+   */
+  static fromPersistence(value) {
+    return new _OrderStatus(value, SKIP_VALUE_OBJECT_VALIDATION);
+  }
+  /**
+   * Checks if the order is in pending status.
+   */
+  isPending() {
+    return this.value === "pending";
+  }
+  /**
+   * Checks if the order is confirmed.
+   */
+  isConfirmed() {
+    return this.value === "confirmed";
+  }
+  /**
+   * Checks if the order has been shipped.
+   */
+  isShipped() {
+    return this.value === "shipped";
+  }
+  /**
+   * Checks if the order has been cancelled.
+   */
+  isCancelled() {
+    return this.value === "cancelled";
+  }
+  /**
+   * Checks if the order can still be modified (pending or confirmed).
+   */
+  isModifiable() {
+    return this.isPending() || this.isConfirmed();
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/events/order-cancelled.event.ts
+var OrderCancelledEvent = class extends BaseDomainEvent {
+  constructor(payload) {
+    super("OrderCancelled", payload.orderId, payload);
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/events/order-placed.event.ts
+var OrderPlacedEvent = class extends BaseDomainEvent {
+  constructor(payload) {
+    super("OrderPlaced", payload.orderId, payload);
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/aggregates/order/policies/value/default-order-status.policy.ts
+var defaultOrderStatus = () => {
+  return OrderStatus.pending();
+};
+
+// src/backend/core/onion-layers/domain/example-domain/aggregates/order/policies/business/can-add-order-item.policy.ts
+var canAddOrderItem = (order) => {
+  return order.status.isPending();
+};
+
+// src/backend/core/onion-layers/domain/example-domain/aggregates/order/policies/business/can-cancel-order.policy.ts
+var canCancelOrder = (order) => {
+  return order.status.isPending() || order.status.isConfirmed();
+};
+
+// src/backend/core/onion-layers/domain/example-domain/aggregates/order/order.aggregate.ts
+var Order = class _Order extends BaseAggregateRoot {
+  constructor(id, props, version) {
+    super(id, props, version);
+  }
+  /**
+   * Creates a new Order.
+   *
+   * @param customerId - The customer placing the order
+   * @param items - Initial order items
+   * @returns A new Order instance with OrderPlacedEvent raised
+   */
+  static create(customerId, items) {
+    const id = OrderId.generate();
+    const totalAmount = items.reduce((sum, item) => sum.add(item.totalPrice), Money.zero());
+    const order = new _Order(id, {
+      customerId,
+      items,
+      status: defaultOrderStatus(),
+      totalAmount,
+      placedAt: /* @__PURE__ */ new Date()
+    });
+    order.addDomainEvent(
+      new OrderPlacedEvent({
+        orderId: id.value,
+        customerId,
+        itemCount: items.length,
+        totalAmount: totalAmount.amount,
+        currency: totalAmount.currency,
+        placedAt: order.placedAt.toISOString()
+      })
+    );
+    return order;
+  }
+  /**
+   * Reconstitutes an Order from persistence.
+   *
+   * @param id - The order ID
+   * @param props - The order properties
+   * @param version - The version for optimistic locking
+   */
+  static fromPersistence(id, props, version) {
+    return new _Order(id, props, version);
+  }
+  get customerId() {
+    return this.props.customerId;
+  }
+  get items() {
+    return this.props.items;
+  }
+  get status() {
+    return this.props.status;
+  }
+  get totalAmount() {
+    return this.props.totalAmount;
+  }
+  get placedAt() {
+    return this.props.placedAt;
+  }
+  /**
+   * Adds an item to the order.
+   *
+   * Uses the `canAddOrderItem` business policy to check if the operation is allowed.
+   *
+   * @param item - The item to add
+   * @throws {InvariantViolationError} If the order is not in pending status
+   */
+  addItem(item) {
+    if (!canAddOrderItem(this)) {
+      throw new InvariantViolationError({
+        message: "Cannot add items to non-pending order",
+        code: "ORDER_NOT_PENDING"
+      });
+    }
+    this._props.items.push(item);
+    this._props.totalAmount = this._props.totalAmount.add(item.totalPrice);
+  }
+  /**
+   * Confirms the order (e.g., after payment received).
+   *
+   * @throws {InvariantViolationError} If the order is not in pending status
+   */
+  confirm() {
+    if (!this.status.isPending()) {
+      throw new InvariantViolationError({
+        message: "Only pending orders can be confirmed",
+        code: "ORDER_NOT_PENDING"
+      });
+    }
+    this._props.status = OrderStatus.confirmed();
+  }
+  /**
+   * Marks the order as shipped.
+   *
+   * @throws {InvariantViolationError} If the order is not confirmed
+   */
+  ship() {
+    if (!this.status.isConfirmed()) {
+      throw new InvariantViolationError({
+        message: "Only confirmed orders can be shipped",
+        code: "ORDER_NOT_CONFIRMED"
+      });
+    }
+    this._props.status = OrderStatus.shipped();
+  }
+  /**
+   * Cancels the order.
+   *
+   * Uses the `canCancelOrder` business policy to check if the operation is allowed.
+   *
+   * @param reason - The reason for cancellation
+   * @throws {InvariantViolationError} If the order cannot be cancelled
+   */
+  cancel(reason) {
+    if (!canCancelOrder(this)) {
+      throw new InvariantViolationError({
+        message: "Order cannot be cancelled - already shipped or cancelled",
+        code: "ORDER_CANNOT_CANCEL"
+      });
+    }
+    this._props.status = OrderStatus.cancelled();
+    this.addDomainEvent(
+      new OrderCancelledEvent({
+        orderId: this.id.value,
+        reason,
+        cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/entities/order-item-id.vo.ts
+var OrderItemId = class extends BaseUuidV7Vo {
+};
+
+// src/backend/core/onion-layers/domain/example-domain/entities/order-item.entity.ts
+var OrderItem = class _OrderItem extends BaseEntity {
+  constructor(id, props) {
+    super(id, props);
+  }
+  /**
+   * Creates a new OrderItem.
+   */
+  static create(props) {
+    return new _OrderItem(OrderItemId.generate(), props);
+  }
+  /**
+   * Reconstitutes an OrderItem from persistence.
+   */
+  static fromPersistence(id, props) {
+    return new _OrderItem(id, props);
+  }
+  get productId() {
+    return this.props.productId;
+  }
+  get productName() {
+    return this.props.productName;
+  }
+  get quantity() {
+    return this.props.quantity;
+  }
+  get unitPrice() {
+    return this.props.unitPrice;
+  }
+  /**
+   * Calculates the total price for this line item.
+   */
+  get totalPrice() {
+    return this.props.unitPrice.multiply(this.props.quantity);
+  }
+  /**
+   * Updates the quantity of this item.
+   */
+  updateQuantity(newQuantity) {
+    this._props.quantity = newQuantity;
+  }
+  /**
+   * Converts to a plain object for events or persistence.
+   */
+  toPlain() {
+    return {
+      id: this.id.value,
+      productId: this.props.productId,
+      productName: this.props.productName,
+      quantity: this.props.quantity,
+      unitPrice: {
+        amount: this.props.unitPrice.amount,
+        currency: this.props.unitPrice.currency
+      }
+    };
+  }
+};
+
+// src/backend/core/onion-layers/domain/example-domain/exceptions/order-already-shipped.error.ts
+var OrderAlreadyShippedError = class extends InvariantViolationError {
+  constructor(orderId) {
+    super({
+      message: `Order ${orderId} has already been shipped and cannot be modified`,
+      code: "ORDER_ALREADY_SHIPPED"
+    });
+  }
+};
+
+// src/backend/core/onion-layers/infra/classes/base-outbound-adapter.class.ts
+var WRAPPED_METHODS_SYMBOL = /* @__PURE__ */ Symbol.for("onion-lasagna:wrapped-methods");
+function getWrappedMethods(proto) {
+  const existing = proto[WRAPPED_METHODS_SYMBOL];
+  if (existing) return existing;
+  const newSet = /* @__PURE__ */ new Set();
+  Object.defineProperty(proto, WRAPPED_METHODS_SYMBOL, {
+    value: newSet,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  return newSet;
+}
+var BaseOutboundAdapter = class _BaseOutboundAdapter {
+  /**
+   * Initializes the adapter and wraps all subclass methods with error handling.
+   * Must be called via `super()` in subclass constructors.
+   */
+  constructor() {
+    this.wrapAllSubclassMethods();
+  }
+  /**
+   * Factory method for creating infrastructure errors.
+   *
+   * Override this in subclasses to return specific error types
+   * (e.g., `DbError`, `NetworkError`, `ExternalServiceError`).
+   *
+   * @param error - The original error that was caught
+   * @param methodName - Name of the method where the error occurred (for debugging)
+   * @returns An InfraError instance wrapping the original error
+   */
+  createInfraError(error, methodName) {
+    return new InfraError({
+      message: `Outbound adapter error in ${methodName}`,
+      cause: error
+    });
+  }
+  /**
+   * Walks the prototype chain and wraps all methods with error handling.
+   * Uses prototype-level Symbol markers to prevent re-wrapping across instances.
+   * @internal
+   */
+  wrapAllSubclassMethods() {
+    const wrapMethod = (methodName, original) => {
+      const wrapped = (...args) => {
+        try {
+          const result = Reflect.apply(original, this, args);
+          if (result instanceof Promise) {
+            return result.catch((error) => {
+              throw this.createInfraError(error, methodName);
+            });
+          }
+          return result;
+        } catch (error) {
+          throw this.createInfraError(error, methodName);
+        }
+      };
+      Object.defineProperty(this, methodName, {
+        value: wrapped,
+        writable: false,
+        enumerable: false,
+        configurable: false
+      });
+    };
+    const methodsToWrap = [];
+    let proto = Object.getPrototypeOf(this);
+    while (proto && proto !== _BaseOutboundAdapter.prototype && proto !== Object.prototype) {
+      const wrappedOnProto = getWrappedMethods(proto);
+      for (const key of Object.getOwnPropertyNames(proto)) {
+        if (key === "constructor") continue;
+        if (wrappedOnProto.has(key)) continue;
+        const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+        if (!descriptor) continue;
+        if (descriptor.get || descriptor.set) continue;
+        if (typeof descriptor.value !== "function") continue;
+        methodsToWrap.push({ name: key, fn: descriptor.value });
+        wrappedOnProto.add(key);
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    for (const { name, fn } of methodsToWrap) {
+      wrapMethod(name, fn);
+    }
+  }
+};
+
+// src/backend/core/onion-layers/infra/exceptions/db.error.ts
+var DbError = class _DbError extends InfraError {
+  /**
+   * Creates a new DbError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the database failure
+   * @param options.code - Machine-readable error code (default: 'DB_ERROR')
+   * @param options.cause - Optional underlying database error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Infra.DB_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a DbError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new DbError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _DbError({
+      message: cause instanceof Error ? cause.message : "Database error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/infra/exceptions/network.error.ts
+var NetworkError = class _NetworkError extends InfraError {
+  /**
+   * Creates a new NetworkError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the network failure
+   * @param options.code - Machine-readable error code (default: 'NETWORK_ERROR')
+   * @param options.cause - Optional underlying network error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Infra.NETWORK_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a NetworkError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new NetworkError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _NetworkError({
+      message: cause instanceof Error ? cause.message : "Network error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/infra/exceptions/timeout.error.ts
+var TimeoutError = class _TimeoutError extends InfraError {
+  /**
+   * Creates a new TimeoutError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of what timed out
+   * @param options.code - Machine-readable error code (default: 'TIMEOUT_ERROR')
+   * @param options.cause - Optional underlying timeout error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Infra.TIMEOUT_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a TimeoutError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new TimeoutError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _TimeoutError({
+      message: cause instanceof Error ? cause.message : "Operation timed out",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/infra/exceptions/external-service.error.ts
+var ExternalServiceError = class _ExternalServiceError extends InfraError {
+  /**
+   * Creates a new ExternalServiceError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of the external service failure
+   * @param options.code - Machine-readable error code (default: 'EXTERNAL_SERVICE_ERROR')
+   * @param options.cause - Optional underlying service error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Infra.EXTERNAL_SERVICE_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an ExternalServiceError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ExternalServiceError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ExternalServiceError({
+      message: cause instanceof Error ? cause.message : "External service error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/presentation/exceptions/controller.error.ts
+var ControllerError = class _ControllerError extends CodedError {
+  /**
+   * Creates a new ControllerError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Human-readable error description
+   * @param options.code - Machine-readable error code (default: 'CONTROLLER_ERROR')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Presentation.CONTROLLER_ERROR,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a ControllerError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ControllerError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ControllerError({
+      message: cause instanceof Error ? cause.message : "Controller error",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/presentation/exceptions/invalid-request.error.ts
+var InvalidRequestError = class _InvalidRequestError extends CodedError {
+  /**
+   * Array of field-level validation errors.
+   *
+   * Each entry contains:
+   * - `field`: Dot-notation path to the invalid field
+   * - `message`: Human-readable validation failure message
+   */
+  validationErrors;
+  /**
+   * Creates a new InvalidRequestError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Summary of the validation failure
+   * @param options.code - Machine-readable error code (default: 'INVALID_REQUEST')
+   * @param options.cause - Optional underlying error
+   * @param options.validationErrors - Array of field-level validation errors
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Presentation.INVALID_REQUEST,
+    cause,
+    validationErrors
+  }) {
+    super({ message, code, cause });
+    this.validationErrors = validationErrors;
+  }
+  /**
+   * Creates an InvalidRequestError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new InvalidRequestError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _InvalidRequestError({
+      message: cause instanceof Error ? cause.message : "Invalid request",
+      cause,
+      validationErrors: []
+    });
+  }
+};
+
+// src/backend/core/onion-layers/presentation/classes/base-controller.class.ts
+var BaseController = class _BaseController {
+  /**
+   * Creates a new BaseController instance.
+   *
+   * @param requestMapper - Function to map request DTO to use case input DTO
+   * @param useCase - The use case port to execute
+   * @param responseMapper - Function to map use case output DTO to response DTO
+   */
+  constructor(requestMapper, useCase, responseMapper) {
+    this.requestMapper = requestMapper;
+    this.useCase = useCase;
+    this.responseMapper = responseMapper;
+  }
+  /**
+   * Factory method to create a controller from a configuration object.
+   *
+   * @param config - Controller configuration
+   * @returns A new BaseController instance
+   */
+  static create(config) {
+    return new _BaseController(config.requestMapper, config.useCase, config.responseMapper);
+  }
+  /**
+   * Executes the controller pipeline with error wrapping.
+   *
+   * This is the public entry point that ensures consistent error handling.
+   * All errors are wrapped in {@link ControllerError} unless they extend {@link CodedError}.
+   *
+   * **Do not override this method.** Override {@link pipeline} instead for custom pipeline logic.
+   *
+   * @param input - The validated request DTO
+   * @returns Promise resolving to the validated response DTO
+   * @throws {InvalidRequestError} When request mapping/validation fails
+   * @throws {ControllerError} When an unexpected error occurs
+   * @throws {CodedError} When use case throws a known error type
+   */
+  async execute(input) {
+    return wrapErrorUnlessAsync(
+      () => this.pipeline(input),
+      (cause) => new ControllerError({
+        message: cause instanceof Error ? cause.message : "Controller execution failed",
+        cause
+      }),
+      [CodedError]
+    );
+  }
+  /**
+   * Runs the controller pipeline.
+   *
+   * Orchestrates: `mapRequest → executeUseCase → mapResponse`
+   *
+   * Override this method to customize the entire pipeline flow, or override
+   * individual protected methods ({@link mapRequest}, {@link executeUseCase},
+   * {@link mapResponse}) for more granular control.
+   *
+   * @param input - The validated request DTO
+   * @returns Promise resolving to the validated response DTO
+   */
+  async pipeline(input) {
+    const mappedInput = this.mapRequest(input);
+    const result = await this.executeUseCase(mappedInput);
+    return this.mapResponse(result);
+  }
+  /**
+   * Maps the request DTO to a use case input DTO.
+   *
+   * Override to add custom pre-processing, logging, or transformation logic.
+   * The default implementation uses the configured `requestMapper` and converts
+   * {@link ObjectValidationError} to {@link InvalidRequestError}.
+   *
+   * @param input - The validated request DTO
+   * @returns The use case input DTO
+   * @throws {InvalidRequestError} When validation fails
+   * @throws {ControllerError} When mapping fails unexpectedly
+   */
+  mapRequest(input) {
+    return wrapErrorUnless(
+      () => this.requestMapper(input),
+      (cause) => {
+        if (cause instanceof ObjectValidationError) {
+          return new InvalidRequestError({
+            message: cause.message,
+            cause,
+            validationErrors: cause.validationErrors
+          });
+        }
+        return new ControllerError({
+          message: cause instanceof Error ? cause.message : "Request mapping failed",
+          cause
+        });
+      },
+      [CodedError]
+    );
+  }
+  /**
+   * Executes the use case with the mapped input.
+   *
+   * Override to add custom logic around use case execution, such as:
+   * - Logging/tracing
+   * - Caching
+   * - Retry logic
+   * - Multi-use-case orchestration
+   *
+   * @param input - The use case input DTO
+   * @returns Promise resolving to the use case output DTO
+   */
+  async executeUseCase(input) {
+    return this.useCase.execute(input);
+  }
+  /**
+   * Maps the use case output DTO to a response DTO.
+   *
+   * Override to add custom post-processing, logging, or transformation logic.
+   * The default implementation uses the configured `responseMapper`.
+   *
+   * @param output - The use case output DTO
+   * @returns The response DTO
+   * @throws {ControllerError} When mapping or validation fails
+   */
+  mapResponse(output) {
+    return wrapErrorUnless(
+      () => this.responseMapper(output),
+      (cause) => new ControllerError({
+        message: cause instanceof ObjectValidationError ? "Response validation failed" : cause instanceof Error ? cause.message : "Response mapping failed",
+        cause
+      }),
+      [CodedError]
+    );
+  }
+};
+
+// src/backend/core/onion-layers/presentation/exceptions/access-denied.error.ts
+var AccessDeniedError = class _AccessDeniedError extends CodedError {
+  /**
+   * Creates a new AccessDeniedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why access was denied
+   * @param options.code - Machine-readable error code (default: 'ACCESS_DENIED')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.Presentation.ACCESS_DENIED,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an AccessDeniedError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new AccessDeniedError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _AccessDeniedError({
+      message: cause instanceof Error ? cause.message : "Access denied",
+      cause
+    });
+  }
+};
+
+// src/backend/core/onion-layers/presentation/classes/guarded-controller.class.ts
+function createAllowAllGuard() {
+  return async () => ({
+    isAllowed: true
+  });
+}
+var GuardedController = class _GuardedController extends BaseController {
+  /** The access guard function for this controller. */
+  accessGuard;
+  /**
+   * Creates a new GuardedController instance.
+   *
+   * @param requestMapper - Function to map request DTO to use case input DTO
+   * @param useCase - The use case port to execute
+   * @param responseMapper - Function to map use case output DTO to response DTO
+   * @param accessGuard - Optional access guard; defaults to allowing all
+   */
+  constructor(requestMapper, useCase, responseMapper, accessGuard) {
+    super(requestMapper, useCase, responseMapper);
+    this.accessGuard = accessGuard ?? createAllowAllGuard();
+  }
+  /**
+   * Factory method to create a guarded controller from a configuration object.
+   *
+   * @param config - Controller configuration including optional access guard
+   * @returns A new GuardedController instance
+   */
+  static create(config) {
+    return new _GuardedController(
+      config.requestMapper,
+      config.useCase,
+      config.responseMapper,
+      config.accessGuard
+    );
+  }
+  /**
+   * Runs the controller pipeline with access control.
+   *
+   * Checks the access guard before executing the pipeline.
+   * If denied, throws {@link AccessDeniedError}.
+   *
+   * @param input - The validated request DTO
+   * @returns Promise resolving to the validated response DTO
+   * @throws {AccessDeniedError} When access guard denies the request
+   */
+  async pipeline(input) {
+    await this.checkAccess(input);
+    return super.pipeline(input);
+  }
+  /**
+   * Checks access using the configured guard.
+   *
+   * Override to customize access control logic.
+   *
+   * @param input - The validated request DTO
+   * @throws {AccessDeniedError} When access is denied
+   */
+  async checkAccess(input) {
+    const result = await this.accessGuard(input);
+    if (!result.isAllowed) {
+      throw new AccessDeniedError({
+        message: result.reason ?? "Access denied"
+      });
+    }
+  }
+};
+
+// src/backend/core/onion-layers/presentation/interfaces/types/metadata/system-metadata.type.ts
+function defineSystemMetadata(metadata) {
+  return metadata;
+}
+
+// src/backend/core/onion-layers/presentation/routing/compute-route-path.util.ts
+function trimSlashes(segment) {
+  return segment.replace(/^\/+|\/+$/g, "");
+}
+function computeRoutePath(service, resource, endpoint) {
+  const segments = [service.basePath, resource.path, endpoint.path].map(trimSlashes).filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    return "/";
+  }
+  return "/" + segments.join("/");
+}
+
+// src/backend/core/onion-layers/presentation/utils/http-response.util.ts
+function isHttpResponse(value) {
+  return typeof value === "object" && value !== null && "statusCode" in value && typeof value.statusCode === "number";
+}
+function assertHttpResponse(value, context = "value") {
+  if (!isHttpResponse(value)) {
+    const actualType = value === null ? "null" : value === void 0 ? "undefined" : typeof value;
+    const hasStatusCode = typeof value === "object" && value !== null && "statusCode" in value;
+    let message = `Expected ${context} to be an HttpResponse with a numeric statusCode, `;
+    if (hasStatusCode) {
+      const statusCodeType = typeof value["statusCode"];
+      message += `but statusCode was ${statusCodeType}`;
+    } else {
+      message += `but got ${actualType}`;
+    }
+    throw new Error(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedError,
+  BaseAggregateRoot,
+  BaseAuditByVo,
+  BaseAuditInfoVo,
+  BaseAuditOnVo,
+  BaseController,
+  BaseDomainEvent,
+  BaseEmailVo,
+  BaseEntity,
+  BaseInboundAdapter,
+  BaseLongTextVo,
+  BaseMediumTextVo,
+  BaseOutboundAdapter,
+  BasePaginationVo,
+  BaseShortTextVo,
+  BaseUuidV4Vo,
+  BaseUuidV7Vo,
+  BaseValueObject,
+  ConflictError,
+  ControllerError,
+  DbError,
+  DomainError,
+  ExternalServiceError,
+  GuardedController,
+  InfraError,
+  InvalidRequestError,
+  InvariantViolationError,
+  Money,
+  NetworkError,
+  NotFoundError,
+  Order,
+  OrderAlreadyShippedError,
+  OrderCancelledEvent,
+  OrderId,
+  OrderItem,
+  OrderItemId,
+  OrderPlacedEvent,
+  OrderStatus,
+  PartialLoadError,
+  SKIP_VALUE_OBJECT_VALIDATION,
+  TimeoutError,
+  UnprocessableError,
+  UseCaseError,
+  assertHttpResponse,
+  canAddOrderItem,
+  canCancelOrder,
+  computeRoutePath,
+  defaultOrderStatus,
+  defineSystemMetadata,
+  isHttpResponse
+});
+//# sourceMappingURL=onion-layers.cjs.map