@zudojs/errors 1.0.0 → 1.0.1

package/dist/base/core/errorMetadata.core.js

@@ -19,9 +19,21 @@ export const REDACTED_METADATA_VALUE = "[REDACTED]";
 export function isForbiddenMetadataKey(key) {
     return FORBIDDEN_METADATA_KEYS.has(key);
 }
+/**
+ * Returns a copy of `pattern` without the `g` and `y` flags.
+ *
+ * Those flags make `RegExp.prototype.test` advance `lastIndex`, so a shared
+ * sensitive-key pattern would redact a key on one call and let the same key
+ * through on the next. Every key check in this module goes through here.
+ */
+function statelessPattern(pattern) {
+    if (!pattern.global && !pattern.sticky)
+        return pattern;
+    return new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ""));
+}
 /** Returns whether a metadata key looks like it carries a secret. */
 export function isSensitiveMetadataKey(key, pattern = SENSITIVE_METADATA_KEY_PATTERN) {
-    return pattern.test(key);
+    return statelessPattern(pattern).test(key);
 }
 /** Returns whether a value is a plain object (Object.prototype or null prototype). */
 function isPlainObject(value) {
@@ -286,7 +298,7 @@ function sanitizeValue(value, seen, depth) {
 export function redactErrorMetadata(metadata, options = {}) {
     if (metadata === undefined || metadata === null)
         return Object.freeze({});
-    const pattern = options.sensitiveKeyPattern ?? SENSITIVE_METADATA_KEY_PATTERN;
+    const pattern = statelessPattern(options.sensitiveKeyPattern ?? SENSITIVE_METADATA_KEY_PATTERN);
     const extraKeys = new Set((options.keys ?? []).map((key) => key.toLowerCase()));
     const replacement = options.replacement ?? REDACTED_METADATA_VALUE;
     const isSensitive = (key) => pattern.test(key) || extraKeys.has(key.toLowerCase());

package/dist/utils/errorSerializer.core.js

@@ -2,7 +2,7 @@
  * Converts errors into safe, predictable serialized structures.
  */
 import { BaseError } from "../base/core/baseError.core.js";
-import { pickErrorMetadata, redactErrorMetadata, } from "../base/core/errorMetadata.core.js";
+import { isSensitiveMetadataKey, pickErrorMetadata, redactErrorMetadata, REDACTED_METADATA_VALUE, } from "../base/core/errorMetadata.core.js";
 import { normalizeUnknownError } from "./errorSerializer.factory.js";
 export { createErrorSerializer, serializeError, serializePublicError, normalizeUnknownError, } from "./errorSerializer.factory.js";
 /** Converts errors into safe, predictable serialized structures. */
@@ -84,10 +84,16 @@ export class ErrorSerializer {
         if (isSerializedBaseError(record)) {
             return this.serializeLevel(record);
         }
-        // Native error shape: { name, message, stack?, cause? }
+        // 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]))
+            : rest;
         return {
-            ...rest,
+            ...fields,
             ...(this.includeStack && stack !== undefined ? { stack } : {}),
             ...(nested !== undefined ? { cause: this.serializeCause(nested) } : {}),
         };
@@ -118,6 +124,57 @@ 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" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/errors",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Shared error base class, error codes, and error handling utilities for the Zudojs framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,6 +28,10 @@
     "node": ">=24.0.0"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },