@cosmneo/onion-lasagna 0.1.3 → 0.1.4

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

@@ -24,7 +24,6 @@ __export(onion_layers_exports, {
   BaseAggregateRoot: () => BaseAggregateRoot,
   BaseAuditByVo: () => BaseAuditByVo,
   BaseAuditOnVo: () => BaseAuditOnVo,
-  BaseController: () => BaseController,
   BaseDomainEvent: () => BaseDomainEvent,
   BaseEmailVo: () => BaseEmailVo,
   BaseEntity: () => BaseEntity,
@@ -43,32 +42,15 @@ __export(onion_layers_exports, {
   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,
   TimeoutError: () => TimeoutError,
   UnprocessableError: () => UnprocessableError,
-  UseCaseError: () => UseCaseError,
-  assertHttpResponse: () => assertHttpResponse,
-  canAddOrderItem: () => canAddOrderItem,
-  canCancelOrder: () => canCancelOrder,
-  computeRoutePath: () => computeRoutePath,
-  defaultOrderStatus: () => defaultOrderStatus,
-  defineSystemMetadata: () => defineSystemMetadata,
-  isHttpResponse: () => isHttpResponse
+  UseCaseError: () => UseCaseError
 });
 module.exports = __toCommonJS(onion_layers_exports);
 
@@ -238,16 +220,6 @@ var ObjectValidationError = class _ObjectValidationError extends CodedError {
 };
 
 // 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();
@@ -360,8 +332,8 @@ var BaseInboundAdapter = class {
    * 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
+   * @param input - Input data
+   * @returns Promise resolving to the output
    * @throws {ObjectValidationError} For validation failures (propagated to controller)
    * @throws {UseCaseError} For use case failures or wrapped unknown errors
    * @throws {DomainError} For domain invariant violations
@@ -530,7 +502,7 @@ var BaseEntity = class {
    * @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);
+   * const user2 = User.reconstitute(user1.id, { name: PersonName.create('John Updated'), ... }, 1);
    * user1.equals(user2); // true - same ID, different state
    * ```
    */
@@ -1209,434 +1181,6 @@ var BaseUuidV7Vo = class _BaseUuidV7Vo extends BaseValueObject {
   }
 };
 
-// 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" });
-  }
-  /**
-   * Creates a Money instance with EUR currency.
-   *
-   * @param amount - The monetary amount
-   */
-  static eur(amount) {
-    return new _Money({ amount, currency: "EUR" });
-  }
-  /**
-   * 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 });
-  }
-  /**
-   * Reconstitutes a Money from a persisted value.
-   *
-   * @param value - The money value from persistence
-   */
-  static fromPersistence(value) {
-    return new _Money(value);
-  }
-  /**
-   * 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 });
-  }
-  /**
-   * 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 });
-  }
-  /**
-   * Multiplies this Money by a factor.
-   *
-   * @param factor - The multiplication factor
-   */
-  multiply(factor) {
-    return new _Money({ amount: this.amount * factor, currency: this.currency });
-  }
-  /**
-   * 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 import_uuid3 = require("uuid");
-var OrderId = class _OrderId extends BaseUuidV7Vo {
-  static generate() {
-    return new _OrderId((0, import_uuid3.v7)());
-  }
-};
-
-// 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");
-  }
-  /**
-   * Creates a new OrderStatus with 'confirmed' value.
-   * Use when payment is received.
-   */
-  static confirmed() {
-    return new _OrderStatus("confirmed");
-  }
-  /**
-   * Creates a new OrderStatus with 'shipped' value.
-   * Use when order is dispatched.
-   */
-  static shipped() {
-    return new _OrderStatus("shipped");
-  }
-  /**
-   * Creates a new OrderStatus with 'cancelled' value.
-   * Use when order is cancelled by customer or system.
-   */
-  static cancelled() {
-    return new _OrderStatus("cancelled");
-  }
-  /**
-   * Reconstitutes an OrderStatus from a persisted value.
-   *
-   * @param value - The status value from persistence
-   */
-  static fromPersistence(value) {
-    return new _OrderStatus(value);
-  }
-  /**
-   * 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 import_uuid4 = require("uuid");
-var OrderItemId = class _OrderItemId extends BaseUuidV7Vo {
-  static generate() {
-    return new _OrderItemId((0, import_uuid4.v7)());
-  }
-};
-
-// 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) {
@@ -1847,6 +1391,37 @@ var ExternalServiceError = class _ExternalServiceError extends InfraError {
   }
 };
 
+// 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/exceptions/controller.error.ts
 var ControllerError = class _ControllerError extends CodedError {
   /**
@@ -1920,283 +1495,12 @@ var InvalidRequestError = class _InvalidRequestError extends CodedError {
     });
   }
 };
-
-// src/backend/core/onion-layers/presentation/classes/base-controller.class.ts
-var BaseController = class _BaseController {
-  /* eslint-enable @typescript-eslint/no-invalid-void-type */
-  /**
-   * 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
-   */
-  /* eslint-disable @typescript-eslint/no-invalid-void-type */
-  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 {
-  /* eslint-enable @typescript-eslint/no-invalid-void-type */
-  /** 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
-   */
-  /* eslint-disable @typescript-eslint/no-invalid-void-type */
-  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,
   BaseAuditOnVo,
-  BaseController,
   BaseDomainEvent,
   BaseEmailVo,
   BaseEntity,
@@ -2215,31 +1519,14 @@ function assertHttpResponse(value, context = "value") {
   DbError,
   DomainError,
   ExternalServiceError,
-  GuardedController,
   InfraError,
   InvalidRequestError,
   InvariantViolationError,
-  Money,
   NetworkError,
   NotFoundError,
-  Order,
-  OrderAlreadyShippedError,
-  OrderCancelledEvent,
-  OrderId,
-  OrderItem,
-  OrderItemId,
-  OrderPlacedEvent,
-  OrderStatus,
   PartialLoadError,
   TimeoutError,
   UnprocessableError,
-  UseCaseError,
-  assertHttpResponse,
-  canAddOrderItem,
-  canCancelOrder,
-  computeRoutePath,
-  defaultOrderStatus,
-  defineSystemMetadata,
-  isHttpResponse
+  UseCaseError
 });
 //# sourceMappingURL=onion-layers.cjs.map