@zudojs/errors 0.1.1 → 1.0.1

package/dist/domain/schema/schemaError.types.js

@@ -2,13 +2,19 @@
  * Specific schema error classes.
  */
 import { ErrorCode } from "../../base/types/errorCode.type.js";
+import { describeValue, safeStringify, sanitizeFragment, } from "../shared/domainError.helpers.js";
 import { SchemaError } from "./schemaError.base.js";
+/*
+ * Messages built here never embed the received (submitted) value; they use a
+ * type/size description instead. Expected values come from the schema
+ * definition and are serialized with a non-throwing stringifier.
+ */
 /**
  * Error thrown when a value does not match the expected type.
  */
 export class SchemaTypeError extends SchemaError {
     constructor(expected, received, path = []) {
-        super(`Expected ${expected}, received ${received}`, {
+        super(`Expected ${sanitizeFragment(expected)}, received ${sanitizeFragment(received)}`, {
             code: ErrorCode.SCHEMA_INVALID_TYPE,
             issues: [{ code: "invalid_type", path, expected, received }],
         });
@@ -19,7 +25,7 @@ export class SchemaTypeError extends SchemaError {
  */
 export class SchemaLiteralError extends SchemaError {
     constructor(expected, received, path = []) {
-        super(`Expected literal ${JSON.stringify(expected)}, received ${JSON.stringify(received)}`, {
+        super(`Expected literal ${sanitizeFragment(safeStringify(expected))}, received ${describeValue(received)}`, {
             code: ErrorCode.SCHEMA_INVALID_LITERAL,
             issues: [{ code: "invalid_literal", path, expected, received }],
         });
@@ -30,7 +36,7 @@ export class SchemaLiteralError extends SchemaError {
  */
 export class SchemaEnumError extends SchemaError {
     constructor(expected, received, path = []) {
-        super(`Expected one of ${expected.map((v) => JSON.stringify(v)).join(", ")}`, {
+        super(`Expected one of ${sanitizeFragment(expected.map((v) => safeStringify(v)).join(", "))}, received ${describeValue(received)}`, {
             code: ErrorCode.SCHEMA_INVALID_ENUM,
             issues: [{ code: "invalid_enum", path, expected, received }],
         });
@@ -85,9 +91,10 @@ export class SchemaUnionError extends SchemaError {
  */
 export class SchemaUnknownKeyError extends SchemaError {
     constructor(key, path = []) {
-        super(`Unknown key: ${key}`, {
+        const safeKey = sanitizeFragment(key);
+        super(`Unknown key: ${safeKey}`, {
             code: ErrorCode.SCHEMA_UNKNOWN_KEY,
-            issues: [{ code: "unknown_keys", path, key }],
+            issues: [{ code: "unknown_keys", path, key: safeKey }],
         });
     }
 }

package/dist/domain/serialization/serializationError.base.d.ts

@@ -4,6 +4,7 @@
 import { BaseError } from "../../base/core/baseError.core.js";
 import type { BaseErrorOptions } from "../../base/types/baseError.type.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
+import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
 /** Options for creating a serialization error. */
 export interface SerializationErrorOptions extends Omit<BaseErrorOptions, "category"> {
@@ -19,6 +20,12 @@ export interface SerializationErrorOptions extends Omit<BaseErrorOptions, "categ
 /** Base error for all serialization subsystem failures. */
 export declare class SerializationError extends BaseError {
     readonly format?: string;
+    readonly depth?: number;
+    readonly maxDepth?: number;
+    readonly size?: number;
+    readonly maxSize?: number;
+    readonly transformerType?: string;
+    readonly serializerName?: string;
     constructor(message: string, options?: SerializationErrorOptions);
     toJSON(): {
         name: string;
@@ -32,7 +39,6 @@ export declare class SerializationError extends BaseError {
         metadata: Readonly<import("../../index.js").ErrorMetadata>;
         stack?: string;
         cause?: import("../../base/types/baseError.type.js").SerializedBaseError | unknown;
-        format?: string | undefined;
     };
 }
 /** Creates a serialization error. */
@@ -42,6 +48,6 @@ export declare function isSerializationError(value: unknown): value is Serializa
 /** Converts an unknown thrown value into a SerializationError. */
 export declare function toSerializationError(error: unknown, options?: {
     message?: string;
-    code?: string;
+    code?: ErrorCode | string;
 }): SerializationError;
 //# sourceMappingURL=serializationError.base.d.ts.map

package/dist/domain/serialization/serializationError.base.js

@@ -5,10 +5,33 @@ import { BaseError } from "../../base/core/baseError.core.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import { safeErrorMessage } from "../shared/domainError.helpers.js";
+/** Diagnostic fields carried by serialization errors. */
+const DIAGNOSTIC_KEYS = [
+    "format",
+    "depth",
+    "maxDepth",
+    "size",
+    "maxSize",
+    "transformerType",
+    "serializerName",
+];
 /** Base error for all serialization subsystem failures. */
 export class SerializationError extends BaseError {
     format;
+    depth;
+    maxDepth;
+    size;
+    maxSize;
+    transformerType;
+    serializerName;
     constructor(message, options = {}) {
+        const diagnostics = {};
+        for (const key of DIAGNOSTIC_KEYS) {
+            const value = options[key];
+            if (value !== undefined)
+                diagnostics[key] = value;
+        }
         super(message, {
             ...options,
             code: options.code ?? ErrorCode.SERIALIZATION,
@@ -17,13 +40,26 @@ export class SerializationError extends BaseError {
             statusCode: options.statusCode ?? 500,
             expose: options.expose ?? false,
             isOperational: options.isOperational ?? true,
+            metadata: { ...options.metadata, ...diagnostics },
         });
         this.format = options.format;
+        this.depth = options.depth;
+        this.maxDepth = options.maxDepth;
+        this.size = options.size;
+        this.maxSize = options.maxSize;
+        this.transformerType = options.transformerType;
+        this.serializerName = options.serializerName;
     }
     toJSON() {
+        const diagnostics = {};
+        for (const key of DIAGNOSTIC_KEYS) {
+            const value = this[key];
+            if (value !== undefined)
+                diagnostics[key] = value;
+        }
         return {
             ...super.toJSON(),
-            ...(this.format !== undefined ? { format: this.format } : {}),
+            ...diagnostics,
         };
     }
 }
@@ -40,13 +76,7 @@ export function toSerializationError(error, options = {}) {
     if (error instanceof SerializationError) {
         return error;
     }
-    if (error instanceof Error) {
-        return new SerializationError(options.message ?? error.message, {
-            code: options.code,
-            cause: error,
-        });
-    }
-    return new SerializationError(options.message ?? String(error), {
+    return new SerializationError(options.message ?? safeErrorMessage(error), {
         code: options.code,
         cause: error,
     });

package/dist/domain/serialization/serializationError.types.d.ts

@@ -9,7 +9,12 @@ export declare class SerializeError extends SerializationError {
         cause?: unknown;
     });
 }
-/** Error thrown when deserialization fails. */
+/**
+ * Error thrown when deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a 400
+ * that may be exposed.
+ */
 export declare class DeserializeError extends SerializationError {
     constructor(message: string, options?: {
         format?: string;
@@ -25,20 +30,34 @@ export declare class SerializerNotFoundError extends SerializationError {
     readonly serializerName: string;
     constructor(name: string);
 }
-/** Error thrown when a circular reference is detected during serialization. */
+/**
+ * Error thrown when a circular reference is detected during serialization.
+ *
+ * Circular data is a server-side data bug, so this is an internal (500) error.
+ */
 export declare class CircularReferenceError extends SerializationError {
     readonly circularPath: string;
     constructor(path?: string);
 }
-/** Error thrown when maximum serialization depth is exceeded. */
+/**
+ * Error thrown when maximum serialization depth is exceeded.
+ *
+ * Over-deep data is a server-side data bug, so this is an internal (500) error.
+ */
 export declare class SerializationDepthError extends SerializationError {
     readonly depth: number;
+    readonly maxDepth: number;
+    /** @deprecated Use `maxDepth`. */
     readonly maxDepthValue: number;
     constructor(depth: number, maxDepth: number);
 }
 /** Error thrown when a serialized payload exceeds the size limit. */
 export declare class SerializationPayloadTooLargeError extends SerializationError {
+    readonly size: number;
+    readonly maxSize: number;
+    /** @deprecated Use `size`. */
     readonly payloadSize: number;
+    /** @deprecated Use `maxSize`. */
     readonly maxSizeValue: number;
     constructor(size: number, maxSize: number);
 }

package/dist/domain/serialization/serializationError.types.js

@@ -13,13 +13,20 @@ export class SerializeError extends SerializationError {
         });
     }
 }
-/** Error thrown when deserialization fails. */
+/**
+ * Error thrown when deserialization fails.
+ *
+ * Malformed serialized input is a client/input problem, so this is a 400
+ * that may be exposed.
+ */
 export class DeserializeError extends SerializationError {
     constructor(message, options = {}) {
         super(message, {
             code: ErrorCode.DESERIALIZATION_FAILED,
             format: options.format,
             cause: options.cause,
+            statusCode: 400,
+            expose: true,
         });
     }
 }
@@ -47,37 +54,53 @@ export class SerializerNotFoundError extends SerializationError {
         this.serializerName = name;
     }
 }
-/** Error thrown when a circular reference is detected during serialization. */
+/**
+ * Error thrown when a circular reference is detected during serialization.
+ *
+ * Circular data is a server-side data bug, so this is an internal (500) error.
+ */
 export class CircularReferenceError extends SerializationError {
     circularPath;
     constructor(path = "root") {
         super(`Circular reference detected at "${path}"`, {
             code: ErrorCode.CIRCULAR_REFERENCE,
-            statusCode: 400,
+            statusCode: 500,
             expose: false,
+            metadata: { circularPath: path },
         });
         this.circularPath = path;
     }
 }
-/** Error thrown when maximum serialization depth is exceeded. */
+/**
+ * Error thrown when maximum serialization depth is exceeded.
+ *
+ * Over-deep data is a server-side data bug, so this is an internal (500) error.
+ */
 export class SerializationDepthError extends SerializationError {
     depth;
+    maxDepth;
+    /** @deprecated Use `maxDepth`. */
     maxDepthValue;
     constructor(depth, maxDepth) {
         super(`Maximum serialization depth exceeded: ${depth} > ${maxDepth}`, {
             code: ErrorCode.MAX_DEPTH_EXCEEDED,
             depth,
             maxDepth,
-            statusCode: 400,
+            statusCode: 500,
             expose: false,
         });
         this.depth = depth;
+        this.maxDepth = maxDepth;
         this.maxDepthValue = maxDepth;
     }
 }
 /** Error thrown when a serialized payload exceeds the size limit. */
 export class SerializationPayloadTooLargeError extends SerializationError {
+    size;
+    maxSize;
+    /** @deprecated Use `size`. */
     payloadSize;
+    /** @deprecated Use `maxSize`. */
     maxSizeValue;
     constructor(size, maxSize) {
         super(`Serialized payload too large: ${size} bytes (max: ${maxSize})`, {
@@ -87,6 +110,8 @@ export class SerializationPayloadTooLargeError extends SerializationError {
             statusCode: 413,
             expose: false,
         });
+        this.size = size;
+        this.maxSize = maxSize;
         this.payloadSize = size;
         this.maxSizeValue = maxSize;
     }

package/dist/domain/shared/domainError.helpers.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared helpers for domain error classes.
+ *
+ * These utilities keep untrusted input out of error messages, make
+ * normalizers robust against exotic thrown values, and validate the
+ * numeric arguments that domain errors record.
+ */
+import type { ErrorMetadata } from "../../base/core/errorMetadata.type.js";
+/** Default maximum length for untrusted strings embedded in messages. */
+export declare const MAX_MESSAGE_FRAGMENT_LENGTH = 200;
+/** Default maximum length for untrusted strings stored in metadata. */
+export declare const MAX_METADATA_FRAGMENT_LENGTH = 1024;
+/**
+ * Removes control characters (including newlines and ANSI escapes) and
+ * truncates the string so it can be safely embedded in a message or log line.
+ */
+export declare function sanitizeFragment(value: unknown, maxLength?: number): string;
+/**
+ * Serializes any value to a string without throwing.
+ *
+ * Handles BigInt, circular structures, symbols, and objects whose
+ * `toString` throws. Never returns more than `maxLength` characters.
+ */
+export declare function safeStringify(value: unknown, maxLength?: number): string;
+/**
+ * Describes a value by type and size without revealing its contents.
+ *
+ * Use this instead of embedding submitted values into exposed messages.
+ */
+export declare function describeValue(value: unknown): string;
+/**
+ * Produces a message for an unknown thrown value without throwing.
+ */
+export declare function safeErrorMessage(error: unknown): string;
+/**
+ * Asserts that a numeric argument is finite and non-negative.
+ */
+export declare function assertFiniteNonNegative(name: string, value: number): number;
+/**
+ * Normalizes a retry-after value in seconds to a finite, non-negative integer
+ * (rounded up), as required by the HTTP `Retry-After` header.
+ */
+export declare function normalizeRetryAfterSeconds(value: number, name?: string): number;
+/**
+ * Merges caller-provided metadata with class-specific fields, letting the
+ * class-specific fields win.
+ */
+export declare function mergeMetadata(callerMetadata: ErrorMetadata | undefined, own: ErrorMetadata): ErrorMetadata;
+/**
+ * Removes submitted values from a list of issue objects so they can be
+ * exposed to clients. Values are replaced by a type/size description under
+ * `<key>Type`.
+ */
+export declare function redactIssueValues<T>(issues: readonly T[]): readonly T[];
+/**
+ * Converts issue objects into JSON-safe structures (no BigInt, no cycles)
+ * so that `JSON.stringify` on the error never throws.
+ */
+export declare function toJsonSafeIssues<T>(issues: readonly T[]): readonly T[];
+//# sourceMappingURL=domainError.helpers.d.ts.map

package/dist/domain/shared/domainError.helpers.js

@@ -0,0 +1,191 @@
+/**
+ * Shared helpers for domain error classes.
+ *
+ * These utilities keep untrusted input out of error messages, make
+ * normalizers robust against exotic thrown values, and validate the
+ * numeric arguments that domain errors record.
+ */
+/** Default maximum length for untrusted strings embedded in messages. */
+export const MAX_MESSAGE_FRAGMENT_LENGTH = 200;
+/** Control characters (C0 range, DEL, and C1 range) that must not reach logs. */
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
+/** Default maximum length for untrusted strings stored in metadata. */
+export const MAX_METADATA_FRAGMENT_LENGTH = 1024;
+/**
+ * Removes control characters (including newlines and ANSI escapes) and
+ * truncates the string so it can be safely embedded in a message or log line.
+ */
+export function sanitizeFragment(value, maxLength = MAX_MESSAGE_FRAGMENT_LENGTH) {
+    const text = typeof value === "string" ? value : safeStringify(value);
+    const cleaned = text.replace(CONTROL_CHARS, " ");
+    if (cleaned.length <= maxLength)
+        return cleaned;
+    return `${cleaned.slice(0, maxLength)}… [truncated ${cleaned.length - maxLength} chars]`;
+}
+/**
+ * Serializes any value to a string without throwing.
+ *
+ * Handles BigInt, circular structures, symbols, and objects whose
+ * `toString` throws. Never returns more than `maxLength` characters.
+ */
+export function safeStringify(value, maxLength = MAX_METADATA_FRAGMENT_LENGTH) {
+    let text;
+    try {
+        if (typeof value === "string") {
+            text = value;
+        }
+        else if (typeof value === "bigint") {
+            text = `${value.toString()}n`;
+        }
+        else if (typeof value === "symbol") {
+            text = value.toString();
+        }
+        else if (typeof value === "function") {
+            text = `[function ${value.name || "anonymous"}]`;
+        }
+        else if (value === undefined) {
+            text = "undefined";
+        }
+        else {
+            const seen = new WeakSet();
+            const json = JSON.stringify(value, (_key, item) => {
+                if (typeof item === "bigint")
+                    return `${item.toString()}n`;
+                if (typeof item === "symbol")
+                    return item.toString();
+                if (typeof item === "object" && item !== null) {
+                    if (seen.has(item))
+                        return "[Circular]";
+                    seen.add(item);
+                }
+                return item;
+            });
+            text = json === undefined ? String(value) : json;
+        }
+    }
+    catch {
+        try {
+            text = Object.prototype.toString.call(value);
+        }
+        catch {
+            text = "[unserializable]";
+        }
+    }
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength)}…`;
+}
+/**
+ * Describes a value by type and size without revealing its contents.
+ *
+ * Use this instead of embedding submitted values into exposed messages.
+ */
+export function describeValue(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (Array.isArray(value))
+        return `array(${value.length})`;
+    switch (typeof value) {
+        case "string":
+            return `string(${value.length})`;
+        case "number":
+            return Number.isFinite(value) ? "number" : `number(${String(value)})`;
+        case "bigint":
+            return "bigint";
+        case "boolean":
+            return `boolean(${String(value)})`;
+        case "symbol":
+            return "symbol";
+        case "function":
+            return "function";
+        default: {
+            if (value instanceof Date)
+                return "date";
+            const proto = Object.getPrototypeOf(value);
+            if (proto === null || proto === Object.prototype)
+                return "object";
+            const name = value.constructor
+                ?.name;
+            return name ? `object(${name})` : "object";
+        }
+    }
+}
+/**
+ * Produces a message for an unknown thrown value without throwing.
+ */
+export function safeErrorMessage(error) {
+    if (error instanceof Error) {
+        return typeof error.message === "string" ? error.message : "Unknown error";
+    }
+    if (typeof error === "string")
+        return error;
+    if (error === null || error === undefined)
+        return "Unknown error";
+    const text = safeStringify(error, MAX_MESSAGE_FRAGMENT_LENGTH);
+    return text.length > 0 ? text : "Unknown error";
+}
+/**
+ * Asserts that a numeric argument is finite and non-negative.
+ */
+export function assertFiniteNonNegative(name, value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new RangeError(`${name} must be a finite non-negative number.`);
+    }
+    return value;
+}
+/**
+ * Normalizes a retry-after value in seconds to a finite, non-negative integer
+ * (rounded up), as required by the HTTP `Retry-After` header.
+ */
+export function normalizeRetryAfterSeconds(value, name = "retryAfterSeconds") {
+    return Math.ceil(assertFiniteNonNegative(name, value));
+}
+/**
+ * Merges caller-provided metadata with class-specific fields, letting the
+ * class-specific fields win.
+ */
+export function mergeMetadata(callerMetadata, own) {
+    return { ...(callerMetadata ?? {}), ...own };
+}
+/** Keys that hold submitted values inside validation/schema issues. */
+const VALUE_KEYS = new Set(["value", "received", "input", "actual"]);
+/**
+ * Removes submitted values from a list of issue objects so they can be
+ * exposed to clients. Values are replaced by a type/size description under
+ * `<key>Type`.
+ */
+export function redactIssueValues(issues) {
+    return issues.map((issue) => {
+        if (typeof issue !== "object" || issue === null || Array.isArray(issue)) {
+            return issue;
+        }
+        const out = {};
+        for (const [key, val] of Object.entries(issue)) {
+            if (VALUE_KEYS.has(key)) {
+                out[`${key}Type`] = describeValue(val);
+            }
+            else {
+                out[key] = val;
+            }
+        }
+        return out;
+    });
+}
+/**
+ * Converts issue objects into JSON-safe structures (no BigInt, no cycles)
+ * so that `JSON.stringify` on the error never throws.
+ */
+export function toJsonSafeIssues(issues) {
+    return issues.map((issue) => {
+        try {
+            return JSON.parse(safeStringify(issue, Number.POSITIVE_INFINITY));
+        }
+        catch {
+            return issue;
+        }
+    });
+}
+//# sourceMappingURL=domainError.helpers.js.map

package/dist/domain/state/conflict.error.d.ts

@@ -21,6 +21,6 @@ export declare function isConflictError(value: unknown): value is ConflictError;
 export declare function alreadyExistsError(resource: string, identifier?: string | number): ConflictError;
 /** Creates an error indicating that a duplicate value was submitted. */
 export declare function duplicateError(field: string, value?: string | number): ConflictError;
-/** Creates an error indicating that a resource is currently locked. */
+/** Creates an error indicating that a resource is currently locked (HTTP 423). */
 export declare function resourceLockedError(resource: string, identifier?: string | number): ConflictError;
 //# sourceMappingURL=conflict.error.d.ts.map

package/dist/domain/state/conflict.error.js

@@ -58,7 +58,7 @@ export function duplicateError(field, value) {
         },
     });
 }
-/** Creates an error indicating that a resource is currently locked. */
+/** Creates an error indicating that a resource is currently locked (HTTP 423). */
 export function resourceLockedError(resource, identifier) {
     const message = identifier !== undefined
         ? `${resource} with identifier "${String(identifier)}" is currently locked.`
@@ -66,7 +66,7 @@ export function resourceLockedError(resource, identifier) {
     return new ConflictError(message, {
         code: ErrorCode.RESOURCE_LOCKED,
         category: ErrorCategory.CONFLICT,
-        statusCode: 409,
+        statusCode: 423,
         expose: true,
         metadata: {
             resource,

package/dist/domain/state/validationError.base.d.ts

@@ -31,7 +31,14 @@ export declare class ValidationError extends BaseError {
     get issueCount(): number;
     /** Returns issues associated with a specific field. */
     issuesForField(field: string): readonly ValidationIssue[];
-    /** Returns a serialized representation including validation issues. */
+    /**
+     * Returns a serialized representation including validation issues.
+     *
+     * When the error is exposable (the default), submitted values inside
+     * issues (`value`) are replaced by a type/size description so that secrets
+     * such as passwords are never echoed to clients or written to logs. The
+     * output is always JSON-safe (BigInt and cyclic values are stringified).
+     */
     toJSON(): {
         name: string;
         message: string;

package/dist/domain/state/validationError.base.js

@@ -2,6 +2,7 @@ import { BaseError } from "../../base/core/baseError.core.js";
 import { ErrorCategory } from "../../base/types/errorCategory.type.js";
 import { ErrorCode } from "../../base/types/errorCode.type.js";
 import { ErrorSeverity } from "../../base/types/errorSeverity.type.js";
+import { redactIssueValues, toJsonSafeIssues, } from "../shared/domainError.helpers.js";
 /**
  * Error raised when input fails validation.
  */
@@ -31,11 +32,19 @@ export class ValidationError extends BaseError {
     issuesForField(field) {
         return this.issues.filter((issue) => issue.field === field || issue.path?.[0] === field);
     }
-    /** Returns a serialized representation including validation issues. */
+    /**
+     * Returns a serialized representation including validation issues.
+     *
+     * When the error is exposable (the default), submitted values inside
+     * issues (`value`) are replaced by a type/size description so that secrets
+     * such as passwords are never echoed to clients or written to logs. The
+     * output is always JSON-safe (BigInt and cyclic values are stringified).
+     */
     toJSON() {
+        const safeIssues = toJsonSafeIssues(this.issues);
         return {
             ...super.toJSON(),
-            issues: this.issues,
+            issues: this.expose ? redactIssueValues(safeIssues) : safeIssues,
         };
     }
 }

package/dist/infrastructure/adapter/adapterError.base.js

@@ -41,10 +41,10 @@ export class AdapterNotFoundError extends AdapterError {
         super(`Adapter "${adapterName}" is not registered.`, {
             code: ErrorCode.ADAPTER_NOT_FOUND,
             adapter: adapterName,
-            statusCode: 404,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "AdapterNotFoundError";
     }
 }
 /** Error thrown when an adapter is already registered. */
@@ -53,10 +53,10 @@ export class AdapterAlreadyRegisteredError extends AdapterError {
         super(`Adapter "${adapterName}" is already registered.`, {
             code: ErrorCode.ADAPTER_ALREADY_REGISTERED,
             adapter: adapterName,
-            statusCode: 409,
-            expose: true,
+            statusCode: 500,
+            expose: false,
+            isOperational: false,
         });
-        this.name = "AdapterAlreadyRegisteredError";
     }
 }
 //# sourceMappingURL=adapterError.base.js.map