@cosmneo/onion-lasagna 0.1.0

package/dist/backend/frameworks/fastify.cjs

@@ -0,0 +1,677 @@
+"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/frameworks/fastify/index.ts
+var fastify_exports = {};
+__export(fastify_exports, {
+  mapErrorToResponse: () => mapErrorToResponse,
+  onionErrorHandler: () => onionErrorHandler,
+  registerFastifyRoutes: () => registerFastifyRoutes
+});
+module.exports = __toCommonJS(fastify_exports);
+
+// src/backend/frameworks/fastify/routing.ts
+function toFastifyPath(path) {
+  return path.replace(/\{([^}]+)\}/g, ":$1");
+}
+function extractRequest(request) {
+  const headers = {};
+  for (const [key, value] of Object.entries(request.headers)) {
+    if (typeof value === "string") {
+      headers[key.toLowerCase()] = value;
+    } else if (Array.isArray(value)) {
+      headers[key.toLowerCase()] = value.join(", ");
+    }
+  }
+  const queryParams = {};
+  const query = request.query;
+  for (const [key, value] of Object.entries(query)) {
+    if (value != null) {
+      queryParams[key] = value;
+    }
+  }
+  return {
+    body: request.body,
+    headers,
+    queryParams,
+    pathParams: request.params
+  };
+}
+function sendResponse(reply, response) {
+  if (response.headers) {
+    for (const [key, value] of Object.entries(response.headers)) {
+      if (value != null) {
+        reply.header(key, String(value));
+      }
+    }
+  }
+  reply.status(response.statusCode);
+  if (response.body === void 0 || response.body === null) {
+    return reply.send();
+  }
+  return reply.send(response.body);
+}
+function registerFastifyRoutes(app, routes, options) {
+  const routeArray = Array.isArray(routes) ? routes : [routes];
+  const prefix = options?.prefix ?? "";
+  const middlewares = options?.middlewares ?? [];
+  for (const { metadata, controller, requestDtoFactory } of routeArray) {
+    const path = prefix + toFastifyPath(metadata.path);
+    const method = metadata.method.toUpperCase();
+    const handler = async (request, reply) => {
+      const rawRequest = extractRequest(request);
+      const requestDto = requestDtoFactory(rawRequest);
+      const responseDto = await controller.execute(requestDto);
+      return sendResponse(reply, responseDto.data);
+    };
+    app.route({
+      method,
+      url: path,
+      preHandler: middlewares,
+      handler
+    });
+  }
+}
+
+// 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/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/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/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/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/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/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/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/frameworks/fastify/map-error-to-response.ts
+function mapErrorToResponse(error) {
+  if (error instanceof ObjectValidationError) {
+    return {
+      statusCode: 400,
+      body: {
+        message: error.message,
+        errorCode: error.code,
+        errorItems: error.validationErrors.map((e) => ({
+          item: e.field,
+          message: e.message
+        }))
+      }
+    };
+  }
+  if (error instanceof InvalidRequestError) {
+    return {
+      statusCode: 400,
+      body: {
+        message: error.message,
+        errorCode: error.code,
+        errorItems: error.validationErrors.map((e) => ({
+          item: e.field,
+          message: e.message
+        }))
+      }
+    };
+  }
+  if (error instanceof AccessDeniedError) {
+    return {
+      statusCode: 403,
+      body: {
+        message: error.message,
+        errorCode: error.code
+      }
+    };
+  }
+  if (error instanceof NotFoundError) {
+    return {
+      statusCode: 404,
+      body: {
+        message: error.message,
+        errorCode: error.code
+      }
+    };
+  }
+  if (error instanceof ConflictError) {
+    return {
+      statusCode: 409,
+      body: {
+        message: error.message,
+        errorCode: error.code
+      }
+    };
+  }
+  if (error instanceof UnprocessableError) {
+    return {
+      statusCode: 422,
+      body: {
+        message: error.message,
+        errorCode: error.code
+      }
+    };
+  }
+  if (error instanceof UseCaseError) {
+    return {
+      statusCode: 400,
+      body: {
+        message: error.message,
+        errorCode: error.code
+      }
+    };
+  }
+  if (error instanceof DomainError) {
+    return {
+      statusCode: 500,
+      body: {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }
+    };
+  }
+  if (error instanceof InfraError) {
+    return {
+      statusCode: 500,
+      body: {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }
+    };
+  }
+  if (error instanceof ControllerError) {
+    return {
+      statusCode: 500,
+      body: {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }
+    };
+  }
+  if (error instanceof CodedError) {
+    return {
+      statusCode: 500,
+      body: {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }
+    };
+  }
+  return {
+    statusCode: 500,
+    body: {
+      message: "An unexpected error occurred",
+      errorCode: "INTERNAL_ERROR"
+    }
+  };
+}
+
+// src/backend/frameworks/fastify/error-handler.ts
+function onionErrorHandler(error, _request, reply) {
+  const { statusCode, body } = mapErrorToResponse(error);
+  return reply.status(statusCode).send(body);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapErrorToResponse,
+  onionErrorHandler,
+  registerFastifyRoutes
+});
+//# sourceMappingURL=fastify.cjs.map