@zudojs/errors 1.0.1 → 1.2.0

package/dist/utils/errorSerializer.core.js

@@ -2,7 +2,9 @@
  * Converts errors into safe, predictable serialized structures.
  */
 import { BaseError } from "../base/core/baseError.core.js";
-import { isSensitiveMetadataKey, pickErrorMetadata, redactErrorMetadata, REDACTED_METADATA_VALUE, } from "../base/core/errorMetadata.core.js";
+import { pickErrorMetadata, redactErrorMetadata, } from "../base/core/errorMetadata.core.js";
+import { isGenuineSerializedBaseError, MAX_CAUSE_DEPTH, toJSONWithFrame, } from "../base/core/baseError.serialize.js";
+import { redactCauseFields, redactCauseValue, } from "../base/core/errorCause.redact.js";
 import { normalizeUnknownError } from "./errorSerializer.factory.js";
 export { createErrorSerializer, serializeError, serializePublicError, normalizeUnknownError, } from "./errorSerializer.factory.js";
 /** Converts errors into safe, predictable serialized structures. */
@@ -27,10 +29,12 @@ export class ErrorSerializer {
      * Serializes an error for internal logging or monitoring.
      *
      * `includeStack`, `includeCause` and `redactSensitiveData` are applied at
-     * every level of the cause chain.
+     * every level of the cause chain, including array causes and plain-object
+     * causes that merely look like a serialized BaseError.
      */
     serialize(error) {
-        return this.serializeLevel(error.toJSON());
+        const raw = toJSONWithFrame(error, { depth: 0, redact: false });
+        return this.serializeLevel(raw, 0);
     }
     /**
      * Serializes an error for an untrusted API client.
@@ -58,7 +62,7 @@ export class ErrorSerializer {
         return this.serializePublic(normalizeUnknownError(value));
     }
     /** Applies the serializer options to one level of a serialized error. */
-    serializeLevel(serialized) {
+    serializeLevel(serialized, depth) {
         const { stack, cause, metadata, ...rest } = serialized;
         const result = {
             ...rest,
@@ -69,25 +73,33 @@ export class ErrorSerializer {
                 : {},
             ...(this.includeStack && stack !== undefined ? { stack } : {}),
             ...(this.includeCause && cause !== undefined
-                ? { cause: this.serializeCause(cause) }
+                ? { cause: this.serializeCause(cause, depth + 1) }
                 : {}),
         };
         return result;
     }
-    /** Applies the serializer options recursively to a serialized cause. */
-    serializeCause(cause) {
+    /**
+     * Applies the serializer options recursively to a serialized cause.
+     *
+     * Only objects that a BaseError's `toJSON` really produced are treated as
+     * serialized BaseErrors (whose `metadata` alone needs redacting). Anything
+     * else, including a plain object carrying the same field names and any
+     * array, has every field walked and redacted.
+     */
+    serializeCause(cause, depth) {
+        if (depth > MAX_CAUSE_DEPTH)
+            return "[MaxDepth]";
         if (cause === null || typeof cause !== "object")
             return cause;
-        if (Array.isArray(cause))
-            return cause;
+        if (Array.isArray(cause)) {
+            return this.redactSensitiveData
+                ? redactCauseValue(cause, this.sensitiveKeyPattern)
+                : cause;
+        }
         const record = cause;
-        if (isSerializedBaseError(record)) {
-            return this.serializeLevel(record);
+        if (isGenuineSerializedBaseError(record)) {
+            return this.serializeLevel(record, depth);
         }
-        // Native error shape: { name, message, stack?, cause? } — or an
-        // arbitrary plain object that was thrown/attached as a cause. The
-        // latter reaches here by reference and used to be copied verbatim, so
-        // `redactSensitiveData` did not apply to it.
         const { stack, cause: nested, ...rest } = record;
         const fields = this.redactSensitiveData
             ? redactCauseFields(rest, this.sensitiveKeyPattern, new WeakSet([record]))
@@ -95,7 +107,9 @@ export class ErrorSerializer {
         return {
             ...fields,
             ...(this.includeStack && stack !== undefined ? { stack } : {}),
-            ...(nested !== undefined ? { cause: this.serializeCause(nested) } : {}),
+            ...(nested !== undefined
+                ? { cause: this.serializeCause(nested, depth + 1) }
+                : {}),
         };
     }
     /** Computes the metadata allowed in a public response. */
@@ -124,64 +138,4 @@ export class ErrorSerializer {
         });
     }
 }
-/** Plain objects (Object.prototype or null prototype) are walked; anything else is kept as-is. */
-function isPlainRecord(value) {
-    if (value === null || typeof value !== "object")
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-/**
- * Redacts sensitive keys inside a non-BaseError cause without changing its
- * shape: primitives, dates and class instances are kept, plain objects and
- * arrays are walked, cycles stop at "[Circular]".
- */
-function redactCauseFields(fields, pattern, seen = new WeakSet()) {
-    const result = {};
-    for (const key of Object.keys(fields)) {
-        if (key === "__proto__" || key === "constructor" || key === "prototype")
-            continue;
-        const value = fields[key];
-        const sensitive = pattern === undefined
-            ? isSensitiveMetadataKey(key)
-            : isSensitiveMetadataKey(key, pattern);
-        result[key] = sensitive
-            ? REDACTED_METADATA_VALUE
-            : redactCauseValue(value, pattern, seen);
-    }
-    return result;
-}
-function redactCauseValue(value, pattern, seen) {
-    if (Array.isArray(value)) {
-        if (seen.has(value))
-            return "[Circular]";
-        seen.add(value);
-        try {
-            return value.map((entry) => redactCauseValue(entry, pattern, seen));
-        }
-        finally {
-            seen.delete(value);
-        }
-    }
-    if (!isPlainRecord(value))
-        return value;
-    if (seen.has(value))
-        return "[Circular]";
-    seen.add(value);
-    try {
-        return redactCauseFields(value, pattern, seen);
-    }
-    finally {
-        seen.delete(value);
-    }
-}
-/** Structural check for a serialized BaseError (used on nested causes). */
-function isSerializedBaseError(value) {
-    return (typeof value.code === "string" &&
-        typeof value.category === "string" &&
-        typeof value.severity === "string" &&
-        typeof value.statusCode === "number" &&
-        typeof value.metadata === "object" &&
-        value.metadata !== null);
-}
 //# sourceMappingURL=errorSerializer.core.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/errors",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Shared error base class, error codes, and error handling utilities for the Zudojs framework.",
   "type": "module",
   "main": "./dist/index.js",