@loggerjs/processors 0.5.1 → 0.5.3

package/dist/index.js

@@ -1,24 +1,58 @@
 import { createBoundContext, createMiddleware, eventToRecord, incrementLoggerMetaCounter, recordToEvent, toLevelName, toLevelValue, withLogEventRoute } from "@loggerjs/core";
+//#region src/error-fields.ts
+const NATIVE_ERROR_FIELDS = ["cause", "errors"];
+function hiddenErrorFields(value) {
+	const fields = [];
+	for (const field of NATIVE_ERROR_FIELDS) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, field);
+		if (descriptor && !descriptor.enumerable) fields.push(field);
+	}
+	return fields;
+}
+function defineHidden(target, field, value) {
+	Object.defineProperty(target, field, {
+		value,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+}
+function dotPath(path, field) {
+	return path ? `${path}.${field}` : field;
+}
+//#endregion
 //#region src/redact.ts
+function keyName$1(key) {
+	if (typeof key === "symbol") return key.description ?? key.toString();
+	return String(key);
+}
+function ownEnumerableEntries$1(value) {
+	return Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key)).map((key) => [key, value[key]]);
+}
 function matchesKey(key, path, value, matchers) {
+	const name = keyName$1(key);
 	return matchers.some((matcher) => {
-		if (typeof matcher === "string") return matcher.toLowerCase() === key.toLowerCase();
+		if (typeof matcher === "symbol") return matcher === key;
+		if (typeof matcher === "string") return matcher.toLowerCase() === name.toLowerCase();
 		if (matcher instanceof RegExp) {
 			matcher.lastIndex = 0;
-			const keyMatches = matcher.test(key);
+			const keyMatches = matcher.test(name);
 			matcher.lastIndex = 0;
 			return keyMatches || matcher.test(path);
 		}
-		return matcher(key, path, value);
+		return matcher(name, path, value);
 	});
 }
 function pathMatches(path, paths) {
 	return paths.includes(path);
 }
