@vitkuz/aws-logger 1.2.0

package/.env.example

@@ -0,0 +1,3 @@
+AWS_REGION=your_aws_region_here
+AWS_ACCESS_KEY_ID=your_aws_access_key_id_here
+AWS_SECRET_ACCESS_KEY=your_aws_secret_access_key_here

package/.prettierignore

@@ -0,0 +1,4 @@
+dist
+node_modules
+package-lock.json
+*.json

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+    "semi": true,
+    "singleQuote": true,
+    "tabWidth": 4,
+    "trailingComma": "all",
+    "printWidth": 100,
+    "arrowParens": "always"
+}

package/dist/index.d.mts

@@ -0,0 +1,89 @@
+interface Logger {
+    debug(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    error(message: string, error?: Error | string, context?: Record<string, any>): void;
+    /**
+     * Creates a child logger with bound context.
+     * Any logs emitted by the child will include the parent's context plus the new context.
+     */
+    child(context: Record<string, any>): Logger;
+}
+
+type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);
+interface RedactionConfig {
+    /**
+     * Array of keys to redact.
+     * Case-insensitive matching is recommended/implemented.
+     */
+    keys: string[];
+    /**
+     * Map of specific key to strategy.
+     * If a key is in 'keys' but not here, it uses the default strategy ('mask').
+     */
+    strategies?: Record<string, RedactionStrategy>;
+    /**
+     * Default strategy for keys found in the list but not in the strategy map.
+     * Default: 'mask'
+     */
+    defaultStrategy?: RedactionStrategy;
+}
+declare const COMMON_REDACTION_KEYS: string[];
+/**
+ * Recursively walks the object and redacts fields matching the config.
+ */
+declare const recursiveRedact: (target: any, config: RedactionConfig, cache?: Set<any>) => any;
+declare const createRedactor: (config: RedactionConfig) => (info: any) => any;
+
+/**
+ * Runs a callback within a logger context.
+ * The logger provided becomes the "current" logger for the duration of the callback.
+ */
+declare const runWithLogger: <T>(logger: Logger, callback: () => T) => T;
+/**
+ * Gets the current logger from the async context.
+ * Throws an error if called outside of a runWithLogger context,
+ * unless a fallback is provided (though usually we want to enforce context).
+ *
+ * To make it easier to use, we can return undefined or a default logger if needed,
+ * but for this specific feature request "access by all down the stream", strictness is good.
+ */
+declare const getLogger: () => Logger | undefined;
+/**
+ * Updates the current context's logger.
+ * This effectively "extends" the logger for the remainder of the current async execution
+ * and any further downstream calls sharing this context.
+ */
+declare const updateLoggerContext: (newLogger: Logger) => void;
+
+interface CreateLoggerOptions {
+    /**
+     * Default context to include in all logs
+     */
+    defaultContext?: Record<string, any>;
+    /**
+     * Log level (default: process.env.LOG_LEVEL || 'info')
+     */
+    level?: string;
+    /**
+     * Configuration for data redaction
+     */
+    redaction?: RedactionConfig;
+}
+declare const createLogger: (options?: CreateLoggerOptions) => Logger;
+
+type Handler<TEvent = any, TResult = any> = (event: TEvent, context: any, callback?: any) => Promise<TResult> | void;
+/**
+ * Higher-order function to wrap a Lambda handler with logger context.
+ * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context
+ * and initializes a logger for the request scope.
+ *
+ * @param handler The original Lambda handler
+ * @param options Logger options (level, redaction, etc.)
+ */
+declare const withLogger: <TEvent = any, TResult = any>(handler: Handler<TEvent, TResult>, options?: CreateLoggerOptions) => Handler<TEvent, TResult>;
+
+declare const DEFAULT_LOG_LEVEL = "info";
+declare const REQUEST_ID_KEY = "x-request-id";
+
+export { COMMON_REDACTION_KEYS, type CreateLoggerOptions, DEFAULT_LOG_LEVEL, type Logger, REQUEST_ID_KEY, type RedactionConfig, type RedactionStrategy, createLogger, createRedactor, getLogger, recursiveRedact, runWithLogger, updateLoggerContext, withLogger };

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+interface Logger {
+    debug(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    error(message: string, error?: Error | string, context?: Record<string, any>): void;
+    /**
+     * Creates a child logger with bound context.
+     * Any logs emitted by the child will include the parent's context plus the new context.
+     */
+    child(context: Record<string, any>): Logger;
+}
+
+type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);
+interface RedactionConfig {
+    /**
+     * Array of keys to redact.
+     * Case-insensitive matching is recommended/implemented.
+     */
+    keys: string[];
+    /**
+     * Map of specific key to strategy.
+     * If a key is in 'keys' but not here, it uses the default strategy ('mask').
+     */
+    strategies?: Record<string, RedactionStrategy>;
+    /**
+     * Default strategy for keys found in the list but not in the strategy map.
+     * Default: 'mask'
+     */
+    defaultStrategy?: RedactionStrategy;
+}
+declare const COMMON_REDACTION_KEYS: string[];
+/**
+ * Recursively walks the object and redacts fields matching the config.
+ */
+declare const recursiveRedact: (target: any, config: RedactionConfig, cache?: Set<any>) => any;
+declare const createRedactor: (config: RedactionConfig) => (info: any) => any;
+
+/**
+ * Runs a callback within a logger context.
+ * The logger provided becomes the "current" logger for the duration of the callback.
+ */
+declare const runWithLogger: <T>(logger: Logger, callback: () => T) => T;
+/**
+ * Gets the current logger from the async context.
+ * Throws an error if called outside of a runWithLogger context,
+ * unless a fallback is provided (though usually we want to enforce context).
+ *
+ * To make it easier to use, we can return undefined or a default logger if needed,
+ * but for this specific feature request "access by all down the stream", strictness is good.
+ */
+declare const getLogger: () => Logger | undefined;
+/**
+ * Updates the current context's logger.
+ * This effectively "extends" the logger for the remainder of the current async execution
+ * and any further downstream calls sharing this context.
+ */
+declare const updateLoggerContext: (newLogger: Logger) => void;
+
+interface CreateLoggerOptions {
+    /**
+     * Default context to include in all logs
+     */
+    defaultContext?: Record<string, any>;
+    /**
+     * Log level (default: process.env.LOG_LEVEL || 'info')
+     */
+    level?: string;
+    /**
+     * Configuration for data redaction
+     */
+    redaction?: RedactionConfig;
+}
+declare const createLogger: (options?: CreateLoggerOptions) => Logger;
+
+type Handler<TEvent = any, TResult = any> = (event: TEvent, context: any, callback?: any) => Promise<TResult> | void;
+/**
+ * Higher-order function to wrap a Lambda handler with logger context.
+ * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context
+ * and initializes a logger for the request scope.
+ *
+ * @param handler The original Lambda handler
+ * @param options Logger options (level, redaction, etc.)
+ */
+declare const withLogger: <TEvent = any, TResult = any>(handler: Handler<TEvent, TResult>, options?: CreateLoggerOptions) => Handler<TEvent, TResult>;
+
+declare const DEFAULT_LOG_LEVEL = "info";
+declare const REQUEST_ID_KEY = "x-request-id";
+
+export { COMMON_REDACTION_KEYS, type CreateLoggerOptions, DEFAULT_LOG_LEVEL, type Logger, REQUEST_ID_KEY, type RedactionConfig, type RedactionStrategy, createLogger, createRedactor, getLogger, recursiveRedact, runWithLogger, updateLoggerContext, withLogger };

