@cosmneo/onion-lasagna 0.1.0

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

@@ -0,0 +1,1158 @@
+import {
+  BaseController,
+  GuardedController,
+  assertHttpResponse,
+  computeRoutePath,
+  defineSystemMetadata,
+  isHttpResponse
+} from "../../chunk-DDAHJZVK.js";
+import {
+  wrapErrorUnlessAsync
+} from "../../chunk-OKFXZHBC.js";
+import {
+  BaseAuditByVo,
+  BaseAuditInfoVo,
+  BaseAuditOnVo,
+  BaseEmailVo,
+  BaseLongTextVo,
+  BaseMediumTextVo,
+  BasePaginationVo,
+  BaseShortTextVo,
+  BaseUuidV4Vo,
+  BaseUuidV7Vo,
+  BaseValueObject,
+  InvariantViolationError,
+  SKIP_VALUE_OBJECT_VALIDATION
+} from "../../chunk-VCHFXT5W.js";
+import {
+  ConflictError,
+  InfraError,
+  NotFoundError,
+  UnprocessableError,
+  UseCaseError
+} from "../../chunk-RLLWYFPI.js";
+import {
+  AccessDeniedError,
+  ControllerError,
+  InvalidRequestError
+} from "../../chunk-74IKUOSE.js";
+import {
+  DomainError
+} from "../../chunk-ZWLYNGO3.js";
+import {
+  ErrorCodes,
+  ObjectValidationError
+} from "../../chunk-MQD5GXMT.js";
+import "../../chunk-CGZBV6BD.js";
+
+// 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/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/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/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
+    });
+  }
+};
+export {
+  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.js.map