@cosmneo/onion-lasagna 0.3.0 → 0.4.0

package/dist/graphql/shared/index.cjs

@@ -0,0 +1,586 @@
+"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/presentation/graphql/shared/index.ts
+var shared_exports = {};
+__export(shared_exports, {
+  getGraphQLErrorCode: () => getGraphQLErrorCode,
+  mapErrorToGraphQLError: () => mapErrorToGraphQLError,
+  shouldMaskGraphQLError: () => shouldMaskGraphQLError
+});
+module.exports = __toCommonJS(shared_exports);
+
+// src/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/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",
+    /** Authorization denied - user lacks permission for this operation */
+    FORBIDDEN: "FORBIDDEN",
+    /** Authentication required or invalid - user is not authenticated */
+    UNAUTHORIZED: "UNAUTHORIZED"
+  },
+  /**
+   * 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/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/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/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/app/exceptions/unauthorized.error.ts
+var UnauthorizedError = class _UnauthorizedError extends UseCaseError {
+  /**
+   * Creates a new UnauthorizedError instance.
+   *
+   * @param options - Error configuration
+   * @param options.message - Description of why authentication failed
+   * @param options.code - Machine-readable error code (default: 'UNAUTHORIZED')
+   * @param options.cause - Optional underlying error
+   */
+  constructor({
+    message,
+    code = ErrorCodes.App.UNAUTHORIZED,
+    cause
+  }) {
+    super({ message, code, cause });
+  }
+  /**
+   * Creates an UnauthorizedError from a caught error.
+   *
+   * @param cause - The original caught error
+   * @returns A new UnauthorizedError instance with the cause attached
+   */
+  static fromError(cause) {
+    return new _UnauthorizedError({
+      message: cause instanceof Error ? cause.message : "Authentication required",
+      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
+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);
+}
+
+// src/presentation/graphql/shared/error-mapping.ts
+var MASKED_ERROR = {
+  message: "An unexpected error occurred",
+  extensions: { code: "INTERNAL_ERROR" }
+};
+var INTERNAL_ERROR_TYPES = [
+  "DomainError",
+  "InfraError",
+  "ControllerError",
+  "NetworkError",
+  "PersistenceError",
+  "ExternalServiceError",
+  "InvariantViolationError"
+];
+function getGraphQLErrorCode(error) {
+  if (error instanceof ObjectValidationError) return "VALIDATION_ERROR";
+  if (error instanceof UnauthorizedError) return "FORBIDDEN";
+  if (error instanceof ForbiddenError) return "FORBIDDEN";
+  if (error instanceof AccessDeniedError) return "FORBIDDEN";
+  if (error instanceof NotFoundError) return "NOT_FOUND";
+  if (error instanceof ConflictError) return "CONFLICT";
+  if (error instanceof UnprocessableError) return "UNPROCESSABLE";
+  if (error instanceof UseCaseError) return "BAD_REQUEST";
+  if (isErrorType(error, "ObjectValidationError")) return "VALIDATION_ERROR";
+  if (isErrorType(error, "UnauthorizedError")) return "FORBIDDEN";
+  if (isErrorType(error, "ForbiddenError")) return "FORBIDDEN";
+  if (isErrorType(error, "AccessDeniedError")) return "FORBIDDEN";
+  if (isErrorType(error, "NotFoundError")) return "NOT_FOUND";
+  if (isErrorType(error, "ConflictError")) return "CONFLICT";
+  if (isErrorType(error, "UnprocessableError")) return "UNPROCESSABLE";
+  if (isErrorType(error, "UseCaseError")) return "BAD_REQUEST";
+  return "INTERNAL_ERROR";
+}
+function shouldMaskGraphQLError(error) {
+  if (error instanceof DomainError || error instanceof InfraError) {
+    return true;
+  }
+  for (const errorType of INTERNAL_ERROR_TYPES) {
+    if (isErrorType(error, errorType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function mapErrorToGraphQLError(error) {
+  if (shouldMaskGraphQLError(error)) {
+    return MASKED_ERROR;
+  }
+  const code = getGraphQLErrorCode(error);
+  if (error instanceof ObjectValidationError) {
+    return buildValidationError(error.message, code, error.code, error.validationErrors);
+  }
+  if (isErrorType(error, "ObjectValidationError") && hasValidationErrors(error)) {
+    return buildValidationError(error.message, code, error.code, error.validationErrors);
+  }
+  if (error instanceof CodedError) {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  if (isErrorType(error, "CodedError")) {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  if (error && typeof error === "object" && "message" in error && "code" in error && typeof error.message === "string" && typeof error.code === "string") {
+    return {
+      message: error.message,
+      extensions: { code, originalCode: error.code }
+    };
+  }
+  return MASKED_ERROR;
+}
+function buildValidationError(message, code, originalCode, validationErrors) {
+  return {
+    message,
+    extensions: {
+      code,
+      originalCode,
+      validationErrors: validationErrors.map(
+        (e) => ({
+          field: e.field,
+          message: e.message
+        })
+      )
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getGraphQLErrorCode,
+  mapErrorToGraphQLError,
+  shouldMaskGraphQLError
+});
+//# sourceMappingURL=index.cjs.map