@cosmneo/onion-lasagna 0.2.0 → 0.2.1

package/dist/http/index.cjs

@@ -22,38 +22,114 @@ var http_exports = {};
 __export(http_exports, {
   buildPath: () => buildPath,
   collectRoutes: () => collectRoutes,
+  createErrorResponseBody: () => createErrorResponseBody,
   createPassthroughAdapter: () => createPassthroughAdapter,
   createRejectingAdapter: () => createRejectingAdapter,
   defineRoute: () => defineRoute,
   defineRouter: () => defineRouter,
   generateOpenAPI: () => generateOpenAPI,
+  generateOperationId: () => generateOperationId,
+  getHttpStatusCode: () => getHttpStatusCode,
   getPathParamNames: () => getPathParamNames,
   hasPathParams: () => hasPathParams,
+  hasValidationErrors: () => hasValidationErrors,
+  isErrorType: () => isErrorType,
   isRouteDefinition: () => isRouteDefinition,
   isRouterDefinition: () => isRouterDefinition,
   isSchemaAdapter: () => isSchemaAdapter,
   isValidationFailure: () => isValidationFailure,
   isValidationSuccess: () => isValidationSuccess,
+  mapErrorToHttpResponse: () => mapErrorToHttpResponse,
   mergeRouters: () => mergeRouters,
   normalizePath: () => normalizePath,
   pathToRegex: () => pathToRegex,
-  serverRoutes: () => serverRoutes
+  serverRoutes: () => serverRoutes,
+  shouldMaskError: () => shouldMaskError
 });
 module.exports = __toCommonJS(http_exports);
 
+// src/presentation/http/schema/types/validation.type.ts
+function isValidationSuccess(result) {
+  return result.success === true;
+}
+function isValidationFailure(result) {
+  return result.success === false;
+}
+
+// src/presentation/http/schema/types/schema-adapter.type.ts
+function isSchemaAdapter(value) {
+  return typeof value === "object" && value !== null && "validate" in value && typeof value.validate === "function" && "toJsonSchema" in value && typeof value.toJsonSchema === "function";
+}
+function createPassthroughAdapter() {
+  return {
+    validate: (data) => ({ success: true, data }),
+    toJsonSchema: () => ({}),
+    _output: void 0,
+    _input: void 0
+  };
+}
+function createRejectingAdapter(message) {
+  return {
+    validate: () => ({
+      success: false,
+      issues: [{ path: [], message }]
+    }),
+    toJsonSchema: () => ({ not: {} }),
+    _output: void 0,
+    _input: void 0
+  };
+}
+
 // src/presentation/http/route/define-route.ts
