@bombillazo/error-x 0.4.5 → 0.5.0

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var deepmergeTs = require('deepmerge-ts');
 var safeStringify = require('safe-stringify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -16,9 +17,7 @@ var ERROR_X_OPTION_FIELDS = [
   "uiMessage",
   "cause",
   "metadata",
-  "type",
-  "docsUrl",
-  "source"
+  "httpStatus"
 ];
 
 // src/error.ts
@@ -34,14 +33,33 @@ var ErrorX = class _ErrorX extends Error {
   metadata;
   /** Unix epoch timestamp (milliseconds) when the error was created */
   timestamp;
-  /** Error type for categorization */
-  type;
-  /** Documentation URL for this specific error */
-  docsUrl;
-  /** Where the error originated (service name, module, component) */
-  source;
-  /** Original error that caused this error (preserves error chain) */
-  cause;
+  /** HTTP status code associated with this error */
+  httpStatus;
+  /** Serialized non-ErrorX entity this was wrapped from (if created via ErrorX.from()) */
+  original;
+  /** Error chain timeline: [this, parent, grandparent, ...] - single source of truth */
+  _chain = [];
+  /**
+   * Gets the immediate parent ErrorX in the chain (if any).
+   * @returns The ErrorX that caused this error, or undefined if this is the root
+   */
+  get parent() {
+    return this._chain[1];
+  }
+  /**
+   * Gets the deepest ErrorX in the chain (the original root cause).
+   * @returns The root cause ErrorX, or undefined if chain has only this error
+   */
+  get root() {
+    return this._chain.length > 1 ? this._chain[this._chain.length - 1] : void 0;
+  }
+  /**
+   * Gets the full error chain timeline.
+   * @returns Array of ErrorX instances: [this, parent, grandparent, ...]
+   */
+  get chain() {
+    return this._chain;
+  }
   /**
    * Creates a new ErrorX instance with enhanced error handling capabilities.
    *
@@ -83,34 +101,26 @@ var ErrorX = class _ErrorX extends Error {
     } else if (messageOrOptions != null) {
       options = messageOrOptions;
     }
-    const envConfig = _ErrorX.getConfig();
     const message = options.message?.trim() ? options.message : "An error occurred";
-    const convertedCause = _ErrorX.toErrorXCause(options.cause);
     super(message);
-    this.cause = convertedCause;
     this.name = options.name ?? _ErrorX.getDefaultName();
     this.code = options.code != null ? String(options.code) : _ErrorX.generateDefaultCode(options.name);
     this.uiMessage = options.uiMessage;
     this.metadata = options.metadata;
-    this.type = _ErrorX.validateType(options.type);
     this.timestamp = Date.now();
-    this.source = options.source ?? envConfig?.source;
-    let generatedDocsUrl;
-    if (envConfig?.docsBaseURL && envConfig?.docsMap && this.code) {
-      const docPath = envConfig.docsMap[this.code];
-      if (docPath) {
-        const base = envConfig.docsBaseURL.replace(/\/+$/, "");
-        const path = docPath.replace(/^\/+/, "");
-        generatedDocsUrl = `${base}/${path}`;
+    this.httpStatus = options.httpStatus;
+    if (options.cause != null) {
+      if (options.cause instanceof _ErrorX) {
+        this._chain = [this, ...options.cause._chain];
+      } else {
+        const wrappedCause = _ErrorX.from(options.cause);
+        this._chain = [this, ...wrappedCause._chain];
       }
-    }
-    this.docsUrl = options.docsUrl ?? generatedDocsUrl;
-    if (convertedCause?.stack) {
-      this.stack = _ErrorX.preserveOriginalStackFromCause(convertedCause, this);
     } else {
-      if (typeof Error.captureStackTrace === "function") {
-        Error.captureStackTrace(this, this.constructor);
-      }
+      this._chain = [this];
+    }
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
     }
     this.stack = _ErrorX.cleanStack(this.stack);
   }
@@ -168,12 +178,7 @@ var ErrorX = class _ErrorX extends Error {
    * @example
    * ```typescript
    * ErrorX.configure({
-   *   source: 'my-api-service',
-   *   docsBaseURL: 'https://docs.example.com/errors',
-   *   docsMap: {
-   *     'AUTH_FAILED': 'authentication-errors',
-   *     'DB_ERROR': 'database-errors'
-   *   },
+   *   cleanStack: true, // Enable stack trace cleaning
    *   cleanStackDelimiter: 'app-entry-point' // Trim stack traces after this line
    * })
    * ```
@@ -201,22 +206,6 @@ var ErrorX = class _ErrorX extends Error {
   static resetConfig() {
     _ErrorX._config = null;
   }
-  /**
-   * Validates and normalizes the type field
-   *
-   * @param type - Type value to validate
-   * @returns Validated type string or undefined if invalid/empty
-   */
-  static validateType(type) {
-    if (type === void 0 || type === null) {
-      return void 0;
-    }
-    const typeStr = String(type).trim();
-    if (typeStr === "") {
-      return void 0;
-    }
-    return typeStr;
-  }
   /**
    * Validates if an object is a valid ErrorXOptions object.
    * Checks that the object only contains accepted ErrorXOptions fields.
@@ -256,21 +245,6 @@ var ErrorX = class _ErrorX extends Error {
     if (!name) return "ERROR";
     return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_]/g, "").toUpperCase();
   }
-  /**
-   * Preserves the original error's stack trace while updating the error message.
-   * Combines the new error's message with the original error's stack trace from ErrorXCause.
-   *
-   * @param cause - The ErrorXCause containing the original stack to preserve
-   * @param newError - The new error whose message to use
-   * @returns Combined stack trace with new error message and original stack
-   */
-  static preserveOriginalStackFromCause(cause, newError) {
-    if (!cause.stack) return newError.stack || "";
-    const newErrorFirstLine = `${newError.name}: ${newError.message}`;
-    const originalStackLines = cause.stack.split("\n");
-    const originalStackTrace = originalStackLines.slice(1);
-    return [newErrorFirstLine, ...originalStackTrace].join("\n");
-  }
   /**
    * Cleans a stack trace by removing ErrorX internal method calls and optionally trimming after a delimiter.
    * This provides cleaner stack traces that focus on user code.
@@ -302,7 +276,7 @@ var ErrorX = class _ErrorX extends Error {
       "new ErrorX",
       "ErrorX.constructor",
       "ErrorX.from",
-      "error-x/dist/",
+      "error-x/dist/error.js",
       "error-x/src/error.ts"
     ];
     const patterns = Array.isArray(cleanStackConfig) ? cleanStackConfig : defaultPatterns;
@@ -350,13 +324,12 @@ var ErrorX = class _ErrorX extends Error {
       name: this.name,
       code: this.code,
       uiMessage: this.uiMessage,
-      cause: this.cause,
       metadata: { ...this.metadata ?? {}, ...additionalMetadata },
-      type: this.type,
-      docsUrl: this.docsUrl,
-      source: this.source
+      httpStatus: this.httpStatus
     };
     const newError = new _ErrorX(options);
+    newError._chain = [newError, ...this._chain.slice(1)];
+    newError.original = this.original;
     if (this.stack) {
       newError.stack = this.stack;
     }
@@ -387,7 +360,8 @@ var ErrorX = class _ErrorX extends Error {
   /**
    * Converts unknown input into ErrorXOptions with intelligent property extraction.
    * Handles strings, regular Error objects, API response objects, and unknown values.
-   * This is a private helper method used by both the constructor and toErrorX.
+   * Extracts metadata directly from objects if present, without wrapping.
+   * This is a private helper method used by ErrorX.from().
    *
    * @param error - Value to convert to ErrorXOptions
    * @returns ErrorXOptions object with extracted properties
@@ -400,13 +374,10 @@ var ErrorX = class _ErrorX extends Error {
     let uiMessage = "";
     let cause;
     let metadata = {};
-    let type;
-    let href;
-    let source;
+    let httpStatus;
     if (error) {
       if (typeof error === "string") {
         message = error;
-        metadata = { originalError: error };
       } else if (error instanceof Error) {
         name = error.name;
         message = error.message;
@@ -425,24 +396,16 @@ var ErrorX = class _ErrorX extends Error {
         if ("code" in error && error.code) code = String(error.code);
         if ("uiMessage" in error && error.uiMessage) uiMessage = String(error.uiMessage);
         else if ("userMessage" in error && error.userMessage) uiMessage = String(error.userMessage);
-        if ("type" in error && error.type) {
-          type = _ErrorX.validateType(String(error.type));
+        if ("metadata" in error && typeof error.metadata === "object" && error.metadata !== null) {
+          metadata = error.metadata;
         }
-        if ("docsUrl" in error && error.docsUrl) {
-          href = String(error.docsUrl);
-        } else if ("href" in error && error.href) {
-          href = String(error.href);
-        } else if ("documentationUrl" in error && error.documentationUrl) {
-          href = String(error.documentationUrl);
+        if ("httpStatus" in error && typeof error.httpStatus === "number") {
+          httpStatus = error.httpStatus;
+        } else if ("status" in error && typeof error.status === "number") {
+          httpStatus = error.status;
+        } else if ("statusCode" in error && typeof error.statusCode === "number") {
+          httpStatus = error.statusCode;
         }
-        if ("source" in error && error.source) {
-          source = String(error.source);
-        } else if ("service" in error && error.service) {
-          source = String(error.service);
-        } else if ("component" in error && error.component) {
-          source = String(error.component);
-        }
-        metadata = { originalError: error };
       }
     }
     const options = {
@@ -453,15 +416,40 @@ var ErrorX = class _ErrorX extends Error {
     if (uiMessage) options.uiMessage = uiMessage;
     if (cause) options.cause = cause;
     if (Object.keys(metadata).length > 0) options.metadata = metadata;
-    if (type) options.type = type;
-    if (href) options.docsUrl = href;
-    if (source) options.source = source;
+    if (httpStatus !== void 0) options.httpStatus = httpStatus;
     return options;
   }
-  static from(error) {
-    if (error instanceof _ErrorX) return error;
-    const options = _ErrorX.convertUnknownToOptions(error);
-    return new _ErrorX(options);
+  static from(payload, overrides) {
+    if (payload instanceof _ErrorX) {
+      if (overrides && Object.keys(overrides).length > 0) {
+        const mergedOptions = {
+          message: overrides.message ?? payload.message,
+          name: overrides.name ?? payload.name,
+          code: overrides.code ?? payload.code,
+          uiMessage: overrides.uiMessage ?? payload.uiMessage,
+          httpStatus: overrides.httpStatus ?? payload.httpStatus,
+          metadata: overrides.metadata ? deepmergeTs.deepmerge(payload.metadata ?? {}, overrides.metadata) : payload.metadata
+        };
+        const newError = new _ErrorX(mergedOptions);
+        newError.original = payload.original;
+        newError._chain = [newError];
+        return newError;
+      }
+      return payload;
+    }
+    const extractedOptions = _ErrorX.convertUnknownToOptions(payload);
+    const finalOptions = overrides ? {
+      ...extractedOptions,
+      ...overrides,
+      metadata: extractedOptions.metadata || overrides.metadata ? deepmergeTs.deepmerge(extractedOptions.metadata ?? {}, overrides.metadata ?? {}) : void 0
+    } : extractedOptions;
+    const error = new _ErrorX(finalOptions);
+    error.original = _ErrorX.toErrorXCause(payload);
+    if (payload instanceof Error && payload.stack) {
+      error.stack = payload.stack;
+    }
+    error._chain = [error];
+    return error;
   }
   /**
    * Converts the ErrorX instance to a detailed string representation.
@@ -531,20 +519,28 @@ ${this.stack}`;
       metadata: safeMetadata,
       timestamp: this.timestamp
     };
-    if (this.type !== void 0) {
-      serialized.type = this.type;
-    }
-    if (this.docsUrl !== void 0) {
-      serialized.docsUrl = this.docsUrl;
-    }
-    if (this.source !== void 0) {
-      serialized.source = this.source;
+    if (this.httpStatus !== void 0) {
+      serialized.httpStatus = this.httpStatus;
     }
     if (this.stack) {
       serialized.stack = this.stack;
     }
-    if (this.cause) {
-      serialized.cause = this.cause;
+    if (this.original) {
+      serialized.original = this.original;
+    }
+    if (this._chain.length > 1) {
+      serialized.chain = this._chain.map((err) => {
+        const causeEntry = {
+          message: err.message
+        };
+        if (err.name) {
+          causeEntry.name = err.name;
+        }
+        if (err.stack) {
+          causeEntry.stack = err.stack;
+        }
+        return causeEntry;
+      });
     }
     return serialized;
   }
@@ -576,10 +572,7 @@ ${this.stack}`;
       name: serialized.name,
       code: serialized.code,
       uiMessage: serialized.uiMessage,
-      type: serialized.type,
-      docsUrl: serialized.docsUrl,
-      source: serialized.source,
-      cause: serialized.cause
+      httpStatus: serialized.httpStatus
     };
     if (serialized.metadata !== void 0) {
       options.metadata = serialized.metadata;
@@ -589,290 +582,629 @@ ${this.stack}`;
       error.stack = serialized.stack;
     }
     error.timestamp = serialized.timestamp;
+    if (serialized.original) {
+      error.original = serialized.original;
+    }
+    if (serialized.chain && serialized.chain.length > 0) {
+      const chainErrors = [error];
+      for (let i = 1; i < serialized.chain.length; i++) {
+        const causeData = serialized.chain[i];
+        if (!causeData) continue;
+        const chainErrorOptions = {
+          message: causeData.message
+        };
+        if (causeData.name) {
+          chainErrorOptions.name = causeData.name;
+        }
+        const chainError = new _ErrorX(chainErrorOptions);
+        if (causeData.stack) {
+          chainError.stack = causeData.stack;
+        }
+        chainErrors.push(chainError);
+      }
+      error._chain = chainErrors;
+    }
     return error;
   }
+  /**
+   * Creates a new instance of this error class using optional presets and overrides.
+   * This is a factory method that supports preset-based error creation with
+   * full TypeScript autocomplete for preset keys.
+   *
+   * Define static properties on your subclass to customize behavior:
+   * - `presets`: Record of preset configurations keyed by identifier
+   * - `defaultPreset`: Key of preset to use as fallback
+   * - `defaults`: Default values for all errors of this class
+   * - `transform`: Function to transform options before instantiation
+   *
+   * Supported call signatures:
+   * - `create()` - uses defaultPreset
+   * - `create(presetKey)` - uses specified preset
+   * - `create(presetKey, overrides)` - preset with overrides
+   * - `create(overrides)` - just overrides, uses defaultPreset
+   *
+   * @param presetKeyOrOverrides - Preset key (string/number) or overrides object
+   * @param overrides - Optional overrides when first arg is preset key
+   * @returns New instance of this error class
+   *
+   * @example
+   * ```typescript
+   * class DBError extends ErrorX<{ query?: string }> {
+   *   static presets = {
+   *     9333: { message: 'Connection timeout', code: 'TIMEOUT' },
+   *     CONN_REFUSED: { message: 'Connection refused', code: 'CONN_REFUSED' },
+   *     GENERIC: { message: 'A database error occurred', code: 'ERROR' },
+   *   }
+   *   static defaultPreset = 'GENERIC'
+   *   static defaults = { httpStatus: 500 }
+   *   static transform = (opts, ctx) => ({
+   *     ...opts,
+   *     code: `DB_${opts.code}`,
+   *   })
+   * }
+   *
+   * DBError.create()                           // uses defaultPreset
+   * DBError.create(9333)                       // uses preset 9333
+   * DBError.create('CONN_REFUSED')             // uses preset CONN_REFUSED
+   * DBError.create(9333, { message: 'Custom' }) // preset + overrides
+   * DBError.create({ message: 'Custom' })      // just overrides
+   * ```
+   */
+  static create(presetKeyOrOverrides, overrides) {
+    let presetKey;
+    let finalOverrides;
+    if (typeof presetKeyOrOverrides === "object" && presetKeyOrOverrides !== null) {
+      presetKey = void 0;
+      finalOverrides = presetKeyOrOverrides;
+    } else {
+      presetKey = presetKeyOrOverrides;
+      finalOverrides = overrides;
+    }
+    const ctor = this;
+    const presets = ctor.presets ?? {};
+    const defaultPreset = ctor.defaultPreset;
+    const defaults = ctor.defaults ?? {};
+    const transform = ctor.transform;
+    let resolvedPreset = {};
+    if (presetKey !== void 0) {
+      if (presetKey in presets) {
+        resolvedPreset = presets[presetKey] ?? {};
+      } else if (defaultPreset !== void 0 && defaultPreset in presets) {
+        resolvedPreset = presets[defaultPreset] ?? {};
+      }
+    } else if (defaultPreset !== void 0 && defaultPreset in presets) {
+      resolvedPreset = presets[defaultPreset] ?? {};
+    }
+    const mergedOptions = deepmergeTs.deepmerge(
+      defaults,
+      resolvedPreset,
+      finalOverrides ?? {}
+    );
+    const transformContext = { presetKey };
+    const finalOptions = transform ? transform(mergedOptions, transformContext) : mergedOptions;
+    return new this(finalOptions);
+  }
 };
 