package/dist/index.js

@@ -0,0 +1,262 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  COMMON_REDACTION_KEYS: () => COMMON_REDACTION_KEYS,
+  DEFAULT_LOG_LEVEL: () => DEFAULT_LOG_LEVEL,
+  REQUEST_ID_KEY: () => REQUEST_ID_KEY,
+  createLogger: () => createLogger,
+  createRedactor: () => createRedactor,
+  getLogger: () => getLogger,
+  recursiveRedact: () => recursiveRedact,
+  runWithLogger: () => runWithLogger,
+  updateLoggerContext: () => updateLoggerContext,
+  withLogger: () => withLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/redactor.ts
+var import_crypto = __toESM(require("crypto"));
+var COMMON_REDACTION_KEYS = [
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "access_token",
+  "access-token",
+  "auth",
+  "auth-token",
+  "authorization",
+  "apikey",
+  "api_key",
+  "api-key",
+  "card",
+  "cvv",
+  "ssn",
+  "pin"
+];
+var applyStrategy = (value, strategy) => {
+  if (typeof strategy === "function") {
+    return strategy(value);
+  }
+  if (typeof strategy === "string" && strategy.startsWith("mask-last-")) {
+    const parts = strategy.split("-");
+    const lastN = parseInt(parts[2], 10);
+    if (typeof value === "string" && !isNaN(lastN)) {
+      if (value.length <= lastN) {
+        return value;
+        return value;
+      }
+      const maskLen = value.length - lastN;
+      return "*".repeat(maskLen) + value.slice(-lastN);
+    }
+    return "*****";
+  }
+  switch (strategy) {
+    case "remove":
+      return void 0;
+    case "hash":
+      if (typeof value === "string" || typeof value === "number") {
+        return import_crypto.default.createHash("sha256").update(String(value)).digest("hex");
+      }
+      return "[HASH_FAILED_TYPE]";
+    case "mask":
+    default:
+      return "*****";
+  }
+};
+var recursiveRedact = (target, config, cache = /* @__PURE__ */ new Set()) => {
+  if (target === null || typeof target !== "object") {
+    return target;
+  }
+  if (cache.has(target)) {
+    return "[Circular]";
+  }
+  cache.add(target);
+  if (Array.isArray(target)) {
+    return target.map((item) => recursiveRedact(item, config, cache));
+  }
+  const redactedObj = {};
+  const keysToRedact = new Set(config.keys.map((k) => k.toLowerCase()));
+  for (const [key, value] of Object.entries(target)) {
+    const lowerKey = key.toLowerCase();
+    if (keysToRedact.has(lowerKey)) {
+      let strategy = config.defaultStrategy || "mask";
+      if (config.strategies && config.strategies[key]) {
+        strategy = config.strategies[key];
+      } else if (config.strategies) {
+        const strategyKey = Object.keys(config.strategies).find(
+          (k) => k.toLowerCase() === lowerKey
+        );
+        if (strategyKey) {
+          strategy = config.strategies[strategyKey];
+        }
+      }
+      const result = applyStrategy(value, strategy);
+      if (result !== void 0) {
+        redactedObj[key] = result;
+      }
+    } else {
+      redactedObj[key] = recursiveRedact(value, config, cache);
+    }
+  }
+  return redactedObj;
+};
+var createRedactor = (config) => {
+  return (info) => {
+    return recursiveRedact(info, config);
+  };
+};
+
+// src/context.ts
+var import_async_hooks = require("async_hooks");
+var asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
+var runWithLogger = (logger, callback) => {
+  return asyncLocalStorage.run({ logger }, callback);
+};
+var getLogger = () => {
+  const store = asyncLocalStorage.getStore();
+  return store?.logger;
+};
+var updateLoggerContext = (newLogger) => {
+  const store = asyncLocalStorage.getStore();
+  if (store) {
+    store.logger = newLogger;
+  } else {
+    console.warn(
+      "AntigravityLogger: updateLoggerContext called outside of an active context. Logic ignored."
+    );
+  }
+};
+
+// src/logger.ts
+var import_winston = __toESM(require("winston"));
+
+// src/constants.ts
+var DEFAULT_LOG_LEVEL = "info";
+var REQUEST_ID_KEY = "x-request-id";
+
+// src/logger.ts
+var formatContext = (context) => {
+  return context || {};
+};
+var createLoggerWrapper = (winstonLogger) => {
+  return {
+    debug: (message, context) => {
+      winstonLogger.debug(message, formatContext(context));
+    },
+    info: (message, context) => {
+      winstonLogger.info(message, formatContext(context));
+    },
+    warn: (message, context) => {
+      winstonLogger.warn(message, formatContext(context));
+    },
+    error: (message, error, context) => {
+      const meta = formatContext(context);
+      if (error instanceof Error) {
+        const { message: message2, name, stack, ...rest } = error;
+        meta.error = {
+          ...rest,
+          message: message2,
+          name,
+          stack
+        };
+      } else if (error) {
+        meta.error = error;
+      }
+      winstonLogger.error(message, meta);
+    },
+    child: (context) => {
+      return createLoggerWrapper(winstonLogger.child(context));
+    }
+  };
+};
+var createLogger = (options = {}) => {
+  const level = options.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;
+  const redactor = options.redaction ? createRedactor(options.redaction) : null;
+  const redactionFormat = import_winston.default.format((info) => {
+    if (redactor) {
+      return redactor(info);
+    }
+    return info;
+  });
+  const format = import_winston.default.format.combine(
+    import_winston.default.format.timestamp(),
+    redactionFormat(),
+    // Apply redaction before JSON
+    import_winston.default.format.json()
+  );
+  const winstonLogger = import_winston.default.createLogger({
+    level,
+    format,
+    defaultMeta: options.defaultContext,
+    transports: [new import_winston.default.transports.Console()]
+  });
+  return createLoggerWrapper(winstonLogger);
+};
+
+// src/wrapper.ts
+var withLogger = (handler, options = {}) => {
+  return async (event, context, callback) => {
+    const rootLogger = createLogger(options);
+    const requestContext = {};
+    if (context) {
+      if (context.awsRequestId) requestContext.requestId = context.awsRequestId;
+      if (context.functionName) requestContext.functionName = context.functionName;
+    }
+    const scopedLogger = rootLogger.child(requestContext);
+    scopedLogger.debug("Lambda Event", { event });
+    scopedLogger.debug("Lambda Context", { context });
+    return runWithLogger(scopedLogger, async () => {
+      try {
+        const result = await handler(event, context, callback);
+        return result;
+      } catch (error) {
+        scopedLogger.error("Unhandled Lambda Exception", error);
+        throw error;
+      }
+    });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMMON_REDACTION_KEYS,
+  DEFAULT_LOG_LEVEL,
+  REQUEST_ID_KEY,
+  createLogger,
+  createRedactor,
+  getLogger,
+  recursiveRedact,
+  runWithLogger,
+  updateLoggerContext,
+  withLogger
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/redactor.ts","../src/context.ts","../src/logger.ts","../src/constants.ts","../src/wrapper.ts"],"sourcesContent":["export * from './types';\nexport * from './redactor';\nexport * from './context';\nexport * from './logger';\nexport * from './wrapper';\nexport * from './constants';\n","import crypto from 'crypto';\n\nexport type RedactionStrategy = 'mask' | 'remove' | 'hash' | string | ((value: any) => any);\n\nexport interface RedactionConfig {\n    /**\n     * Array of keys to redact.\n     * Case-insensitive matching is recommended/implemented.\n     */\n    keys: string[];\n    /**\n     * Map of specific key to strategy.\n     * If a key is in 'keys' but not here, it uses the default strategy ('mask').\n     */\n    strategies?: Record<string, RedactionStrategy>;\n    /**\n     * Default strategy for keys found in the list but not in the strategy map.\n     * Default: 'mask'\n     */\n    defaultStrategy?: RedactionStrategy;\n}\n\nexport const COMMON_REDACTION_KEYS = [\n    'password',\n    'passwd',\n    'secret',\n    'token',\n    'access_token',\n    'access-token',\n    'auth',\n    'auth-token',\n    'authorization',\n    'apikey',\n    'api_key',\n    'api-key',\n    'card',\n    'cvv',\n    'ssn',\n    'pin',\n];\n\n/**\n * Applies the redaction strategy to a single value.\n */\nconst applyStrategy = (value: any, strategy: RedactionStrategy): any => {\n    if (typeof strategy === 'function') {\n        return strategy(value);\n    }\n\n    if (typeof strategy === 'string' && strategy.startsWith('mask-last-')) {\n        const parts = strategy.split('-');\n        const lastN = parseInt(parts[2], 10);\n\n        if (typeof value === 'string' && !isNaN(lastN)) {\n            if (value.length <= lastN) {\n                return value; // Or mask entirely? Usually if shorter, we show it or mask all. Let's return as is or mask all?\n                // Security wise: showing short secrets fully is bad. Masking all is safer.\n                // BUT, if user asked for last 4 and length is 3, showing 3 is effectively \"last 4\".\n                // Let's mask all if length <= lastN to be safe? Or just return.\n                // Actually, standard is usually: if len <= N, show all (it IS the last N).\n                // But for API keys, usually we want to see SOMETHING masked.\n                // Let's preserve standard behavior: visible suffix.\n                return value;\n            }\n            const maskLen = value.length - lastN;\n            return '*'.repeat(maskLen) + value.slice(-lastN);\n        }\n        return '*****'; // Fallback for non-strings\n    }\n\n    switch (strategy) {\n        case 'remove':\n            return undefined;\n        case 'hash':\n            if (typeof value === 'string' || typeof value === 'number') {\n                return crypto.createHash('sha256').update(String(value)).digest('hex');\n            }\n            return '[HASH_FAILED_TYPE]';\n        case 'mask':\n        default:\n            return '*****';\n    }\n};\n\n/**\n * Recursively walks the object and redacts fields matching the config.\n */\nexport const recursiveRedact = (\n    target: any,\n    config: RedactionConfig,\n    cache = new Set<any>(),\n): any => {\n    if (target === null || typeof target !== 'object') {\n        return target;\n    }\n\n    // Handle circular references\n    if (cache.has(target)) {\n        return '[Circular]';\n    }\n    cache.add(target);\n\n    // Handle Arrays\n    if (Array.isArray(target)) {\n        return target.map((item) => recursiveRedact(item, config, cache));\n    }\n\n    // Handle Objects\n    const redactedObj: Record<string, any> = {};\n    const keysToRedact = new Set(config.keys.map((k) => k.toLowerCase()));\n\n    for (const [key, value] of Object.entries(target)) {\n        const lowerKey = key.toLowerCase();\n\n        if (keysToRedact.has(lowerKey)) {\n            // Determine strategy\n            let strategy = config.defaultStrategy || 'mask';\n            if (config.strategies && config.strategies[key]) {\n                // Try exact match first\n                strategy = config.strategies[key];\n            } else if (config.strategies) {\n                // Try case-insensitive lookup in strategies if needed,\n                // but for simplicity let's rely on specific keys matching or default.\n                // Actually, user might put 'Password': 'hash' and we matched 'password'.\n                // Let's iterate strategies keys to find case-insensitive match if strictly needed.\n                // For performance/simplicity, strict case matching in strategies map is safer,\n                // but generic 'keys' list is case-insensitive.\n\n                // Let's look for a key in strategies that matches lowerKey\n                const strategyKey = Object.keys(config.strategies).find(\n                    (k) => k.toLowerCase() === lowerKey,\n                );\n                if (strategyKey) {\n                    strategy = config.strategies[strategyKey];\n                }\n            }\n\n            const result = applyStrategy(value, strategy);\n            if (result !== undefined) {\n                redactedObj[key] = result;\n            }\n            // If undefined (remove strategy), we just don't add the key.\n        } else {\n            // Recurse\n            redactedObj[key] = recursiveRedact(value, config, cache);\n        }\n    }\n\n    return redactedObj;\n};\n\nexport const createRedactor = (config: RedactionConfig) => {\n    return (info: any) => {\n        return recursiveRedact(info, config);\n    };\n};\n","import { AsyncLocalStorage } from 'async_hooks';\nimport { Logger } from './types';\n\n// We store a reference to the logger so we can update it in-place for the current context\ninterface LoggerStore {\n    logger: Logger;\n}\n\nconst asyncLocalStorage = new AsyncLocalStorage<LoggerStore>();\n\n/**\n * Runs a callback within a logger context.\n * The logger provided becomes the \"current\" logger for the duration of the callback.\n */\nexport const runWithLogger = <T>(logger: Logger, callback: () => T): T => {\n    return asyncLocalStorage.run({ logger }, callback);\n};\n\n/**\n * Gets the current logger from the async context.\n * Throws an error if called outside of a runWithLogger context,\n * unless a fallback is provided (though usually we want to enforce context).\n *\n * To make it easier to use, we can return undefined or a default logger if needed,\n * but for this specific feature request \"access by all down the stream\", strictness is good.\n */\nexport const getLogger = (): Logger | undefined => {\n    const store = asyncLocalStorage.getStore();\n    return store?.logger;\n};\n\n/**\n * Updates the current context's logger.\n * This effectively \"extends\" the logger for the remainder of the current async execution\n * and any further downstream calls sharing this context.\n */\nexport const updateLoggerContext = (newLogger: Logger): void => {\n    const store = asyncLocalStorage.getStore();\n    if (store) {\n        store.logger = newLogger;\n    } else {\n        // If we are not in a context, we can't update it.\n        // We could throw, or warn. For now, let's warn.\n        console.warn(\n            'AntigravityLogger: updateLoggerContext called outside of an active context. Logic ignored.',\n        );\n    }\n};\n","import winston from 'winston';\nimport { Logger } from './types';\nimport { DEFAULT_LOG_LEVEL } from './constants';\nimport { RedactionConfig, createRedactor } from './redactor';\n\nexport interface CreateLoggerOptions {\n    /**\n     * Default context to include in all logs\n     */\n    defaultContext?: Record<string, any>;\n    /**\n     * Log level (default: process.env.LOG_LEVEL || 'info')\n     */\n    level?: string;\n    /**\n     * Configuration for data redaction\n     */\n    redaction?: RedactionConfig;\n}\n\nconst formatContext = (context?: Record<string, any>): Record<string, any> => {\n    return context || {};\n};\n\nconst createLoggerWrapper = (winstonLogger: winston.Logger): Logger => {\n    return {\n        debug: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.debug(message, formatContext(context));\n        },\n\n        info: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.info(message, formatContext(context));\n        },\n\n        warn: (message: string, context?: Record<string, any>): void => {\n            winstonLogger.warn(message, formatContext(context));\n        },\n\n        error: (message: string, error?: Error | string, context?: Record<string, any>): void => {\n            const meta = formatContext(context);\n            if (error instanceof Error) {\n                // Winston handles error objects well if passed as meta or splat\n                // But for explicit structure, let's attach it\n                // Spread error first to capture custom props, then overwrite standard ones to ensure presence\n                const { message, name, stack, ...rest } = error;\n                meta.error = {\n                    ...rest,\n                    message,\n                    name,\n                    stack,\n                };\n            } else if (error) {\n                meta.error = error;\n            }\n            winstonLogger.error(message, meta);\n        },\n\n        child: (context: Record<string, any>): Logger => {\n            // Winston's child() returns a new logger instance with the metadata bound\n            return createLoggerWrapper(winstonLogger.child(context));\n        },\n    };\n};\n\nexport const createLogger = (options: CreateLoggerOptions = {}): Logger => {\n    const level = options.level || process.env.LOG_LEVEL || DEFAULT_LOG_LEVEL;\n\n    // Create redactor if config is present\n    const redactor = options.redaction ? createRedactor(options.redaction) : null;\n\n    // Custom format that applies redaction\n    const redactionFormat = winston.format((info) => {\n        if (redactor) {\n            return redactor(info);\n        }\n        return info;\n    });\n\n    const format = winston.format.combine(\n        winston.format.timestamp(),\n        redactionFormat(), // Apply redaction before JSON\n        winston.format.json(),\n    );\n\n    const winstonLogger = winston.createLogger({\n        level,\n        format,\n        defaultMeta: options.defaultContext,\n        transports: [new winston.transports.Console()],\n    });\n\n    return createLoggerWrapper(winstonLogger);\n};\n","export const DEFAULT_LOG_LEVEL = 'info';\nexport const REQUEST_ID_KEY = 'x-request-id';\n","import { CreateLoggerOptions, createLogger } from './logger';\nimport { runWithLogger } from './context';\n\n// Generic Handler type compatible with AWS Lambda\n// We use 'any' to avoid strict dependency on @types/aws-lambda for this generic wrapper\n// but in practice it wraps (event, context, callback?) => Promise<any> | any\ntype Handler<TEvent = any, TResult = any> = (\n    event: TEvent,\n    context: any,\n    callback?: any,\n) => Promise<TResult> | void;\n\n/**\n * Higher-order function to wrap a Lambda handler with logger context.\n * Automatically extracts 'awsRequestId' and 'functionName' from the Lambda context\n * and initializes a logger for the request scope.\n *\n * @param handler The original Lambda handler\n * @param options Logger options (level, redaction, etc.)\n */\nexport const withLogger = <TEvent = any, TResult = any>(\n    handler: Handler<TEvent, TResult>,\n    options: CreateLoggerOptions = {},\n): Handler<TEvent, TResult> => {\n    return async (event: TEvent, context: any, callback?: any) => {\n        // 1. Initialize Logger\n        // Create a root logger if custom options are provided, or use default behavior.\n        // We create a FRESH logger instance for each request to ensure context isolation if needed?\n        // Actually, creating a logger instance is cheap?\n        // Winston createLogger is relatively heavy.\n        // Optimization: We could reuse a global logger and just child() it.\n        // But options might change? Usually options are static.\n        // Let's assume options are static per lambda wrapper usage.\n\n        // HOWEVER, to support dynamic options per request might be overkill.\n        // Let's create one global logger instance for this wrapper instantiation if possible?\n        // But wait, the standard `createLogger` we implemented creates a NEW winston instance every time.\n        // We should probably cache it?\n        // For now, let's keep it simple: createLogger per request.\n        // If performance becomes an issue, we can refactor `createLogger` to reuse the winston instance if options match.\n\n        const rootLogger = createLogger(options);\n\n        // 2. Extract Context\n        const requestContext: Record<string, any> = {};\n        if (context) {\n            if (context.awsRequestId) requestContext.requestId = context.awsRequestId;\n            if (context.functionName) requestContext.functionName = context.functionName;\n        }\n\n        // 3. Create Child Logger with Request Context\n        const scopedLogger = rootLogger.child(requestContext);\n\n        // 3a. Log Event and Context\n        scopedLogger.debug('Lambda Event', { event });\n        scopedLogger.debug('Lambda Context', { context });\n\n        // 4. Run Handler in Context\n        return runWithLogger(scopedLogger, async () => {\n            // We use 'await' to ensure the context stays active during the handler execution\n            // If the handler accepts a callback, we might need special handling?\n            // Most modern lambdas use async/await.\n            // If legacy callback style is used, AsyncLocalStorage context *should* still propagate\n            // if the callback is invoked asynchronously.\n            // But we wrap the result in Promise usually.\n\n            // Supporting both async and callback style:\n            try {\n                // If it returns a promise, await it\n                const result = await handler(event, context, callback);\n                return result as TResult;\n            } catch (error) {\n                // We could log unhandled errors here too?\n                // Standard lambda practice is to let the error propagate so Lambda runtime sees it (and retries etc)\n                // BUT we should log it first because once it leaves here, we might lose the logger context behavior.\n                scopedLogger.error('Unhandled Lambda Exception', error as Error);\n                throw error;\n            }\n        });\n    };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,oBAAmB;AAsBZ,IAAM,wBAAwB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ;AAKA,IAAM,gBAAgB,CAAC,OAAY,aAAqC;AACpE,MAAI,OAAO,aAAa,YAAY;AAChC,WAAO,SAAS,KAAK;AAAA,EACzB;AAEA,MAAI,OAAO,aAAa,YAAY,SAAS,WAAW,YAAY,GAAG;AACnE,UAAM,QAAQ,SAAS,MAAM,GAAG;AAChC,UAAM,QAAQ,SAAS,MAAM,CAAC,GAAG,EAAE;AAEnC,QAAI,OAAO,UAAU,YAAY,CAAC,MAAM,KAAK,GAAG;AAC5C,UAAI,MAAM,UAAU,OAAO;AACvB,eAAO;AAOP,eAAO;AAAA,MACX;AACA,YAAM,UAAU,MAAM,SAAS;AAC/B,aAAO,IAAI,OAAO,OAAO,IAAI,MAAM,MAAM,CAAC,KAAK;AAAA,IACnD;AACA,WAAO;AAAA,EACX;AAEA,UAAQ,UAAU;AAAA,IACd,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,UAAI,OAAO,UAAU,YAAY,OAAO,UAAU,UAAU;AACxD,eAAO,cAAAA,QAAO,WAAW,QAAQ,EAAE,OAAO,OAAO,KAAK,CAAC,EAAE,OAAO,KAAK;AAAA,MACzE;AACA,aAAO;AAAA,IACX,KAAK;AAAA,IACL;AACI,aAAO;AAAA,EACf;AACJ;AAKO,IAAM,kBAAkB,CAC3B,QACA,QACA,QAAQ,oBAAI,IAAS,MACf;AACN,MAAI,WAAW,QAAQ,OAAO,WAAW,UAAU;AAC/C,WAAO;AAAA,EACX;AAGA,MAAI,MAAM,IAAI,MAAM,GAAG;AACnB,WAAO;AAAA,EACX;AACA,QAAM,IAAI,MAAM;AAGhB,MAAI,MAAM,QAAQ,MAAM,GAAG;AACvB,WAAO,OAAO,IAAI,CAAC,SAAS,gBAAgB,MAAM,QAAQ,KAAK,CAAC;AAAA,EACpE;AAGA,QAAM,cAAmC,CAAC;AAC1C,QAAM,eAAe,IAAI,IAAI,OAAO,KAAK,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEpE,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AAC/C,UAAM,WAAW,IAAI,YAAY;AAEjC,QAAI,aAAa,IAAI,QAAQ,GAAG;AAE5B,UAAI,WAAW,OAAO,mBAAmB;AACzC,UAAI,OAAO,cAAc,OAAO,WAAW,GAAG,GAAG;AAE7C,mBAAW,OAAO,WAAW,GAAG;AAAA,MACpC,WAAW,OAAO,YAAY;AAS1B,cAAM,cAAc,OAAO,KAAK,OAAO,UAAU,EAAE;AAAA,UAC/C,CAAC,MAAM,EAAE,YAAY,MAAM;AAAA,QAC/B;AACA,YAAI,aAAa;AACb,qBAAW,OAAO,WAAW,WAAW;AAAA,QAC5C;AAAA,MACJ;AAEA,YAAM,SAAS,cAAc,OAAO,QAAQ;AAC5C,UAAI,WAAW,QAAW;AACtB,oBAAY,GAAG,IAAI;AAAA,MACvB;AAAA,IAEJ,OAAO;AAEH,kBAAY,GAAG,IAAI,gBAAgB,OAAO,QAAQ,KAAK;AAAA,IAC3D;AAAA,EACJ;AAEA,SAAO;AACX;AAEO,IAAM,iBAAiB,CAAC,WAA4B;AACvD,SAAO,CAAC,SAAc;AAClB,WAAO,gBAAgB,MAAM,MAAM;AAAA,EACvC;AACJ;;;AC3JA,yBAAkC;AAQlC,IAAM,oBAAoB,IAAI,qCAA+B;AAMtD,IAAM,gBAAgB,CAAI,QAAgB,aAAyB;AACtE,SAAO,kBAAkB,IAAI,EAAE,OAAO,GAAG,QAAQ;AACrD;AAUO,IAAM,YAAY,MAA0B;AAC/C,QAAM,QAAQ,kBAAkB,SAAS;AACzC,SAAO,OAAO;AAClB;AAOO,IAAM,sBAAsB,CAAC,cAA4B;AAC5D,QAAM,QAAQ,kBAAkB,SAAS;AACzC,MAAI,OAAO;AACP,UAAM,SAAS;AAAA,EACnB,OAAO;AAGH,YAAQ;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACJ;;;AC/CA,qBAAoB;;;ACAb,IAAM,oBAAoB;AAC1B,IAAM,iBAAiB;;;ADmB9B,IAAM,gBAAgB,CAAC,YAAuD;AAC1E,SAAO,WAAW,CAAC;AACvB;AAEA,IAAM,sBAAsB,CAAC,kBAA0C;AACnE,SAAO;AAAA,IACH,OAAO,CAAC,SAAiB,YAAwC;AAC7D,oBAAc,MAAM,SAAS,cAAc,OAAO,CAAC;AAAA,IACvD;AAAA,IAEA,MAAM,CAAC,SAAiB,YAAwC;AAC5D,oBAAc,KAAK,SAAS,cAAc,OAAO,CAAC;AAAA,IACtD;AAAA,IAEA,MAAM,CAAC,SAAiB,YAAwC;AAC5D,oBAAc,KAAK,SAAS,cAAc,OAAO,CAAC;AAAA,IACtD;AAAA,IAEA,OAAO,CAAC,SAAiB,OAAwB,YAAwC;AACrF,YAAM,OAAO,cAAc,OAAO;AAClC,UAAI,iBAAiB,OAAO;AAIxB,cAAM,EAAE,SAAAC,UAAS,MAAM,OAAO,GAAG,KAAK,IAAI;AAC1C,aAAK,QAAQ;AAAA,UACT,GAAG;AAAA,UACH,SAAAA;AAAA,UACA;AAAA,UACA;AAAA,QACJ;AAAA,MACJ,WAAW,OAAO;AACd,aAAK,QAAQ;AAAA,MACjB;AACA,oBAAc,MAAM,SAAS,IAAI;AAAA,IACrC;AAAA,IAEA,OAAO,CAAC,YAAyC;AAE7C,aAAO,oBAAoB,cAAc,MAAM,OAAO,CAAC;AAAA,IAC3D;AAAA,EACJ;AACJ;AAEO,IAAM,eAAe,CAAC,UAA+B,CAAC,MAAc;AACvE,QAAM,QAAQ,QAAQ,SAAS,QAAQ,IAAI,aAAa;AAGxD,QAAM,WAAW,QAAQ,YAAY,eAAe,QAAQ,SAAS,IAAI;AAGzE,QAAM,kBAAkB,eAAAC,QAAQ,OAAO,CAAC,SAAS;AAC7C,QAAI,UAAU;AACV,aAAO,SAAS,IAAI;AAAA,IACxB;AACA,WAAO;AAAA,EACX,CAAC;AAED,QAAM,SAAS,eAAAA,QAAQ,OAAO;AAAA,IAC1B,eAAAA,QAAQ,OAAO,UAAU;AAAA,IACzB,gBAAgB;AAAA;AAAA,IAChB,eAAAA,QAAQ,OAAO,KAAK;AAAA,EACxB;AAEA,QAAM,gBAAgB,eAAAA,QAAQ,aAAa;AAAA,IACvC;AAAA,IACA;AAAA,IACA,aAAa,QAAQ;AAAA,IACrB,YAAY,CAAC,IAAI,eAAAA,QAAQ,WAAW,QAAQ,CAAC;AAAA,EACjD,CAAC;AAED,SAAO,oBAAoB,aAAa;AAC5C;;;AExEO,IAAM,aAAa,CACtB,SACA,UAA+B,CAAC,MACL;AAC3B,SAAO,OAAO,OAAe,SAAc,aAAmB;AAiB1D,UAAM,aAAa,aAAa,OAAO;AAGvC,UAAM,iBAAsC,CAAC;AAC7C,QAAI,SAAS;AACT,UAAI,QAAQ,aAAc,gBAAe,YAAY,QAAQ;AAC7D,UAAI,QAAQ,aAAc,gBAAe,eAAe,QAAQ;AAAA,IACpE;AAGA,UAAM,eAAe,WAAW,MAAM,cAAc;AAGpD,iBAAa,MAAM,gBAAgB,EAAE,MAAM,CAAC;AAC5C,iBAAa,MAAM,kBAAkB,EAAE,QAAQ,CAAC;AAGhD,WAAO,cAAc,cAAc,YAAY;AAS3C,UAAI;AAEA,cAAM,SAAS,MAAM,QAAQ,OAAO,SAAS,QAAQ;AACrD,eAAO;AAAA,MACX,SAAS,OAAO;AAIZ,qBAAa,MAAM,8BAA8B,KAAc;AAC/D,cAAM;AAAA,MACV;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;","names":["crypto","message","winston"]}