+function extractSchema(field) {
+  if (field == null) return void 0;
+  if (isSchemaAdapter(field)) return field;
+  return field.schema;
+}
+function extractMeta(field) {
+  if (field == null || isSchemaAdapter(field)) return void 0;
+  const config = field;
+  if (config.description == null && config.contentType == null && config.required == null) {
+    return void 0;
+  }
+  return {
+    description: config.description,
+    contentType: config.contentType,
+    required: config.required
+  };
+}
+function normalizeResponses(responses) {
+  const result = {};
+  for (const [key, value] of Object.entries(responses)) {
+    result[String(key)] = value;
+  }
+  return result;
+}
 function defineRoute(input) {
+  const req = input.request;
+  const bodyMeta = extractMeta(req?.body);
+  const queryMeta = extractMeta(req?.query);
+  const paramsMeta = extractMeta(req?.params);
+  const headersMeta = extractMeta(req?.headers);
+  const contextMeta = extractMeta(req?.context);
+  const _meta = {
+    ...bodyMeta ? { body: bodyMeta } : {},
+    ...queryMeta ? { query: { description: queryMeta.description } } : {},
+    ...paramsMeta ? { params: { description: paramsMeta.description } } : {},
+    ...headersMeta ? { headers: { description: headersMeta.description } } : {},
+    ...contextMeta ? { context: { description: contextMeta.description } } : {}
+  };
   const definition = {
     method: input.method,
     path: input.path,
     request: {
-      body: input.request?.body ?? void 0,
-      query: input.request?.query ?? void 0,
-      params: input.request?.params ?? void 0,
-      headers: input.request?.headers ?? void 0,
-      context: input.request?.context ?? void 0
+      body: extractSchema(req?.body) ?? void 0,
+      query: extractSchema(req?.query) ?? void 0,
+      params: extractSchema(req?.params) ?? void 0,
+      headers: extractSchema(req?.headers) ?? void 0,
+      context: extractSchema(req?.context) ?? void 0
     },
-    responses: input.responses,
+    responses: input.responses ? normalizeResponses(input.responses) : void 0,
     docs: {
       summary: input.docs?.summary,
       description: input.docs?.description,
@@ -63,6 +139,7 @@ function defineRoute(input) {
       security: input.docs?.security,
       externalDocs: input.docs?.externalDocs
     },
+    _meta,
     _types: void 0
   };
   return Object.freeze(definition);
@@ -95,7 +172,7 @@ function normalizePath(path) {
 
 // src/presentation/http/route/types/router-definition.type.ts
 function isRouteDefinition(value) {
-  return typeof value === "object" && value !== null && "method" in value && "path" in value && "responses" in value && "_types" in value;
+  return typeof value === "object" && value !== null && "method" in value && "path" in value && "_types" in value;
 }
 function isRouterDefinition(value) {
   return typeof value === "object" && value !== null && "_isRouter" in value && value._isRouter === true;
@@ -117,14 +194,59 @@ function collectRoutes(config, basePath = "") {
 
 // src/presentation/http/route/define-router.ts
 function defineRouter(routes, options) {
+  const defaults = options?.defaults;
+  const processedRoutes = defaults?.context || defaults?.tags ? applyRouterDefaults(routes, defaults) : routes;
   const definition = {
-    routes,
+    routes: processedRoutes,
     basePath: options?.basePath,
-    tags: options?.tags,
+    defaults,
     _isRouter: true
   };
   return deepFreeze(definition);
 }
+function applyRouterDefaults(routes, defaults) {
+  const result = {};
+  for (const [key, value] of Object.entries(routes)) {
+    if (isRouteDefinition(value)) {
+      result[key] = applyDefaultsToRoute(value, defaults);
+    } else if (isRouterDefinition(value)) {
+      result[key] = {
+        ...value,
+        routes: applyRouterDefaults(value.routes, defaults)
+      };
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = applyRouterDefaults(value, defaults);
+    }
+  }
+  return result;
+}
+function applyDefaultsToRoute(route, defaults) {
+  const needsContext = defaults.context && !route.request.context;
+  const needsTags = defaults.tags && defaults.tags.length > 0;
+  if (!needsContext && !needsTags) return route;
+  return Object.freeze({
+    ...route,
+    request: {
+      ...route.request,
+      context: route.request.context ?? defaults.context ?? void 0
+    },
+    docs: {
+      ...route.docs,
+      tags: mergeTags(defaults.tags, route.docs.tags)
+    }
+  });
+}
+function mergeTags(routerTags, routeTags) {
+  if (!routerTags || routerTags.length === 0) return routeTags;
+  if (!routeTags || routeTags.length === 0) return routerTags;
+  const merged = [...routerTags];
+  for (const tag of routeTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}
 function deepFreeze(obj) {
   const propNames = Object.getOwnPropertyNames(obj);
   for (const name of propNames) {
@@ -159,36 +281,11 @@ function mergeRouters(...routers) {
   return defineRouter(merged);
 }
 
-// src/presentation/http/schema/types/validation.type.ts
-function isValidationSuccess(result) {
-  return result.success === true;
-}
-function isValidationFailure(result) {
-  return result.success === false;
-}
-
-// src/presentation/http/schema/types/schema-adapter.type.ts
-function isSchemaAdapter(value) {
-  return typeof value === "object" && value !== null && "validate" in value && typeof value.validate === "function" && "toJsonSchema" in value && typeof value.toJsonSchema === "function";
-}
-function createPassthroughAdapter() {
-  return {
-    validate: (data) => ({ success: true, data }),
-    toJsonSchema: () => ({}),
-    _output: void 0,
-    _input: void 0
-  };
-}
-function createRejectingAdapter(message) {
-  return {
-    validate: () => ({
-      success: false,
-      issues: [{ path: [], message }]
-    }),
-    toJsonSchema: () => ({ not: {} }),
-    _output: void 0,
-    _input: void 0
-  };
+// src/presentation/http/route/utils.ts
+function generateOperationId(key) {
+  return key.split(".").map(
+    (segment, index) => index === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1)
+  ).join("");
 }
 
 // src/presentation/http/server/types.ts
@@ -489,7 +586,7 @@ function createServerRoutesInternal(router, handlers, options) {
         `Missing handler for route "${key}". All routes must have a handler configuration.`
       );
     }
-    result.push(createRouteHandler(route, handlerConfig, resolvedOptions));
+    result.push(createRouteHandler(key, route, handlerConfig, resolvedOptions));
   }
   return result;
 }
@@ -514,7 +611,7 @@ function sortRoutesBySpecificity(routes) {
     return 0;
   });
 }
-function createRouteHandler(route, config, options) {
+function createRouteHandler(key, route, config, options) {
   const middleware = config.middleware ?? [];
   const globalMiddleware = options?.middleware ?? [];
   const allMiddleware = [...globalMiddleware, ...middleware];
@@ -524,7 +621,7 @@ function createRouteHandler(route, config, options) {
     method: route.method,
     path: normalizePath(route.path),
     metadata: {
-      operationId: route.docs.operationId,
+      operationId: route.docs.operationId ?? generateOperationId(key),
       summary: route.docs.summary,
       description: route.docs.description,
       tags: route.docs.tags,
@@ -532,7 +629,7 @@ function createRouteHandler(route, config, options) {
     },
     handler: async (rawRequest, ctx) => {
       const rawContext = options?.createContext ? options.createContext(rawRequest) : ctx ?? { requestId: generateRequestId() };
-      const validatedContext = route.request.context?.schema ? wrapError(
+      const validatedContext = route.request.context ? wrapError(
         () => {
           const result = validateContextData(route, rawContext);
           if (!result.success) {
@@ -636,8 +733,8 @@ function createRouteHandler(route, config, options) {
 function validateRequestData(route, rawRequest) {
   const errors = [];
   const data = {};
-  if (route.request.body?.schema) {
-    const result = route.request.body.schema.validate(rawRequest.body);
+  if (route.request.body) {
+    const result = route.request.body.validate(rawRequest.body);
     if (result.success) {
       data.body = result.data;
     } else {
@@ -649,9 +746,9 @@ function validateRequestData(route, rawRequest) {
       );
     }
   }
-  if (route.request.query?.schema) {
+  if (route.request.query) {
     const queryObj = normalizeQuery(rawRequest.query);
-    const result = route.request.query.schema.validate(queryObj);
+    const result = route.request.query.validate(queryObj);
     if (result.success) {
       data.query = result.data;
     } else {
@@ -663,8 +760,8 @@ function validateRequestData(route, rawRequest) {
       );
     }
   }
-  if (route.request.params?.schema) {
-    const result = route.request.params.schema.validate(rawRequest.params ?? {});
+  if (route.request.params) {
+    const result = route.request.params.validate(rawRequest.params ?? {});
     if (result.success) {
       data.pathParams = result.data;
     } else {
@@ -678,9 +775,9 @@ function validateRequestData(route, rawRequest) {
   } else {
     data.pathParams = normalizePathParams(rawRequest.params);
   }
-  if (route.request.headers?.schema) {
+  if (route.request.headers) {
     const headersObj = normalizeHeaders(rawRequest.headers);
-    const result = route.request.headers.schema.validate(headersObj);
+    const result = route.request.headers.validate(headersObj);
     if (result.success) {
       data.headers = result.data;
     } else {
@@ -698,13 +795,11 @@ function validateRequestData(route, rawRequest) {
   return { success: true, data };
 }
 function validateResponseData(route, response) {
-  const statusCode = String(response.status);
-  const responses = route.responses;
-  const responseConfig = responses[statusCode];
-  if (!responseConfig) {
+  if (!route.responses) {
     return { success: true };
   }
-  const schema = responseConfig.schema;
+  const entry = route.responses[String(response.status)];
+  const schema = entry?.schema;
   if (!schema) {
     return { success: true };
   }
@@ -719,7 +814,7 @@ function validateResponseData(route, response) {
   return { success: false, errors };
 }
 function validateContextData(route, context) {
-  const contextSchema = route.request.context?.schema;
+  const contextSchema = route.request.context;
   if (!contextSchema) {
     return { success: true, data: context };
   }
@@ -857,12 +952,12 @@ function generateOpenAPI(router, config) {
   const collectedRoutes = collectRoutes(routes);
   const paths = {};
   const allTags = /* @__PURE__ */ new Set();
-  for (const { route } of collectedRoutes) {
+  for (const { key, route } of collectedRoutes) {
     const openAPIPath = convertToOpenAPIPath(route.path);
     if (!paths[openAPIPath]) {
       paths[openAPIPath] = {};
     }
-    const operation = buildOperation(route);
+    const operation = buildOperation(key, route);
     const method = route.method.toLowerCase();
     paths[openAPIPath][method] = operation;
     if (operation.tags) {
@@ -904,13 +999,12 @@ function generateOpenAPI(router, config) {
 function convertToOpenAPIPath(path) {
   return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}");
 }
-function buildOperation(route) {
+function buildOperation(key, route) {
   const operation = {
     responses: buildResponses(route)
   };
-  if (route.docs.operationId) {
-    operation.operationId = route.docs.operationId;
-  }
+  const operationId = route.docs.operationId ?? generateOperationId(key);
+  operation.operationId = operationId;
   if (route.docs.summary) {
     operation.summary = route.docs.summary;
   }
@@ -948,8 +1042,8 @@ function buildParameters(route) {
       required: true,
       schema: { type: "string" }
     };
-    if (route.request.params?.schema) {
-      const jsonSchema = route.request.params.schema.toJsonSchema();
+    if (route.request.params) {
+      const jsonSchema = route.request.params.toJsonSchema();
       if (jsonSchema.properties && typeof jsonSchema.properties === "object") {
         const propSchema = jsonSchema.properties[name];
         if (isValidJsonSchema(propSchema)) {
@@ -959,8 +1053,8 @@ function buildParameters(route) {
     }
     parameters.push(param);
   }
-  if (route.request.query?.schema) {
-    const querySchema = route.request.query.schema.toJsonSchema();
+  if (route.request.query) {
+    const querySchema = route.request.query.toJsonSchema();
     if (querySchema.properties && typeof querySchema.properties === "object") {
       const requiredFields = new Set(
         Array.isArray(querySchema.required) ? querySchema.required : []
@@ -984,8 +1078,8 @@ function buildParameters(route) {
       }
     }
   }
-  if (route.request.headers?.schema) {
-    const headersSchema = route.request.headers.schema.toJsonSchema();
+  if (route.request.headers) {
+    const headersSchema = route.request.headers.toJsonSchema();
     if (headersSchema.properties && typeof headersSchema.properties === "object") {
       const requiredFields = new Set(
         Array.isArray(headersSchema.required) ? headersSchema.required : []
@@ -1009,63 +1103,439 @@ function buildParameters(route) {
   return parameters;
 }
 function buildRequestBody(route) {
-  const bodyConfig = route.request.body;
-  const contentType = bodyConfig.contentType ?? "application/json";
+  const bodySchema = route.request.body;
+  const meta = route._meta?.body;
+  const contentType = meta?.contentType ?? "application/json";
   const requestBody = {
-    required: bodyConfig.required !== false,
+    required: meta?.required !== false,
     content: {
       [contentType]: {
-        schema: bodyConfig.schema.toJsonSchema()
+        schema: bodySchema.toJsonSchema()
       }
     }
   };
-  if (bodyConfig.description) {
-    requestBody.description = bodyConfig.description;
+  if (meta?.description) {
+    requestBody.description = meta.description;
   }
   return requestBody;
 }
 function buildResponses(route) {
   const responses = {};
-  for (const [statusCode, responseConfig] of Object.entries(route.responses)) {
-    if (!responseConfig || typeof responseConfig !== "object") continue;
-    const response = {
-      description: responseConfig.description ?? `Response ${statusCode}`
-    };
-    const schema = responseConfig.schema;
-    if (schema) {
-      const contentType = responseConfig.contentType ?? "application/json";
-      response.content = {
-        [contentType]: {
-          schema: schema.toJsonSchema()
-        }
-      };
+  if (route.responses && Object.keys(route.responses).length > 0) {
+    for (const [statusCode, config] of Object.entries(route.responses)) {
+      const description = config.description ?? `Response ${statusCode}`;
+      if (config.schema) {
+        const contentType = config.contentType ?? "application/json";
+        responses[statusCode] = {
+          description,
+          content: {
+            [contentType]: {
+              schema: config.schema.toJsonSchema()
+            }
+          }
+        };
+      } else {
+        responses[statusCode] = { description };
+      }
     }
-    responses[statusCode] = response;
-  }
-  if (Object.keys(responses).length === 0) {
+  } else {
     responses["200"] = { description: "Successful response" };
   }
   return responses;
 }
+
+// src/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/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/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/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/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/app/exceptions/forbidden.error.ts
+var ForbiddenError = class _ForbiddenError extends UseCaseError {
+  /**
+   * Creates a new ForbiddenError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why authorization was denied
+   * @param options.code - Machine-readable error code (default: 'FORBIDDEN')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.FORBIDDEN,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates a ForbiddenError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new ForbiddenError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _ForbiddenError({
+      message: cause instanceof Error ? cause.message : "Operation forbidden",
+      cause
+    });
+  }
+};
+
+// src/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/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/presentation/http/shared/error-mapping.ts
+var MASKED_ERROR_BODY = {
+  message: "An unexpected error occurred",
+  errorCode: "INTERNAL_ERROR"
+};
+var INTERNAL_ERROR_TYPES = [
+  "DomainError",
+  "InfraError",
+  "ControllerError",
+  "NetworkError",
+  "PersistenceError",
+  "ExternalServiceError",
+  "InvariantViolationError"
+];
+function isErrorType(error, typeName) {
+  if (!error || typeof error !== "object") return false;
+  const constructor = Object.prototype.hasOwnProperty.call(error, "constructor") ? error.constructor : Object.getPrototypeOf(error)?.constructor;
+  if (!constructor) return false;
+  const name = constructor.name;
+  return name === typeName || name === `_${typeName}`;
+}
+function hasValidationErrors(error) {
+  if (!error || typeof error !== "object") return false;
+  return "validationErrors" in error && Array.isArray(error.validationErrors);
+}
+function buildValidationErrorBody(message, code, validationErrors) {
+  return {
+    message,
+    errorCode: code,
+    errorItems: validationErrors.map((e) => ({
+      item: e.field,
+      message: e.message
+    }))
+  };
+}
+function buildSimpleErrorBody(message, code) {
+  return {
+    message,
+    errorCode: code
+  };
+}
+function getHttpStatusCode(error) {
+  if (error instanceof ObjectValidationError) return 400;
+  if (error instanceof InvalidRequestError) return 400;
+  if (error instanceof UnauthorizedError) return 401;
+  if (error instanceof ForbiddenError) return 403;
+  if (error instanceof AccessDeniedError) return 403;
+  if (error instanceof NotFoundError) return 404;
+  if (error instanceof ConflictError) return 409;
+  if (error instanceof UnprocessableError) return 422;
+  if (error instanceof UseCaseError) return 400;
+  if (isErrorType(error, "ObjectValidationError")) return 400;
+  if (isErrorType(error, "InvalidRequestError")) return 400;
+  if (isErrorType(error, "UnauthorizedError")) return 401;
+  if (isErrorType(error, "ForbiddenError")) return 403;
+  if (isErrorType(error, "AccessDeniedError")) return 403;
+  if (isErrorType(error, "NotFoundError")) return 404;
+  if (isErrorType(error, "ConflictError")) return 409;
+  if (isErrorType(error, "UnprocessableError")) return 422;
+  if (isErrorType(error, "UseCaseError")) return 400;
+  return 500;
+}
+function shouldMaskError(error) {
+  if (error instanceof DomainError || error instanceof InfraError || error instanceof ControllerError) {
+    return true;
+  }
+  for (const errorType of INTERNAL_ERROR_TYPES) {
+    if (isErrorType(error, errorType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createErrorResponseBody(error) {
+  if (shouldMaskError(error)) {
+    return MASKED_ERROR_BODY;
+  }
+  if (error instanceof ObjectValidationError) {
+    return buildValidationErrorBody(error.message, error.code, error.validationErrors);
+  }
+  if (error instanceof InvalidRequestError) {
+    return buildValidationErrorBody(error.message, error.code, error.validationErrors);
+  }
+  if (isErrorType(error, "ObjectValidationError") && hasValidationErrors(error)) {
+    return buildValidationErrorBody(error.message, error.code, error.validationErrors);
+  }
+  if (isErrorType(error, "InvalidRequestError") && hasValidationErrors(error)) {
+    return buildValidationErrorBody(error.message, error.code, error.validationErrors);
+  }
+  if (error instanceof CodedError) {
+    return buildSimpleErrorBody(error.message, error.code);
+  }
+  if (isErrorType(error, "CodedError")) {
+    return buildSimpleErrorBody(error.message, error.code);
+  }
+  if (error && typeof error === "object" && "message" in error && "code" in error && typeof error.message === "string" && typeof error.code === "string") {
+    return buildSimpleErrorBody(error.message, error.code);
+  }
+  return MASKED_ERROR_BODY;
+}
+function mapErrorToHttpResponse(error) {
+  return {
+    status: getHttpStatusCode(error),
+    body: createErrorResponseBody(error)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildPath,
   collectRoutes,
+  createErrorResponseBody,
   createPassthroughAdapter,
   createRejectingAdapter,
   defineRoute,
   defineRouter,
   generateOpenAPI,
+  generateOperationId,
+  getHttpStatusCode,
   getPathParamNames,
   hasPathParams,
+  hasValidationErrors,
+  isErrorType,
   isRouteDefinition,
   isRouterDefinition,
   isSchemaAdapter,
   isValidationFailure,
   isValidationSuccess,
+  mapErrorToHttpResponse,
   mergeRouters,
   normalizePath,
   pathToRegex,
-  serverRoutes
+  serverRoutes,
+  shouldMaskError
 });
 //# sourceMappingURL=index.cjs.map