-// src/presets.ts
-var http = {
+// src/presets/db-error.ts
+var dbPresets = {
+  // Connection errors
+  CONNECTION_FAILED: {
+    code: "CONNECTION_FAILED",
+    name: "DBConnectionError",
+    message: "Failed to connect to database.",
+    uiMessage: "Unable to connect to the database. Please try again later."
+  },
+  CONNECTION_TIMEOUT: {
+    code: "CONNECTION_TIMEOUT",
+    name: "DBConnectionTimeoutError",
+    message: "Database connection timed out.",
+    uiMessage: "The database connection timed out. Please try again."
+  },
+  CONNECTION_REFUSED: {
+    code: "CONNECTION_REFUSED",
+    name: "DBConnectionRefusedError",
+    message: "Database connection refused.",
+    uiMessage: "Unable to connect to the database. Please try again later."
+  },
+  CONNECTION_LOST: {
+    code: "CONNECTION_LOST",
+    name: "DBConnectionLostError",
+    message: "Database connection lost.",
+    uiMessage: "The database connection was lost. Please try again."
+  },
+  // Query errors
+  QUERY_FAILED: {
+    code: "QUERY_FAILED",
+    name: "DBQueryError",
+    message: "Database query failed.",
+    uiMessage: "The database operation failed. Please try again."
+  },
+  QUERY_TIMEOUT: {
+    code: "QUERY_TIMEOUT",
+    name: "DBQueryTimeoutError",
+    message: "Database query timed out.",
+    uiMessage: "The database operation took too long. Please try again."
+  },
+  SYNTAX_ERROR: {
+    code: "SYNTAX_ERROR",
+    name: "DBSyntaxError",
+    message: "Invalid query syntax.",
+    uiMessage: "An internal error occurred. Please contact support."
+  },
+  // Constraint errors
+  UNIQUE_VIOLATION: {
+    code: "UNIQUE_VIOLATION",
+    name: "DBUniqueViolationError",
+    message: "Unique constraint violation.",
+    uiMessage: "This record already exists.",
+    httpStatus: 409
+  },
+  FOREIGN_KEY_VIOLATION: {
+    code: "FOREIGN_KEY_VIOLATION",
+    name: "DBForeignKeyError",
+    message: "Foreign key constraint violation.",
+    uiMessage: "This operation references a record that does not exist.",
+    httpStatus: 400
+  },
+  NOT_NULL_VIOLATION: {
+    code: "NOT_NULL_VIOLATION",
+    name: "DBNotNullError",
+    message: "Not null constraint violation.",
+    uiMessage: "A required field is missing.",
+    httpStatus: 400
+  },
+  CHECK_VIOLATION: {
+    code: "CHECK_VIOLATION",
+    name: "DBCheckViolationError",
+    message: "Check constraint violation.",
+    uiMessage: "The provided data is invalid.",
+    httpStatus: 400
+  },
+  // Transaction errors
+  TRANSACTION_FAILED: {
+    code: "TRANSACTION_FAILED",
+    name: "DBTransactionError",
+    message: "Database transaction failed.",
+    uiMessage: "The operation failed. Please try again."
+  },
+  DEADLOCK: {
+    code: "DEADLOCK",
+    name: "DBDeadlockError",
+    message: "Database deadlock detected.",
+    uiMessage: "The operation encountered a conflict. Please try again.",
+    httpStatus: 409
+  },
+  // Record errors
+  NOT_FOUND: {
+    code: "NOT_FOUND",
+    name: "DBNotFoundError",
+    message: "Record not found.",
+    uiMessage: "The requested record was not found.",
+    httpStatus: 404
+  },
+  // Generic
+  UNKNOWN: {
+    code: "UNKNOWN",
+    name: "DBErrorX",
+    message: "An unknown database error occurred.",
+    uiMessage: "A database error occurred. Please try again later."
+  }
+};
+var DBErrorX = class _DBErrorX extends ErrorX {
+  /**
+   * Database error presets for common scenarios.
+   */
+  static presets = dbPresets;
+  /** Default to UNKNOWN when no preset specified */
+  static defaultPreset = "UNKNOWN";
+  /** Default httpStatus for database errors (500 = server error) */
+  static defaults = { httpStatus: 500 };
+  /**
+   * Transform that prefixes all codes with `DB_`.
+   */
+  static transform = (opts, _ctx) => {
+    const code = String(opts.code ?? "UNKNOWN");
+    return {
+      ...opts,
+      code: code.startsWith("DB_") ? code : `DB_${code}`
+    };
+  };
+  static create(presetKeyOrOverrides, overrides) {
+    return ErrorX.create.call(
+      _DBErrorX,
+      presetKeyOrOverrides,
+      overrides
+    );
+  }
+};
+
+// src/presets/http-error.ts
+var httpPresets = {
   // 4xx Client Errors
   400: {
     code: "BAD_REQUEST",
-    name: "Bad Request Error",
+    name: "BadRequestError",
     message: "Bad request.",
-    uiMessage: "The request could not be processed. Please check your input and try again.",
-    metadata: { status: 400 }
+    uiMessage: "The request could not be processed. Please check your input and try again."
   },
   401: {
     code: "UNAUTHORIZED",
-    name: "Unauthorized Error",
+    name: "UnauthorizedError",
     message: "Unauthorized.",
-    uiMessage: "Authentication required. Please log in to continue.",
-    metadata: { status: 401 }
+    uiMessage: "Authentication required. Please log in to continue."
   },
   402: {
     code: "PAYMENT_REQUIRED",
-    name: "Payment Required Error",
+    name: "PaymentRequiredError",
     message: "Payment required.",
-    uiMessage: "Payment is required to access this resource.",
-    metadata: { status: 402 }
+    uiMessage: "Payment is required to access this resource."
   },
   403: {
     code: "FORBIDDEN",
-    name: "Forbidden Error",
+    name: "ForbiddenError",
     message: "Forbidden.",
-    uiMessage: "You do not have permission to access this resource.",
-    metadata: { status: 403 }
+    uiMessage: "You do not have permission to access this resource."
   },
   404: {
     code: "NOT_FOUND",
-    name: "Not Found Error",
+    name: "NotFoundError",
     message: "Not found.",
-    uiMessage: "The requested resource could not be found.",
-    metadata: { status: 404 }
+    uiMessage: "The requested resource could not be found."
   },
   405: {
     code: "METHOD_NOT_ALLOWED",
-    name: "Method Not Allowed Error",
+    name: "MethodNotAllowedError",
     message: "Method not allowed.",
-    uiMessage: "This action is not allowed for the requested resource.",
-    metadata: { status: 405 }
+    uiMessage: "This action is not allowed for the requested resource."
   },
   406: {
     code: "NOT_ACCEPTABLE",
-    name: "Not Acceptable Error",
+    name: "NotAcceptableError",
     message: "Not acceptable.",
-    uiMessage: "The requested format is not supported.",
-    metadata: { status: 406 }
+    uiMessage: "The requested format is not supported."
   },
   407: {
     code: "PROXY_AUTHENTICATION_REQUIRED",
-    name: "Proxy Authentication Required Error",
+    name: "ProxyAuthenticationRequiredError",
     message: "Proxy authentication required.",
-    uiMessage: "Proxy authentication is required to access this resource.",
-    metadata: { status: 407 }
+    uiMessage: "Proxy authentication is required to access this resource."
   },
   408: {
     code: "REQUEST_TIMEOUT",
-    name: "Request Timeout Error",
+    name: "RequestTimeoutError",
     message: "Request timeout.",
-    uiMessage: "The request took too long to complete. Please try again.",
-    metadata: { status: 408 }
+    uiMessage: "The request took too long to complete. Please try again."
   },
   409: {
     code: "CONFLICT",
-    name: "Conflict Error",
+    name: "ConflictError",
     message: "Conflict.",
-    uiMessage: "The request conflicts with the current state. Please refresh and try again.",
-    metadata: { status: 409 }
+    uiMessage: "The request conflicts with the current state. Please refresh and try again."
   },
   410: {
     code: "GONE",
-    name: "Gone Error",
+    name: "GoneError",
     message: "Gone.",
-    uiMessage: "This resource is no longer available.",
-    metadata: { status: 410 }
+    uiMessage: "This resource is no longer available."
   },
   411: {
     code: "LENGTH_REQUIRED",
-    name: "Length Required Error",
+    name: "LengthRequiredError",
     message: "Length required.",
-    uiMessage: "The request is missing required length information.",
-    metadata: { status: 411 }
+    uiMessage: "The request is missing required length information."
   },
   412: {
     code: "PRECONDITION_FAILED",
-    name: "Precondition Failed Error",
+    name: "PreconditionFailedError",
     message: "Precondition failed.",
-    uiMessage: "A required condition was not met. Please try again.",
-    metadata: { status: 412 }
+    uiMessage: "A required condition was not met. Please try again."
   },
   413: {
     code: "PAYLOAD_TOO_LARGE",
-    name: "Payload Too Large Error",
+    name: "PayloadTooLargeError",
     message: "Payload too large.",
-    uiMessage: "The request is too large. Please reduce the size and try again.",
-    metadata: { status: 413 }
+    uiMessage: "The request is too large. Please reduce the size and try again."
   },
   414: {
     code: "URI_TOO_LONG",
-    name: "URI Too Long Error",
+    name: "UriTooLongError",
     message: "URI too long.",
-    uiMessage: "The request URL is too long.",
-    metadata: { status: 414 }
+    uiMessage: "The request URL is too long."
   },
   415: {
     code: "UNSUPPORTED_MEDIA_TYPE",
-    name: "Unsupported Media Type Error",
+    name: "UnsupportedMediaTypeError",
     message: "Unsupported media type.",
-    uiMessage: "The file type is not supported.",
-    metadata: { status: 415 }
+    uiMessage: "The file type is not supported."
   },
   416: {
     code: "RANGE_NOT_SATISFIABLE",
-    name: "Range Not Satisfiable Error",
+    name: "RangeNotSatisfiableError",
     message: "Range not satisfiable.",
-    uiMessage: "The requested range cannot be satisfied.",
-    metadata: { status: 416 }
+    uiMessage: "The requested range cannot be satisfied."
   },
   417: {
     code: "EXPECTATION_FAILED",
-    name: "Expectation Failed Error",
+    name: "ExpectationFailedError",
     message: "Expectation failed.",
-    uiMessage: "The server cannot meet the requirements of the request.",
-    metadata: { status: 417 }
+    uiMessage: "The server cannot meet the requirements of the request."
   },
   418: {
     code: "IM_A_TEAPOT",
-    name: "Im A Teapot Error",
+    name: "ImATeapotError",
     message: "I'm a teapot.",
-    uiMessage: "I'm a teapot and cannot brew coffee.",
-    metadata: { status: 418 }
+    uiMessage: "I'm a teapot and cannot brew coffee."
   },
   422: {
     code: "UNPROCESSABLE_ENTITY",
-    name: "Unprocessable Entity Error",
+    name: "UnprocessableEntityError",
     message: "Unprocessable entity.",
-    uiMessage: "The request contains invalid data. Please check your input.",
-    metadata: { status: 422 }
+    uiMessage: "The request contains invalid data. Please check your input."
   },
   423: {
     code: "LOCKED",
-    name: "Locked Error",
+    name: "LockedError",
     message: "Locked.",
-    uiMessage: "This resource is locked and cannot be modified.",
-    metadata: { status: 423 }
+    uiMessage: "This resource is locked and cannot be modified."
   },
   424: {
     code: "FAILED_DEPENDENCY",
-    name: "Failed Dependency Error",
+    name: "FailedDependencyError",
     message: "Failed dependency.",
-    uiMessage: "The request failed due to a dependency error.",
-    metadata: { status: 424 }
+    uiMessage: "The request failed due to a dependency error."
   },
   425: {
     code: "TOO_EARLY",
-    name: "Too Early Error",
+    name: "TooEarlyError",
     message: "Too early.",
-    uiMessage: "The request was sent too early. Please try again later.",
-    metadata: { status: 425 }
+    uiMessage: "The request was sent too early. Please try again later."
   },
   426: {
     code: "UPGRADE_REQUIRED",
-    name: "Upgrade Required Error",
+    name: "UpgradeRequiredError",
     message: "Upgrade required.",
-    uiMessage: "Please upgrade to continue using this service.",
-    metadata: { status: 426 }
+    uiMessage: "Please upgrade to continue using this service."
   },
   428: {
     code: "PRECONDITION_REQUIRED",
-    name: "Precondition Required Error",
+    name: "PreconditionRequiredError",
     message: "Precondition required.",
-    uiMessage: "Required conditions are missing from the request.",
-    metadata: { status: 428 }
+    uiMessage: "Required conditions are missing from the request."
   },
   429: {
     code: "TOO_MANY_REQUESTS",
-    name: "Too Many Requests Error",
+    name: "TooManyRequestsError",
     message: "Too many requests.",
-    uiMessage: "You have made too many requests. Please wait and try again.",
-    metadata: { status: 429 }
+    uiMessage: "You have made too many requests. Please wait and try again."
   },
   431: {
     code: "REQUEST_HEADER_FIELDS_TOO_LARGE",
-    name: "Request Header Fields Too Large Error",
+    name: "RequestHeaderFieldsTooLargeError",
     message: "Request header fields too large.",
-    uiMessage: "The request headers are too large.",
-    metadata: { status: 431 }
+    uiMessage: "The request headers are too large."
   },
   451: {
     code: "UNAVAILABLE_FOR_LEGAL_REASONS",
-    name: "Unavailable For Legal Reasons Error",
+    name: "UnavailableForLegalReasonsError",
     message: "Unavailable for legal reasons.",
-    uiMessage: "This content is unavailable for legal reasons.",
-    metadata: { status: 451 }
+    uiMessage: "This content is unavailable for legal reasons."
   },
   // 5xx Server Errors
   500: {
     code: "INTERNAL_SERVER_ERROR",
-    name: "Internal Server Error",
+    name: "InternalServerError",
     message: "Internal server error.",
-    uiMessage: "An unexpected error occurred. Please try again later.",
-    metadata: { status: 500 }
+    uiMessage: "An unexpected error occurred. Please try again later."
   },
   501: {
     code: "NOT_IMPLEMENTED",
-    name: "Not Implemented Error",
+    name: "NotImplementedError",
     message: "Not implemented.",
-    uiMessage: "This feature is not yet available.",
-    metadata: { status: 501 }
+    uiMessage: "This feature is not yet available."
   },
   502: {
     code: "BAD_GATEWAY",
-    name: "Bad Gateway Error",
+    name: "BadGatewayError",
     message: "Bad gateway.",
-    uiMessage: "Unable to connect to the server. Please try again later.",
-    metadata: { status: 502 }
+    uiMessage: "Unable to connect to the server. Please try again later."
   },
   503: {
     code: "SERVICE_UNAVAILABLE",
-    name: "Service Unavailable Error",
+    name: "ServiceUnavailableError",
     message: "Service unavailable.",
-    uiMessage: "The service is temporarily unavailable. Please try again later.",
-    metadata: { status: 503 }
+    uiMessage: "The service is temporarily unavailable. Please try again later."
   },
   504: {
     code: "GATEWAY_TIMEOUT",
-    name: "Gateway Timeout Error",
+    name: "GatewayTimeoutError",
     message: "Gateway timeout.",
-    uiMessage: "The server took too long to respond. Please try again.",
-    metadata: { status: 504 }
+    uiMessage: "The server took too long to respond. Please try again."
   },
   505: {
     code: "HTTP_VERSION_NOT_SUPPORTED",
-    name: "HTTP Version Not Supported Error",
+    name: "HttpVersionNotSupportedError",
     message: "HTTP version not supported.",
-    uiMessage: "Your browser version is not supported.",
-    metadata: { status: 505 }
+    uiMessage: "Your browser version is not supported."
   },
   506: {
     code: "VARIANT_ALSO_NEGOTIATES",
-    name: "Variant Also Negotiates Error",
+    name: "VariantAlsoNegotiatesError",
     message: "Variant also negotiates.",
-    uiMessage: "The server has an internal configuration error.",
-    metadata: { status: 506 }
+    uiMessage: "The server has an internal configuration error."
   },
   507: {
     code: "INSUFFICIENT_STORAGE",
-    name: "Insufficient Storage Error",
+    name: "InsufficientStorageError",
     message: "Insufficient storage.",
-    uiMessage: "The server has insufficient storage to complete the request.",
-    metadata: { status: 507 }
+    uiMessage: "The server has insufficient storage to complete the request."
   },
   508: {
     code: "LOOP_DETECTED",
-    name: "Loop Detected Error",
+    name: "LoopDetectedError",
     message: "Loop detected.",
-    uiMessage: "The server detected an infinite loop.",
-    metadata: { status: 508 }
+    uiMessage: "The server detected an infinite loop."
   },
   510: {
     code: "NOT_EXTENDED",
-    name: "Not Extended Error",
+    name: "NotExtendedError",
     message: "Not extended.",
-    uiMessage: "Additional extensions are required.",
-    metadata: { status: 510 }
+    uiMessage: "Additional extensions are required."
   },
   511: {
     code: "NETWORK_AUTHENTICATION_REQUIRED",
-    name: "Network Authentication Required Error",
+    name: "NetworkAuthenticationRequiredError",
     message: "Network authentication required.",
-    uiMessage: "Network authentication is required to access this resource.",
-    metadata: { status: 511 }
+    uiMessage: "Network authentication is required to access this resource."
+  }
+};
+var HTTPErrorX = class _HTTPErrorX extends ErrorX {
+  /**
+   * HTTP status code presets for all standard codes.
+   * Keys are numeric status codes (400, 401, 404, 500, etc.)
+   */
+  static presets = httpPresets;
+  /** Default to 500 Internal Server Error when no preset specified */
+  static defaultPreset = 500;
+  /** Default httpStatus for all HTTPErrorXs */
+  static defaults = { httpStatus: 500 };
+  /**
+   * Transform that automatically sets httpStatus from the preset key.
+   * Only sets httpStatus from presetKey if it matches a known preset.
+   */
+  static transform = (opts, { presetKey }) => ({
+    ...opts,
+    httpStatus: typeof presetKey === "number" && presetKey in httpPresets ? presetKey : opts.httpStatus
+  });
+  static create(statusCodeOrOverrides, overrides) {
+    return ErrorX.create.call(
+      _HTTPErrorX,
+      statusCodeOrOverrides,
+      overrides
+    );
+  }
+};
+
+// src/presets/validation-error.ts
+var ValidationErrorX = class _ValidationErrorX extends ErrorX {
+  /** Default httpStatus for validation errors (400 = bad request) */
+  static defaults = {
+    httpStatus: 400,
+    name: "ValidationErrorX",
+    code: "VALIDATION_ERROR",
+    message: "Validation failed.",
+    uiMessage: "The provided input is invalid. Please check your data."
+  };
+  /**
+   * Transform that maps Zod issue codes to VALIDATION_ prefixed codes.
+   * Converts Zod's snake_case codes to SCREAMING_SNAKE_CASE.
+   */
+  static transform = (opts, _ctx) => {
+    const code = String(opts.code ?? "ERROR").toUpperCase();
+    return {
+      ...opts,
+      code: code.startsWith("VALIDATION_") ? code : `VALIDATION_${code}`
+    };
+  };
+  /**
+   * Creates a ValidationErrorX from a Zod error.
+   *
+   * Maps Zod's error structure to ErrorX:
+   * - Uses first issue's message as the error message
+   * - Converts Zod issue code to ErrorX code (e.g., 'invalid_type' → 'VALIDATION_INVALID_TYPE')
+   * - Captures all issues in metadata for multi-error handling
+   *
+   * @param zodError - The Zod error object (or any object with `issues` array)
+   * @param overrides - Optional overrides for any ErrorX options
+   * @returns ValidationErrorX instance
+   *
+   * @example
+   * ```typescript
+   * // Basic usage
+   * try {
+   *   schema.parse(data)
+   * } catch (err) {
+   *   if (err instanceof ZodError) {
+   *     throw ValidationErrorX.fromZodError(err)
+   *   }
+   * }
+   *
+   * // With custom uiMessage
+   * ValidationErrorX.fromZodError(zodError, {
+   *   uiMessage: 'Please fix the form errors',
+   * })
+   *
+   * // Access all issues
+   * const error = ValidationErrorX.fromZodError(zodError)
+   * error.metadata?.issues?.forEach(issue => {
+   *   console.log(`${issue.path.join('.')}: ${issue.message}`)
+   * })
+   * ```
+   */
+  static fromZodError(zodError, overrides) {
+    const firstIssue = zodError.issues[0];
+    const fieldPath = firstIssue?.path.join(".");
+    const zodCode = firstIssue?.code ?? "unknown";
+    const errorCode = zodCode.toUpperCase().replace(/-/g, "_");
+    const metadata = {
+      zodCode,
+      issueCount: zodError.issues.length,
+      issues: zodError.issues
+    };
+    if (fieldPath) metadata.field = fieldPath;
+    if (firstIssue?.path) metadata.path = firstIssue.path;
+    if (firstIssue?.expected) metadata.expected = firstIssue.expected;
+    if (firstIssue?.received) metadata.received = firstIssue.received;
+    const mergedOpts = {
+      ..._ValidationErrorX.defaults,
+      code: errorCode,
+      message: firstIssue?.message ?? "Validation failed",
+      metadata,
+      ...overrides
+    };
+    const transformedOpts = _ValidationErrorX.transform(mergedOpts, { presetKey: void 0 });
+    return new _ValidationErrorX(transformedOpts);
+  }
+  /**
+   * Creates a ValidationErrorX for a specific field.
+   * Convenience method for manual validation errors.
+   *
+   * @param field - The field name that failed validation
+   * @param message - The error message
+   * @param options - Additional options
+   * @returns ValidationErrorX instance
+   *
+   * @example
+   * ```typescript
+   * // Simple field error
+   * throw ValidationErrorX.forField('email', 'Invalid email format')
+   *
+   * // With code
+   * throw ValidationErrorX.forField('age', 'Must be 18 or older', {
+   *   code: 'TOO_YOUNG',
+   * })
+   * ```
+   */
+  static forField(field, message, options) {
+    const mergedOpts = {
+      ..._ValidationErrorX.defaults,
+      message,
+      code: options?.code ?? "INVALID_FIELD",
+      metadata: {
+        field,
+        path: field.split("."),
+        ...options?.metadata
+      },
+      ...options
+    };
+    const transformedOpts = _ValidationErrorX.transform(mergedOpts, { presetKey: void 0 });
+    return new _ValidationErrorX(transformedOpts);
   }
 };
 
+exports.DBErrorX = DBErrorX;
 exports.ErrorX = ErrorX;
-exports.http = http;
+exports.HTTPErrorX = HTTPErrorX;
+exports.ValidationErrorX = ValidationErrorX;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map