+function shouldRedact(key, path, value, options) {
+	return matchesKey(key, path, value, options.keys ?? []) || pathMatches(path, options.paths ?? []);
+}
 function redactValue(value, options, path = "", depth = 0, seen = /* @__PURE__ */ new WeakMap()) {
 	if (value === null || value === void 0) return value;
 	if (typeof value !== "object") return value;
-	if (depth >= options.maxDepth) return value;
+	if (depth >= options.maxDepth) return options.replacement;
 	if (seen.has(value)) return seen.get(value);
 	if (Array.isArray(value)) {
 		const out = [];
@@ -26,14 +60,67 @@ function redactValue(value, options, path = "", depth = 0, seen = /* @__PURE__ *
 		for (let index = 0; index < value.length; index += 1) out[index] = redactValue(value[index], options, `${path}[${index}]`, depth + 1, seen);
 		return out;
 	}
-	if (value instanceof Error) return value;
 	if (value instanceof Date) return value;
-	const input = value;
+	if (value instanceof Error) {
+		const entries = ownEnumerableEntries$1(value);
+		const hiddenFields = hiddenErrorFields(value);
+		if (entries.length === 0 && hiddenFields.length === 0) return value;
+		const errorOut = Object.create(Object.getPrototypeOf(value));
+		seen.set(value, errorOut);
+		defineHidden(errorOut, "message", value.message);
+		defineHidden(errorOut, "stack", value.stack);
+		for (const field of hiddenFields) {
+			const child = value[field];
+			const childPath = dotPath(path, field);
+			if (shouldRedact(field, childPath, child, options)) {
+				if (options.remove) continue;
+				defineHidden(errorOut, field, options.replacement);
+				continue;
+			}
+			defineHidden(errorOut, field, redactValue(child, options, childPath, depth + 1, seen));
+		}
+		for (const [key, child] of entries) {
+			const childPath = dotPath(path, keyName$1(key));
+			if (shouldRedact(key, childPath, child, options)) {
+				if (options.remove) continue;
+				errorOut[key] = options.replacement;
+			} else errorOut[key] = redactValue(child, options, childPath, depth + 1, seen);
+		}
+		return errorOut;
+	}
+	if (value instanceof Map) {
+		const mapOut = /* @__PURE__ */ new Map();
+		seen.set(value, mapOut);
+		for (const [key, child] of value) {
+			if (typeof key === "string" || typeof key === "symbol") {
+				const childPath = dotPath(path, keyName$1(key));
+				if (shouldRedact(key, childPath, child, options)) {
+					if (options.remove) continue;
+					mapOut.set(key, options.replacement);
+					continue;
+				}
+				mapOut.set(key, redactValue(child, options, childPath, depth + 1, seen));
+				continue;
+			}
+			mapOut.set(key, redactValue(child, options, path, depth + 1, seen));
+		}
+		return mapOut;
+	}
+	if (value instanceof Set) {
+		const setOut = /* @__PURE__ */ new Set();
+		seen.set(value, setOut);
+		let index = 0;
+		for (const child of value) {
+			setOut.add(redactValue(child, options, `${path}[${index}]`, depth + 1, seen));
+			index += 1;
+		}
+		return setOut;
+	}
 	const out = {};
 	seen.set(value, out);
-	for (const [key, child] of Object.entries(input)) {
-		const childPath = path ? `${path}.${key}` : key;
-		if (matchesKey(key, childPath, child, options.keys ?? []) || pathMatches(childPath, options.paths ?? [])) {
+	for (const [key, child] of ownEnumerableEntries$1(value)) {
+		const childPath = dotPath(path, keyName$1(key));
+		if (shouldRedact(key, childPath, child, options)) {
 			if (options.remove) continue;
 			out[key] = options.replacement;
 		} else out[key] = redactValue(child, options, childPath, depth + 1, seen);
@@ -1023,6 +1110,13 @@ function isAsciiAlphaNumeric(code) {
 function hasChar(code, chars) {
 	return chars.includes(String.fromCharCode(code));
 }
+function keyName(key) {
+	if (typeof key === "symbol") return key.description ?? key.toString();
+	return String(key);
+}
+function ownEnumerableEntries(value) {
+	return Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key)).map((key) => [key, value[key]]);
+}
 function isEmailLocalChar(code) {
 	return isAsciiAlphaNumeric(code) || hasChar(code, "._%+-");
 }
@@ -1088,12 +1182,14 @@ function redactEmailAddresses(input, path, options) {
 	};
 }
 function matcherMatches(matcher, key, path, value) {
-	if (typeof matcher === "string") return matcher.toLowerCase() === key.toLowerCase();
+	const name = keyName(key);
+	if (typeof matcher === "symbol") return matcher === key;
+	if (typeof matcher === "string") return matcher.toLowerCase() === name.toLowerCase();
 	if (matcher instanceof RegExp) {
 		matcher.lastIndex = 0;
-		return matcher.test(key) || matcher.test(path);
+		return matcher.test(name) || matcher.test(path);
 	}
-	return matcher(key, path, value);
+	return matcher(name, path, value);
 }
 function matchesAny(matchers, key, path, value) {
 	return matchers.some((matcher) => matcherMatches(matcher, key, path, value));
@@ -1134,6 +1230,12 @@ function guardString(input, path, options) {
 		changed: changed || value !== input
 	};
 }
+function guardErrorString(input, path, options) {
+	return typeof input === "string" ? guardString(input, path, options) : {
+		value: input,
+		changed: false
+	};
+}
 function guardValue(value, path, key, depth, options, seen) {
 	if (matchesAny(options.denyKeys, key, path, value) && !matchesAny(options.allowKeys, key, path, value)) return {
 		value: redact(path, "deny-key", options),
@@ -1152,10 +1254,72 @@ function guardValue(value, path, key, depth, options, seen) {
 		value: seen.get(value),
 		changed: true
 	};
-	if (value instanceof Date || value instanceof Error) return {
+	if (value instanceof Date) return {
 		value,
 		changed: false
 	};
+	if (value instanceof Error) {
+		const message = guardErrorString(value.message, dotPath(path, "message"), options);
+		const stack = guardErrorString(value.stack, dotPath(path, "stack"), options);
+		const fieldChanged = message.changed || stack.changed;
+		const entries = ownEnumerableEntries(value);
+		const hiddenFields = hiddenErrorFields(value);
+		if (entries.length === 0 && hiddenFields.length === 0 && !fieldChanged) return {
+			value,
+			changed: false
+		};
+		const errorOut = Object.create(Object.getPrototypeOf(value));
+		seen.set(value, errorOut);
+		defineHidden(errorOut, "message", message.value);
+		defineHidden(errorOut, "stack", stack.value);
+		let changed = fieldChanged;
+		for (const field of hiddenFields) {
+			const childPath = dotPath(path, field);
+			const child = guardValue(value[field], childPath, field, depth + 1, options, seen);
+			defineHidden(errorOut, field, child.value);
+			changed ||= child.changed;
+		}
+		for (const [childKey, childValue] of entries) {
+			const child = guardValue(childValue, dotPath(path, keyName(childKey)), childKey, depth + 1, options, seen);
+			errorOut[childKey] = child.value;
+			changed ||= child.changed;
+		}
+		return {
+			value: changed ? errorOut : value,
+			changed
+		};
+	}
+	if (value instanceof Map) {
+		const mapOut = /* @__PURE__ */ new Map();
+		seen.set(value, mapOut);
+		let changed = false;
+		for (const [mapKey, mapValue] of value) {
+			const isNamedKey = typeof mapKey === "string" || typeof mapKey === "symbol";
+			const child = guardValue(mapValue, isNamedKey ? dotPath(path, keyName(mapKey)) : path, isNamedKey ? mapKey : key, depth + 1, options, seen);
+			mapOut.set(mapKey, child.value);
+			changed ||= child.changed;
+		}
+		return {
+			value: changed ? mapOut : value,
+			changed
+		};
+	}
+	if (value instanceof Set) {
+		const setOut = /* @__PURE__ */ new Set();
+		seen.set(value, setOut);
+		let changed = false;
+		let index = 0;
+		for (const item of value) {
+			const child = guardValue(item, `${path}[${index}]`, String(index), depth + 1, options, seen);
+			setOut.add(child.value);
+			changed ||= child.changed;
+			index += 1;
+		}
+		return {
+			value: changed ? setOut : value,
+			changed
+		};
+	}
 	if (Array.isArray(value)) {
 		const out = [];
 		seen.set(value, out);
@@ -1170,12 +1334,11 @@ function guardValue(value, path, key, depth, options, seen) {
 			changed
 		};
 	}
-	const input = value;
 	const out = {};
 	seen.set(value, out);
 	let changed = false;
-	for (const [childKey, childValue] of Object.entries(input)) {
-		const child = guardValue(childValue, path ? `${path}.${childKey}` : childKey, childKey, depth + 1, options, seen);
+	for (const [childKey, childValue] of ownEnumerableEntries(value)) {
+		const child = guardValue(childValue, dotPath(path, keyName(childKey)), childKey, depth + 1, options, seen);
 		out[childKey] = child.value;
 		changed ||= child.changed;
 	}