@maestro-js/log 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/index.d.ts

@@ -24,6 +24,11 @@ interface LogFunctions<LogMessageData extends any[] = any[]> {
     error(...data: LogMessageData): void;
     emergency(...data: LogMessageData): void;
 }
+interface WithRedactionsOptions {
+    redact?: (string | RegExp)[];
+    replacement?: string;
+    redactor?: (key: string, value: unknown) => unknown;
+}
 
 declare function ConsoleTransport<LogMessageData extends any[] = any[]>(options?: {
     filter?: LogMessageFilter<LogMessageData>;
@@ -80,6 +85,8 @@ declare function StubTransport<LogMessageData extends any[] = any[]>(options?: {
     listMessages(): LogMessage<LogMessageData>[];
 };
 
+declare function withRedactions<T extends LogTransport<D>, D extends any[] = any[]>(transport: T, options: WithRedactionsOptions): T;
+
 /**
  * Creates a new logger. By default loggers have no transports
  */
@@ -192,6 +199,8 @@ declare namespace Log {
     type MessageFilter<LogMessageData extends any[] = any[]> = LogMessageFilter<LogMessageData>;
     /** Destination that receives {@link Log.Message messages} from a logger. */
     type Transport<LogMessageData extends any[] = any[]> = LogTransport<LogMessageData>;
+    /** Options for {@link Log.withRedactions}. */
+    type WithRedactionsOptions = WithRedactionsOptions;
 }
 /**
  * Structured logging with pluggable transports.
@@ -208,6 +217,8 @@ declare const Log: {
     addTransport: (...transport: Log.Transport<any>[]) => void;
     removeTransport: (...transport: Log.Transport<any>[]) => void;
     channel: <ChannelMessageData extends any = any>(channel: LogChannel) => Log.LogFunctions<ChannelMessageData>;
+    withRedactions: typeof withRedactions;
+    commonSensitiveKeys: readonly ["password", "secret", "token", "accessToken", "refreshToken", "apiKey", "apiSecret", "authorization", "cookie", "creditCard", "ssn", "socialSecurityNumber"];
     transports: {
         console: typeof ConsoleTransport;
         file: typeof FileTransport;

package/dist/index.js

@@ -188,6 +188,118 @@ function StubTransport(options) {
   };
 }
 
+// src/with-redactions.ts
+var commonSensitiveKeys = [
+  "password",
+  "secret",
+  "token",
+  "accessToken",
+  "refreshToken",
+  "apiKey",
+  "apiSecret",
+  "authorization",
+  "cookie",
+  "creditCard",
+  "ssn",
+  "socialSecurityNumber"
+];
+function withRedactions(transport, options) {
+  const { replacement = "[REDACTED]", redact = [], redactor } = options;
+  const stringMatchers = /* @__PURE__ */ new Set();
+  const regexMatchers = [];
+  for (const matcher of redact) {
+    if (typeof matcher === "string") {
+      stringMatchers.add(matcher.toLowerCase());
+    } else {
+      regexMatchers.push(matcher);
+    }
+  }
+  function keyMatches(key) {
+    if (stringMatchers.has(key.toLowerCase())) return true;
+    for (const re of regexMatchers) {
+      if (re.test(key)) return true;
+    }
+    return false;
+  }
+  function redactMessage(message) {
+    if (stringMatchers.size === 0 && regexMatchers.length === 0 && !redactor) return message;
+    const seen = /* @__PURE__ */ new WeakSet();
+    const newData = redactData(message.data, seen);
+    return newData === message.data ? message : { ...message, data: newData };
+  }
+  function redactData(data, seen) {
+    let changed = false;
+    const result = data.map((item) => {
+      const redacted = redactValue(item, seen);
+      if (redacted !== item) changed = true;
+      return redacted;
+    });
+    return changed ? result : data;
+  }
+  function redactValue(value, seen) {
+    if (value === null || value === void 0 || typeof value !== "object") return value;
+    const obj = value;
+    if (seen.has(obj)) return "[CIRCULAR]";
+    if (obj instanceof Date || obj instanceof RegExp || obj instanceof Map || obj instanceof Set || Buffer.isBuffer(obj)) {
+      return obj;
+    }
+    seen.add(obj);
+    if (Array.isArray(obj)) return redactArray(obj, seen);
+    if (obj instanceof Error) return redactError(obj, seen);
+    const proto = Object.getPrototypeOf(obj);
+    if (proto === Object.prototype || proto === null) return redactPlainObject(obj, seen);
+    return obj;
+  }
+  function redactArray(arr, seen) {
+    let changed = false;
+    const result = arr.map((item) => {
+      const redacted = redactValue(item, seen);
+      if (redacted !== item) changed = true;
+      return redacted;
+    });
+    return changed ? result : arr;
+  }
+  function redactError(err, seen) {
+    const plain = {
+      name: err.name,
+      message: err.message,
+      stack: err.stack
+    };
+    if (err.cause !== void 0) {
+      plain.cause = redactValue(err.cause, seen);
+    }
+    for (const key of Object.keys(err)) {
+      plain[key] = redactKeyValue(key, err[key], seen);
+    }
+    return plain;
+  }
+  function redactPlainObject(obj, seen) {
+    let changed = false;
+    const result = {};
+    for (const key of Object.keys(obj)) {
+      const original = obj[key];
+      const redacted = redactKeyValue(key, original, seen);
+      if (redacted !== original) changed = true;
+      result[key] = redacted;
+    }
+    return changed ? result : obj;
+  }
+  function redactKeyValue(key, value, seen) {
+    if (redactor) {
+      const custom = redactor(key, value);
+      if (custom !== value) return custom;
+    }
+    if (keyMatches(key)) return replacement;
+    return redactValue(value, seen);
+  }
+  return {
+    ...transport,
+    write(message) {
+      transport.write(redactMessage(message));
+    }
+  };
+}
+
 // src/index.ts
 var defaultConsoleTransport = ConsoleTransport();
 function create(config) {
@@ -320,6 +432,8 @@ var Log = {
   addTransport: defaultLogger.addTransport,
   removeTransport: defaultLogger.removeTransport,
   channel: defaultLogger.channel,
+  withRedactions,
+  commonSensitiveKeys,
   transports: {
     console: ConsoleTransport,
     file: FileTransport,

package/package.json

@@ -16,7 +16,7 @@
     "@sentry/types": "^8.30.0",
     "@types/node": "^22.19.11"
   },
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.11",
   "publishConfig": {
     "access": "restricted"
   },