@cosmneo/onion-lasagna 0.1.0

package/dist/backend/frameworks/hono.cjs

@@ -0,0 +1,715 @@
+"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/hono/index.ts
+var hono_exports = {};
+__export(hono_exports, {
+  mapErrorToHttpException: () => mapErrorToHttpException,
+  onionErrorHandler: () => onionErrorHandler,
+  registerHonoRoutes: () => registerHonoRoutes
+});
+module.exports = __toCommonJS(hono_exports);
+
+// src/backend/frameworks/hono/routing.ts
+function getRouteRegistrar(app, method) {
+  const httpMethod = method;
+  switch (httpMethod) {
+    case "get":
+      return app.get.bind(app);
+    case "post":
+      return app.post.bind(app);
+    case "put":
+      return app.put.bind(app);
+    case "patch":
+      return app.patch.bind(app);
+    case "delete":
+      return app.delete.bind(app);
+    case "options":
+      return app.options.bind(app);
+    case "head":
+      return ((path, ...handlers) => (
+        // @ts-expect-error Hono's on() typing is complex, but runtime works
+        app.on("HEAD", path, ...handlers)
+      ));
+    default:
+      throw new Error(`Unsupported HTTP method: ${method}`);
+  }
+}
+function toHonoPath(path) {
+  return path.replace(/\{([^}]+)\}/g, ":$1");
+}
+async function extractRequest(c) {
+  let body;
+  const method = c.req.method.toUpperCase();
+  if (method === "POST" || method === "PUT" || method === "PATCH") {
+    try {
+      body = await c.req.json();
+    } catch {
+    }
+  }
+  const headers = {};
+  c.req.raw.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  const queryParams = {};
+  new URL(c.req.url).searchParams.forEach((value, key) => {
+    const existing = queryParams[key];
+    if (existing) {
+      queryParams[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+    } else {
+      queryParams[key] = value;
+    }
+  });
+  return {
+    body,
+    headers,
+    queryParams,
+    pathParams: c.req.param()
+  };
+}
+function sendResponse(c, response) {
+  if (response.headers) {
+    for (const [key, value] of Object.entries(response.headers)) {
+      if (value != null) c.header(key, String(value));
+    }
+  }
+  if (response.body === void 0 || response.body === null) {
+    return c.body(null, response.statusCode);
+  }
+  if (typeof response.body === "string") {
+    return c.text(response.body, response.statusCode);
+  }
+  return c.json(response.body, response.statusCode);
+}
+function registerHonoRoutes(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 + toHonoPath(metadata.path);
+    const method = metadata.method.toLowerCase();
+    const handler = async (c) => {
+      const rawRequest = await extractRequest(c);
+      const requestDto = requestDtoFactory(rawRequest);
+      const responseDto = await controller.execute(requestDto);
+      return sendResponse(c, responseDto.data);
+    };
+    const registrar = getRouteRegistrar(app, method);
+    registrar(path, ...middlewares, handler);
+  }
+}
+
+// src/backend/frameworks/hono/map-error-to-http-exception.ts
+var import_http_exception = require("hono/http-exception");
+
+// 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/hono/map-error-to-http-exception.ts
+function createErrorResponse(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function mapErrorToHttpException(error) {
+  if (error instanceof import_http_exception.HTTPException) {
+    return error;
+  }
+  if (error instanceof ObjectValidationError) {
+    return new import_http_exception.HTTPException(400, {
+      res: createErrorResponse(400, {
+        message: error.message,
+        errorCode: error.code,
+        errorItems: error.validationErrors.map((e) => ({
+          item: e.field,
+          message: e.message
+        }))
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof InvalidRequestError) {
+    return new import_http_exception.HTTPException(400, {
+      res: createErrorResponse(400, {
+        message: error.message,
+        errorCode: error.code,
+        errorItems: error.validationErrors.map((e) => ({
+          item: e.field,
+          message: e.message
+        }))
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof AccessDeniedError) {
+    return new import_http_exception.HTTPException(403, {
+      res: createErrorResponse(403, {
+        message: error.message,
+        errorCode: error.code
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof NotFoundError) {
+    return new import_http_exception.HTTPException(404, {
+      res: createErrorResponse(404, {
+        message: error.message,
+        errorCode: error.code
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof ConflictError) {
+    return new import_http_exception.HTTPException(409, {
+      res: createErrorResponse(409, {
+        message: error.message,
+        errorCode: error.code
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof UnprocessableError) {
+    return new import_http_exception.HTTPException(422, {
+      res: createErrorResponse(422, {
+        message: error.message,
+        errorCode: error.code
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof UseCaseError) {
+    return new import_http_exception.HTTPException(400, {
+      res: createErrorResponse(400, {
+        message: error.message,
+        errorCode: error.code
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof DomainError) {
+    return new import_http_exception.HTTPException(500, {
+      res: createErrorResponse(500, {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof InfraError) {
+    return new import_http_exception.HTTPException(500, {
+      res: createErrorResponse(500, {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof ControllerError) {
+    return new import_http_exception.HTTPException(500, {
+      res: createErrorResponse(500, {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }),
+      cause: error
+    });
+  }
+  if (error instanceof CodedError) {
+    return new import_http_exception.HTTPException(500, {
+      res: createErrorResponse(500, {
+        message: "An unexpected error occurred",
+        errorCode: "INTERNAL_ERROR"
+      }),
+      cause: error
+    });
+  }
+  return new import_http_exception.HTTPException(500, {
+    res: createErrorResponse(500, {
+      message: "An unexpected error occurred",
+      errorCode: "INTERNAL_ERROR"
+    }),
+    cause: error
+  });
+}
+
+// src/backend/frameworks/hono/error-handler.ts
+function onionErrorHandler(error, _c) {
+  const httpException = mapErrorToHttpException(error);
+  return httpException.getResponse();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapErrorToHttpException,
+  onionErrorHandler,
+  registerHonoRoutes
+});
+//# sourceMappingURL=hono.cjs.map