@geekmidas/logger 0.1.0 → 0.2.0

package/dist/console.cjs

@@ -1,53 +1,83 @@
+const require_types = require('./types-ag_0Cvbg.cjs');
 
 //#region src/console.ts
+/**
+* Numeric priority for log levels (higher = more severe)
+*/
+const LOG_LEVEL_PRIORITY = {
+	[require_types.LogLevel.Trace]: 10,
+	[require_types.LogLevel.Debug]: 20,
+	[require_types.LogLevel.Info]: 30,
+	[require_types.LogLevel.Warn]: 40,
+	[require_types.LogLevel.Error]: 50,
+	[require_types.LogLevel.Fatal]: 60,
+	[require_types.LogLevel.Silent]: 70
+};
 var ConsoleLogger = class ConsoleLogger {
+	level;
 	/**
 	* Creates a new ConsoleLogger instance.
 	*
 	* @param data - Initial context data to include in all log messages
+	* @param level - Minimum log level to output (default: Info)
 	*/
-	constructor(data = {}) {
+	constructor(data = {}, level = require_types.LogLevel.Info) {
 		this.data = data;
+		this.level = level;
+	}
+	/**
+	* Checks if a log level should be output based on the configured minimum level.
+	*/
+	shouldLog(level) {
+		if (this.level === require_types.LogLevel.Silent) return false;
+		return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
 	}
 	/**
 	* Creates a logging function that merges context data and adds timestamps.
 	*
 	* @param logMethod - The console method to use (e.g., console.log, console.error)
+	* @param level - The log level for this method
 	* @returns A LogFn that handles both structured and simple logging
 	* @private
 	*/
-	createLogFn(logMethod) {
+	createLogFn(logMethod, level) {
 		return (objOrMsg, msg, ...args) => {
+			if (!this.shouldLog(level)) return;
 			const ts = Date.now();
 			if (typeof objOrMsg === "string") {
-				const mergedData$1 = {
+				const logData$1 = {
 					...this.data,
+					msg: objOrMsg,
 					ts
 				};
-				logMethod(mergedData$1, objOrMsg, ...args);
+				logMethod(logData$1, ...args);
 				return;
 			}
-			const mergedData = {
+			const logData = msg ? {
+				...this.data,
+				...objOrMsg,
+				msg,
+				ts
+			} : {
 				...this.data,
 				...objOrMsg,
 				ts
 			};
-			if (msg) logMethod(mergedData, msg, ...args);
-			else logMethod(mergedData, ...args);
+			logMethod(logData, ...args);
 		};
 	}
+	/** Trace level logging function */
+	trace = this.createLogFn(console.trace.bind(console), require_types.LogLevel.Trace);
 	/** Debug level logging function */
-	debug = this.createLogFn(console.debug.bind(console));
+	debug = this.createLogFn(console.debug.bind(console), require_types.LogLevel.Debug);
 	/** Info level logging function */
-	info = this.createLogFn(console.info.bind(console));
+	info = this.createLogFn(console.info.bind(console), require_types.LogLevel.Info);
 	/** Warning level logging function */
-	warn = this.createLogFn(console.warn.bind(console));
+	warn = this.createLogFn(console.warn.bind(console), require_types.LogLevel.Warn);
 	/** Error level logging function */
-	error = this.createLogFn(console.error.bind(console));
+	error = this.createLogFn(console.error.bind(console), require_types.LogLevel.Error);
 	/** Fatal level logging function (uses console.error) */
-	fatal = this.createLogFn(console.error.bind(console));
-	/** Trace level logging function */
-	trace = this.createLogFn(console.trace.bind(console));
+	fatal = this.createLogFn(console.error.bind(console), require_types.LogLevel.Fatal);
 	/**
 	* Creates a child logger with additional context data.
 	* The child logger inherits all context from the parent and adds its own.
@@ -67,7 +97,7 @@ var ConsoleLogger = class ConsoleLogger {
 		return new ConsoleLogger({
 			...this.data,
 			...obj
-		});
+		}, this.level);
 	}
 };
 /**
@@ -75,14 +105,14 @@ var ConsoleLogger = class ConsoleLogger {
 * ```typescript
 * const logger = new ConsoleLogger({ app: 'myApp' });
 * logger.info({ action: 'start' }, 'Application starting');
-* // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+* // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
 * ```
 *
 * @example Child logger usage
 * ```typescript
 * const childLogger = logger.child({ module: 'auth' });
 * childLogger.debug({ userId: 123 }, 'User authenticated');
-* // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+* // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
 * ```
 *
 * @example Error logging with context
@@ -104,13 +134,15 @@ const DEFAULT_LOGGER = new ConsoleLogger();
 * @example
 * ```typescript
 * import { createLogger } from '@geekmidas/logger/console';
+* import { LogLevel } from '@geekmidas/logger';
 *
 * const logger = createLogger({ level: LogLevel.Debug });
-* logger.info({ action: 'start' }, 'Application starting');
+* logger.debug('This will be logged');
+* logger.trace('This will NOT be logged (below Debug level)');
 * ```
 */
 function createLogger(options = {}) {
-	return new ConsoleLogger();
+	return new ConsoleLogger({}, options.level ?? require_types.LogLevel.Info);
 }
 
 //#endregion

package/dist/console.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"console.cjs","names":["data: object","logMethod: (...args: any[]) => void","objOrMsg: T | string","msg?: string","mergedData","obj: object","options: CreateLoggerOptions"],"sources":["../src/console.ts"],"sourcesContent":["import type { CreateLoggerOptions, LogFn, Logger } from './types';\n\nexport class ConsoleLogger implements Logger {\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   */\n  constructor(readonly data: object = {}) {}\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(logMethod: (...args: any[]) => void): LogFn {\n    return <T extends object>(\n      objOrMsg: T | string,\n      msg?: string,\n      ...args: any[]\n    ): void => {\n      const ts = Date.now();\n\n      // Handle simple string logging: logger.info('message')\n      if (typeof objOrMsg === 'string') {\n        const mergedData = { ...this.data, ts };\n        logMethod(mergedData, objOrMsg, ...args);\n        return;\n      }\n\n      // Handle structured logging: logger.info({ data }, 'message')\n      const mergedData = { ...this.data, ...objOrMsg, ts };\n      if (msg) {\n        logMethod(mergedData, msg, ...args);\n      } else {\n        logMethod(mergedData, ...args);\n      }\n    };\n  }\n\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console));\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console));\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console));\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console));\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console));\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console));\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger({\n      ...this.data,\n      ...obj,\n    });\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n\n/**\n * Creates a console logger with the same API as pino's createLogger.\n *\n * @param options - Logger configuration options\n * @returns A ConsoleLogger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@geekmidas/logger/console';\n *\n * const logger = createLogger({ level: LogLevel.Debug });\n * logger.info({ action: 'start' }, 'Application starting');\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}): Logger {\n  return new ConsoleLogger();\n}\n"],"mappings":";;AAEA,IAAa,gBAAb,MAAa,cAAgC;;;;;;CAM3C,YAAqBA,OAAe,CAAE,GAAE;EAAnB;CAAqB;;;;;;;;CAS1C,AAAQ,YAAYC,WAA4C;AAC9D,SAAO,CACLC,UACAC,KACA,GAAG,SACM;GACT,MAAM,KAAK,KAAK,KAAK;AAGrB,cAAW,aAAa,UAAU;IAChC,MAAMC,eAAa;KAAE,GAAG,KAAK;KAAM;IAAI;AACvC,cAAUA,cAAY,UAAU,GAAG,KAAK;AACxC;GACD;GAGD,MAAM,aAAa;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;GAAI;AACpD,OAAI,IACF,WAAU,YAAY,KAAK,GAAG,KAAK;OAEnC,WAAU,YAAY,GAAG,KAAK;EAEjC;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;;;;;;;;;;;;;;;CAiB5D,MAAMC,KAAqB;AACzB,SAAO,IAAI,cAAc;GACvB,GAAG,KAAK;GACR,GAAG;EACJ;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI;;;;;;;;;;;;;;;AAgBlC,SAAgB,aAAaC,UAA+B,CAAE,GAAU;AACtE,QAAO,IAAI;AACZ"}
+{"version":3,"file":"console.cjs","names":["LOG_LEVEL_PRIORITY: Record<LogLevel, number>","LogLevel","data: object","level: LogLevel","logMethod: (...args: any[]) => void","objOrMsg: T | string","msg?: string","logData","obj: object","options: CreateLoggerOptions"],"sources":["../src/console.ts"],"sourcesContent":["import type { CreateLoggerOptions, LogFn, Logger } from './types';\nimport { LogLevel } from './types';\n\n/**\n * Numeric priority for log levels (higher = more severe)\n */\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  [LogLevel.Trace]: 10,\n  [LogLevel.Debug]: 20,\n  [LogLevel.Info]: 30,\n  [LogLevel.Warn]: 40,\n  [LogLevel.Error]: 50,\n  [LogLevel.Fatal]: 60,\n  [LogLevel.Silent]: 70,\n};\n\nexport class ConsoleLogger implements Logger {\n  private readonly level: LogLevel;\n\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   * @param level - Minimum log level to output (default: Info)\n   */\n  constructor(\n    readonly data: object = {},\n    level: LogLevel = LogLevel.Info,\n  ) {\n    this.level = level;\n  }\n\n  /**\n   * Checks if a log level should be output based on the configured minimum level.\n   */\n  private shouldLog(level: LogLevel): boolean {\n    if (this.level === LogLevel.Silent) {\n      return false;\n    }\n    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];\n  }\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @param level - The log level for this method\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(\n    logMethod: (...args: any[]) => void,\n    level: LogLevel,\n  ): LogFn {\n    return <T extends object>(\n      objOrMsg: T | string,\n      msg?: string,\n      ...args: any[]\n    ): void => {\n      if (!this.shouldLog(level)) {\n        return;\n      }\n\n      const ts = Date.now();\n\n      // Handle simple string logging: logger.info('message')\n      if (typeof objOrMsg === 'string') {\n        const logData = { ...this.data, msg: objOrMsg, ts };\n        logMethod(logData, ...args);\n        return;\n      }\n\n      // Handle structured logging: logger.info({ data }, 'message')\n      const logData = msg\n        ? { ...this.data, ...objOrMsg, msg, ts }\n        : { ...this.data, ...objOrMsg, ts };\n      logMethod(logData, ...args);\n    };\n  }\n\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console), LogLevel.Trace);\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console), LogLevel.Debug);\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console), LogLevel.Info);\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Error);\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Fatal);\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger(\n      {\n        ...this.data,\n        ...obj,\n      },\n      this.level,\n    );\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n\n/**\n * Creates a console logger with the same API as pino's createLogger.\n *\n * @param options - Logger configuration options\n * @returns A ConsoleLogger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@geekmidas/logger/console';\n * import { LogLevel } from '@geekmidas/logger';\n *\n * const logger = createLogger({ level: LogLevel.Debug });\n * logger.debug('This will be logged');\n * logger.trace('This will NOT be logged (below Debug level)');\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}): Logger {\n  return new ConsoleLogger({}, options.level ?? LogLevel.Info);\n}\n"],"mappings":";;;;;;AAMA,MAAMA,qBAA+C;EAClDC,uBAAS,QAAQ;EACjBA,uBAAS,QAAQ;EACjBA,uBAAS,OAAO;EAChBA,uBAAS,OAAO;EAChBA,uBAAS,QAAQ;EACjBA,uBAAS,QAAQ;EACjBA,uBAAS,SAAS;AACpB;AAED,IAAa,gBAAb,MAAa,cAAgC;CAC3C,AAAiB;;;;;;;CAQjB,YACWC,OAAe,CAAE,GAC1BC,QAAkBF,uBAAS,MAC3B;EAFS;AAGT,OAAK,QAAQ;CACd;;;;CAKD,AAAQ,UAAUE,OAA0B;AAC1C,MAAI,KAAK,UAAUF,uBAAS,OAC1B,QAAO;AAET,SAAO,mBAAmB,UAAU,mBAAmB,KAAK;CAC7D;;;;;;;;;CAUD,AAAQ,YACNG,WACAD,OACO;AACP,SAAO,CACLE,UACAC,KACA,GAAG,SACM;AACT,QAAK,KAAK,UAAU,MAAM,CACxB;GAGF,MAAM,KAAK,KAAK,KAAK;AAGrB,cAAW,aAAa,UAAU;IAChC,MAAMC,YAAU;KAAE,GAAG,KAAK;KAAM,KAAK;KAAU;IAAI;AACnD,cAAUA,WAAS,GAAG,KAAK;AAC3B;GACD;GAGD,MAAM,UAAU,MACZ;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;IAAK;GAAI,IACtC;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;GAAI;AACrC,aAAU,SAAS,GAAG,KAAK;EAC5B;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEN,uBAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEA,uBAAS,MAAM;;CAE5E,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAEA,uBAAS,KAAK;;CAEzE,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAEA,uBAAS,KAAK;;CAEzE,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEA,uBAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAEA,uBAAS,MAAM;;;;;;;;;;;;;;;;CAiB5E,MAAMO,KAAqB;AACzB,SAAO,IAAI,cACT;GACE,GAAG,KAAK;GACR,GAAG;EACJ,GACD,KAAK;CAER;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI;;;;;;;;;;;;;;;;;AAkBlC,SAAgB,aAAaC,UAA+B,CAAE,GAAU;AACtE,QAAO,IAAI,cAAc,CAAE,GAAE,QAAQ,SAASR,uBAAS;AACxD"}

package/dist/console.d.cts

@@ -1,22 +1,31 @@
-import { CreateLoggerOptions, LogFn, Logger } from "./types-JxCFymH0.cjs";
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-JxCFymH0.cjs";
 
 //#region src/console.d.ts
 declare class ConsoleLogger implements Logger {
   readonly data: object;
+  private readonly level;
   /**
    * Creates a new ConsoleLogger instance.
    *
    * @param data - Initial context data to include in all log messages
+   * @param level - Minimum log level to output (default: Info)
    */
-  constructor(data?: object);
+  constructor(data?: object, level?: LogLevel);
+  /**
+   * Checks if a log level should be output based on the configured minimum level.
+   */
+  private shouldLog;
   /**
    * Creates a logging function that merges context data and adds timestamps.
    *
    * @param logMethod - The console method to use (e.g., console.log, console.error)
+   * @param level - The log level for this method
    * @returns A LogFn that handles both structured and simple logging
    * @private
    */
   private createLogFn;
+  /** Trace level logging function */
+  trace: LogFn;
   /** Debug level logging function */
   debug: LogFn;
   /** Info level logging function */
@@ -27,8 +36,6 @@ declare class ConsoleLogger implements Logger {
   error: LogFn;
   /** Fatal level logging function (uses console.error) */
   fatal: LogFn;
-  /** Trace level logging function */
-  trace: LogFn;
   /**
    * Creates a child logger with additional context data.
    * The child logger inherits all context from the parent and adds its own.
@@ -51,14 +58,14 @@ declare class ConsoleLogger implements Logger {
  * ```typescript
  * const logger = new ConsoleLogger({ app: 'myApp' });
  * logger.info({ action: 'start' }, 'Application starting');
- * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+ * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
  * ```
  *
  * @example Child logger usage
  * ```typescript
  * const childLogger = logger.child({ module: 'auth' });
  * childLogger.debug({ userId: 123 }, 'User authenticated');
- * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+ * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
  * ```
  *
  * @example Error logging with context
@@ -80,9 +87,11 @@ declare const DEFAULT_LOGGER: any;
  * @example
  * ```typescript
  * import { createLogger } from '@geekmidas/logger/console';
+ * import { LogLevel } from '@geekmidas/logger';
  *
  * const logger = createLogger({ level: LogLevel.Debug });
- * logger.info({ action: 'start' }, 'Application starting');
+ * logger.debug('This will be logged');
+ * logger.trace('This will NOT be logged (below Debug level)');
  * ```
  */
 declare function createLogger(options?: CreateLoggerOptions): Logger;

package/dist/console.d.mts

@@ -1,22 +1,31 @@
-import { CreateLoggerOptions, LogFn, Logger } from "./types-BFiJzL9N.mjs";
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-Bga8WDuP.mjs";
 
 //#region src/console.d.ts
 declare class ConsoleLogger implements Logger {
   readonly data: object;
+  private readonly level;
   /**
    * Creates a new ConsoleLogger instance.
    *
    * @param data - Initial context data to include in all log messages
+   * @param level - Minimum log level to output (default: Info)
    */
-  constructor(data?: object);
+  constructor(data?: object, level?: LogLevel);
+  /**
+   * Checks if a log level should be output based on the configured minimum level.
+   */
+  private shouldLog;
   /**
    * Creates a logging function that merges context data and adds timestamps.
    *
    * @param logMethod - The console method to use (e.g., console.log, console.error)
+   * @param level - The log level for this method
    * @returns A LogFn that handles both structured and simple logging
    * @private
    */
   private createLogFn;
+  /** Trace level logging function */
+  trace: LogFn;
   /** Debug level logging function */
   debug: LogFn;
   /** Info level logging function */
@@ -27,8 +36,6 @@ declare class ConsoleLogger implements Logger {
   error: LogFn;
   /** Fatal level logging function (uses console.error) */
   fatal: LogFn;
-  /** Trace level logging function */
-  trace: LogFn;
   /**
    * Creates a child logger with additional context data.
    * The child logger inherits all context from the parent and adds its own.
@@ -51,14 +58,14 @@ declare class ConsoleLogger implements Logger {
  * ```typescript
  * const logger = new ConsoleLogger({ app: 'myApp' });
  * logger.info({ action: 'start' }, 'Application starting');
- * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+ * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
  * ```
  *
  * @example Child logger usage
  * ```typescript
  * const childLogger = logger.child({ module: 'auth' });
  * childLogger.debug({ userId: 123 }, 'User authenticated');
- * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+ * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
  * ```
  *
  * @example Error logging with context
@@ -80,9 +87,11 @@ declare const DEFAULT_LOGGER: any;
  * @example
  * ```typescript
  * import { createLogger } from '@geekmidas/logger/console';
+ * import { LogLevel } from '@geekmidas/logger';
  *
  * const logger = createLogger({ level: LogLevel.Debug });
- * logger.info({ action: 'start' }, 'Application starting');
+ * logger.debug('This will be logged');
+ * logger.trace('This will NOT be logged (below Debug level)');
  * ```
  */
 declare function createLogger(options?: CreateLoggerOptions): Logger;

package/dist/console.mjs

@@ -1,52 +1,83 @@
+import { LogLevel } from "./types-yQ6XOihF.mjs";
+
 //#region src/console.ts
+/**
+* Numeric priority for log levels (higher = more severe)
+*/
+const LOG_LEVEL_PRIORITY = {
+	[LogLevel.Trace]: 10,
+	[LogLevel.Debug]: 20,
+	[LogLevel.Info]: 30,
+	[LogLevel.Warn]: 40,
+	[LogLevel.Error]: 50,
+	[LogLevel.Fatal]: 60,
+	[LogLevel.Silent]: 70
+};
 var ConsoleLogger = class ConsoleLogger {
+	level;
 	/**
 	* Creates a new ConsoleLogger instance.
 	*
 	* @param data - Initial context data to include in all log messages
+	* @param level - Minimum log level to output (default: Info)
 	*/
-	constructor(data = {}) {
+	constructor(data = {}, level = LogLevel.Info) {
 		this.data = data;
+		this.level = level;
+	}
+	/**
+	* Checks if a log level should be output based on the configured minimum level.
+	*/
+	shouldLog(level) {
+		if (this.level === LogLevel.Silent) return false;
+		return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
 	}
 	/**
 	* Creates a logging function that merges context data and adds timestamps.
 	*
 	* @param logMethod - The console method to use (e.g., console.log, console.error)
+	* @param level - The log level for this method
 	* @returns A LogFn that handles both structured and simple logging
 	* @private
 	*/
-	createLogFn(logMethod) {
+	createLogFn(logMethod, level) {
 		return (objOrMsg, msg, ...args) => {
+			if (!this.shouldLog(level)) return;
 			const ts = Date.now();
 			if (typeof objOrMsg === "string") {
-				const mergedData$1 = {
+				const logData$1 = {
 					...this.data,
+					msg: objOrMsg,
 					ts
 				};
-				logMethod(mergedData$1, objOrMsg, ...args);
+				logMethod(logData$1, ...args);
 				return;
 			}
-			const mergedData = {
+			const logData = msg ? {
+				...this.data,
+				...objOrMsg,
+				msg,
+				ts
+			} : {
 				...this.data,
 				...objOrMsg,
 				ts
 			};
-			if (msg) logMethod(mergedData, msg, ...args);
-			else logMethod(mergedData, ...args);
+			logMethod(logData, ...args);
 		};
 	}
+	/** Trace level logging function */
+	trace = this.createLogFn(console.trace.bind(console), LogLevel.Trace);
 	/** Debug level logging function */
-	debug = this.createLogFn(console.debug.bind(console));
+	debug = this.createLogFn(console.debug.bind(console), LogLevel.Debug);
 	/** Info level logging function */
-	info = this.createLogFn(console.info.bind(console));
+	info = this.createLogFn(console.info.bind(console), LogLevel.Info);
 	/** Warning level logging function */
-	warn = this.createLogFn(console.warn.bind(console));
+	warn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);
 	/** Error level logging function */
-	error = this.createLogFn(console.error.bind(console));
+	error = this.createLogFn(console.error.bind(console), LogLevel.Error);
 	/** Fatal level logging function (uses console.error) */
-	fatal = this.createLogFn(console.error.bind(console));
-	/** Trace level logging function */
-	trace = this.createLogFn(console.trace.bind(console));
+	fatal = this.createLogFn(console.error.bind(console), LogLevel.Fatal);
 	/**
 	* Creates a child logger with additional context data.
 	* The child logger inherits all context from the parent and adds its own.
@@ -66,7 +97,7 @@ var ConsoleLogger = class ConsoleLogger {
 		return new ConsoleLogger({
 			...this.data,
 			...obj
-		});
+		}, this.level);
 	}
 };
 /**
@@ -74,14 +105,14 @@ var ConsoleLogger = class ConsoleLogger {
 * ```typescript
 * const logger = new ConsoleLogger({ app: 'myApp' });
 * logger.info({ action: 'start' }, 'Application starting');
-* // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+* // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
 * ```
 *
 * @example Child logger usage
 * ```typescript
 * const childLogger = logger.child({ module: 'auth' });
 * childLogger.debug({ userId: 123 }, 'User authenticated');
-* // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated
+* // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
 * ```
 *
 * @example Error logging with context
@@ -103,13 +134,15 @@ const DEFAULT_LOGGER = new ConsoleLogger();
 * @example
 * ```typescript
 * import { createLogger } from '@geekmidas/logger/console';
+* import { LogLevel } from '@geekmidas/logger';
 *
 * const logger = createLogger({ level: LogLevel.Debug });
-* logger.info({ action: 'start' }, 'Application starting');
+* logger.debug('This will be logged');
+* logger.trace('This will NOT be logged (below Debug level)');
 * ```
 */
 function createLogger(options = {}) {
-	return new ConsoleLogger();
+	return new ConsoleLogger({}, options.level ?? LogLevel.Info);
 }
 
 //#endregion

package/dist/console.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"console.mjs","names":["data: object","logMethod: (...args: any[]) => void","objOrMsg: T | string","msg?: string","mergedData","obj: object","options: CreateLoggerOptions"],"sources":["../src/console.ts"],"sourcesContent":["import type { CreateLoggerOptions, LogFn, Logger } from './types';\n\nexport class ConsoleLogger implements Logger {\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   */\n  constructor(readonly data: object = {}) {}\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(logMethod: (...args: any[]) => void): LogFn {\n    return <T extends object>(\n      objOrMsg: T | string,\n      msg?: string,\n      ...args: any[]\n    ): void => {\n      const ts = Date.now();\n\n      // Handle simple string logging: logger.info('message')\n      if (typeof objOrMsg === 'string') {\n        const mergedData = { ...this.data, ts };\n        logMethod(mergedData, objOrMsg, ...args);\n        return;\n      }\n\n      // Handle structured logging: logger.info({ data }, 'message')\n      const mergedData = { ...this.data, ...objOrMsg, ts };\n      if (msg) {\n        logMethod(mergedData, msg, ...args);\n      } else {\n        logMethod(mergedData, ...args);\n      }\n    };\n  }\n\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console));\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console));\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console));\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console));\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console));\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console));\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger({\n      ...this.data,\n      ...obj,\n    });\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, ts: 1234567891 } User authenticated\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n\n/**\n * Creates a console logger with the same API as pino's createLogger.\n *\n * @param options - Logger configuration options\n * @returns A ConsoleLogger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@geekmidas/logger/console';\n *\n * const logger = createLogger({ level: LogLevel.Debug });\n * logger.info({ action: 'start' }, 'Application starting');\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}): Logger {\n  return new ConsoleLogger();\n}\n"],"mappings":";AAEA,IAAa,gBAAb,MAAa,cAAgC;;;;;;CAM3C,YAAqBA,OAAe,CAAE,GAAE;EAAnB;CAAqB;;;;;;;;CAS1C,AAAQ,YAAYC,WAA4C;AAC9D,SAAO,CACLC,UACAC,KACA,GAAG,SACM;GACT,MAAM,KAAK,KAAK,KAAK;AAGrB,cAAW,aAAa,UAAU;IAChC,MAAMC,eAAa;KAAE,GAAG,KAAK;KAAM;IAAI;AACvC,cAAUA,cAAY,UAAU,GAAG,KAAK;AACxC;GACD;GAGD,MAAM,aAAa;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;GAAI;AACpD,OAAI,IACF,WAAU,YAAY,KAAK,GAAG,KAAK;OAEnC,WAAU,YAAY,GAAG,KAAK;EAEjC;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,CAAC;;CAE1D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;CAE5D,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,CAAC;;;;;;;;;;;;;;;;CAiB5D,MAAMC,KAAqB;AACzB,SAAO,IAAI,cAAc;GACvB,GAAG,KAAK;GACR,GAAG;EACJ;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI;;;;;;;;;;;;;;;AAgBlC,SAAgB,aAAaC,UAA+B,CAAE,GAAU;AACtE,QAAO,IAAI;AACZ"}
+{"version":3,"file":"console.mjs","names":["LOG_LEVEL_PRIORITY: Record<LogLevel, number>","data: object","level: LogLevel","logMethod: (...args: any[]) => void","objOrMsg: T | string","msg?: string","logData","obj: object","options: CreateLoggerOptions"],"sources":["../src/console.ts"],"sourcesContent":["import type { CreateLoggerOptions, LogFn, Logger } from './types';\nimport { LogLevel } from './types';\n\n/**\n * Numeric priority for log levels (higher = more severe)\n */\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  [LogLevel.Trace]: 10,\n  [LogLevel.Debug]: 20,\n  [LogLevel.Info]: 30,\n  [LogLevel.Warn]: 40,\n  [LogLevel.Error]: 50,\n  [LogLevel.Fatal]: 60,\n  [LogLevel.Silent]: 70,\n};\n\nexport class ConsoleLogger implements Logger {\n  private readonly level: LogLevel;\n\n  /**\n   * Creates a new ConsoleLogger instance.\n   *\n   * @param data - Initial context data to include in all log messages\n   * @param level - Minimum log level to output (default: Info)\n   */\n  constructor(\n    readonly data: object = {},\n    level: LogLevel = LogLevel.Info,\n  ) {\n    this.level = level;\n  }\n\n  /**\n   * Checks if a log level should be output based on the configured minimum level.\n   */\n  private shouldLog(level: LogLevel): boolean {\n    if (this.level === LogLevel.Silent) {\n      return false;\n    }\n    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];\n  }\n\n  /**\n   * Creates a logging function that merges context data and adds timestamps.\n   *\n   * @param logMethod - The console method to use (e.g., console.log, console.error)\n   * @param level - The log level for this method\n   * @returns A LogFn that handles both structured and simple logging\n   * @private\n   */\n  private createLogFn(\n    logMethod: (...args: any[]) => void,\n    level: LogLevel,\n  ): LogFn {\n    return <T extends object>(\n      objOrMsg: T | string,\n      msg?: string,\n      ...args: any[]\n    ): void => {\n      if (!this.shouldLog(level)) {\n        return;\n      }\n\n      const ts = Date.now();\n\n      // Handle simple string logging: logger.info('message')\n      if (typeof objOrMsg === 'string') {\n        const logData = { ...this.data, msg: objOrMsg, ts };\n        logMethod(logData, ...args);\n        return;\n      }\n\n      // Handle structured logging: logger.info({ data }, 'message')\n      const logData = msg\n        ? { ...this.data, ...objOrMsg, msg, ts }\n        : { ...this.data, ...objOrMsg, ts };\n      logMethod(logData, ...args);\n    };\n  }\n\n  /** Trace level logging function */\n  trace: LogFn = this.createLogFn(console.trace.bind(console), LogLevel.Trace);\n  /** Debug level logging function */\n  debug: LogFn = this.createLogFn(console.debug.bind(console), LogLevel.Debug);\n  /** Info level logging function */\n  info: LogFn = this.createLogFn(console.info.bind(console), LogLevel.Info);\n  /** Warning level logging function */\n  warn: LogFn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);\n  /** Error level logging function */\n  error: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Error);\n  /** Fatal level logging function (uses console.error) */\n  fatal: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Fatal);\n\n  /**\n   * Creates a child logger with additional context data.\n   * The child logger inherits all context from the parent and adds its own.\n   *\n   * @param obj - Additional context data for the child logger\n   * @returns A new ConsoleLogger instance with merged context\n   *\n   * @example\n   * ```typescript\n   * const parentLogger = new ConsoleLogger({ app: 'myApp' });\n   * const childLogger = parentLogger.child({ module: 'database' });\n   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');\n   * // Context includes both { app: 'myApp' } and { module: 'database' }\n   * ```\n   */\n  child(obj: object): Logger {\n    return new ConsoleLogger(\n      {\n        ...this.data,\n        ...obj,\n      },\n      this.level,\n    );\n  }\n}\n\n/**\n * @example Basic usage\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp' });\n * logger.info({ action: 'start' }, 'Application starting');\n * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }\n * ```\n *\n * @example Child logger usage\n * ```typescript\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ userId: 123 }, 'User authenticated');\n * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }\n * ```\n *\n * @example Error logging with context\n * ```typescript\n * try {\n *   await someOperation();\n * } catch (error) {\n *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');\n * }\n * ```\n */\n\nexport const DEFAULT_LOGGER = new ConsoleLogger() as any;\n\n/**\n * Creates a console logger with the same API as pino's createLogger.\n *\n * @param options - Logger configuration options\n * @returns A ConsoleLogger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@geekmidas/logger/console';\n * import { LogLevel } from '@geekmidas/logger';\n *\n * const logger = createLogger({ level: LogLevel.Debug });\n * logger.debug('This will be logged');\n * logger.trace('This will NOT be logged (below Debug level)');\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}): Logger {\n  return new ConsoleLogger({}, options.level ?? LogLevel.Info);\n}\n"],"mappings":";;;;;;AAMA,MAAMA,qBAA+C;EAClD,SAAS,QAAQ;EACjB,SAAS,QAAQ;EACjB,SAAS,OAAO;EAChB,SAAS,OAAO;EAChB,SAAS,QAAQ;EACjB,SAAS,QAAQ;EACjB,SAAS,SAAS;AACpB;AAED,IAAa,gBAAb,MAAa,cAAgC;CAC3C,AAAiB;;;;;;;CAQjB,YACWC,OAAe,CAAE,GAC1BC,QAAkB,SAAS,MAC3B;EAFS;AAGT,OAAK,QAAQ;CACd;;;;CAKD,AAAQ,UAAUA,OAA0B;AAC1C,MAAI,KAAK,UAAU,SAAS,OAC1B,QAAO;AAET,SAAO,mBAAmB,UAAU,mBAAmB,KAAK;CAC7D;;;;;;;;;CAUD,AAAQ,YACNC,WACAD,OACO;AACP,SAAO,CACLE,UACAC,KACA,GAAG,SACM;AACT,QAAK,KAAK,UAAU,MAAM,CACxB;GAGF,MAAM,KAAK,KAAK,KAAK;AAGrB,cAAW,aAAa,UAAU;IAChC,MAAMC,YAAU;KAAE,GAAG,KAAK;KAAM,KAAK;KAAU;IAAI;AACnD,cAAUA,WAAS,GAAG,KAAK;AAC3B;GACD;GAGD,MAAM,UAAU,MACZ;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;IAAK;GAAI,IACtC;IAAE,GAAG,KAAK;IAAM,GAAG;IAAU;GAAI;AACrC,aAAU,SAAS,GAAG,KAAK;EAC5B;CACF;;CAGD,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;CAE5E,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAE,SAAS,KAAK;;CAEzE,OAAc,KAAK,YAAY,QAAQ,KAAK,KAAK,QAAQ,EAAE,SAAS,KAAK;;CAEzE,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;CAE5E,QAAe,KAAK,YAAY,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,MAAM;;;;;;;;;;;;;;;;CAiB5E,MAAMC,KAAqB;AACzB,SAAO,IAAI,cACT;GACE,GAAG,KAAK;GACR,GAAG;EACJ,GACD,KAAK;CAER;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA2BD,MAAa,iBAAiB,IAAI;;;;;;;;;;;;;;;;;AAkBlC,SAAgB,aAAaC,UAA+B,CAAE,GAAU;AACtE,QAAO,IAAI,cAAc,CAAE,GAAE,QAAQ,SAAS,SAAS;AACxD"}

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { CreateLoggerOptions, LogFn, LogLevel, Logger, RedactOptions } from "./types-BFiJzL9N.mjs";
+import { CreateLoggerOptions, LogFn, LogLevel, Logger, RedactOptions } from "./types-Bga8WDuP.mjs";
 export { CreateLoggerOptions, LogFn, LogLevel, Logger, RedactOptions };

package/dist/pino.cjs

@@ -21,72 +21,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+const require_redact_paths = require('./redact-paths-D0m0DIuQ.cjs');
 const pino = __toESM(require("pino"));
 
 //#region src/pino.ts
 /**
-* Default sensitive field paths for redaction.
-*
-* These paths are automatically used when `redact: true` is set,
-* and merged with custom paths unless `resolution: 'override'` is specified.
-*
-* Includes:
-* - Authentication: password, token, apiKey, authorization, credentials
-* - Headers: authorization, cookie, x-api-key, x-auth-token
-* - Personal data: ssn, creditCard, cvv, pin
-* - Secrets: secret, connectionString, databaseUrl
-* - Wildcards: *.password, *.secret, *.token (catches nested fields)
-*/
-const DEFAULT_REDACT_PATHS = [
-	"password",
-	"pass",
-	"passwd",
-	"secret",
-	"token",
-	"accessToken",
-	"refreshToken",
-	"idToken",
-	"apiKey",
-	"api_key",
-	"apikey",
-	"auth",
-	"authorization",
-	"credential",
-	"credentials",
-	"*.password",
-	"*.secret",
-	"*.token",
-	"*.apiKey",
-	"*.api_key",
-	"*.authorization",
-	"*.accessToken",
-	"*.refreshToken",
-	"headers.authorization",
-	"headers.Authorization",
-	"headers[\"authorization\"]",
-	"headers[\"Authorization\"]",
-	"headers.cookie",
-	"headers.Cookie",
-	"headers[\"x-api-key\"]",
-	"headers[\"X-Api-Key\"]",
-	"headers[\"x-auth-token\"]",
-	"headers[\"X-Auth-Token\"]",
-	"ssn",
-	"socialSecurityNumber",
-	"social_security_number",
-	"creditCard",
-	"credit_card",
-	"cardNumber",
-	"card_number",
-	"cvv",
-	"cvc",
-	"pin",
-	"connectionString",
-	"connection_string",
-	"databaseUrl",
-	"database_url"
-];
-/**
 * Resolves redaction configuration from options.
 * Returns undefined if redaction is disabled, or a pino-compatible redact config.
 *
@@ -95,10 +34,10 @@ const DEFAULT_REDACT_PATHS = [
 */
 function resolveRedactConfig(redact) {
 	if (redact === void 0 || redact === false) return void 0;
-	if (redact === true) return DEFAULT_REDACT_PATHS;
-	if (Array.isArray(redact)) return [...DEFAULT_REDACT_PATHS, ...redact];
+	if (redact === true) return require_redact_paths.DEFAULT_REDACT_PATHS;
+	if (Array.isArray(redact)) return [...require_redact_paths.DEFAULT_REDACT_PATHS, ...redact];
 	const { resolution = "merge", paths, censor, remove } = redact;
-	const resolvedPaths = resolution === "override" ? paths : [...DEFAULT_REDACT_PATHS, ...paths];
+	const resolvedPaths = resolution === "override" ? paths : [...require_redact_paths.DEFAULT_REDACT_PATHS, ...paths];
 	const config = { paths: resolvedPaths };
 	if (censor !== void 0) config.censor = censor;
 	if (remove !== void 0) config.remove = remove;
@@ -145,6 +84,6 @@ function createLogger(options = {}) {
 }
 
 //#endregion
-exports.DEFAULT_REDACT_PATHS = DEFAULT_REDACT_PATHS;
+exports.DEFAULT_REDACT_PATHS = require_redact_paths.DEFAULT_REDACT_PATHS;
 exports.createLogger = createLogger;
 //# sourceMappingURL=pino.cjs.map

package/dist/pino.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"pino.cjs","names":["DEFAULT_REDACT_PATHS: string[]","redact: boolean | RedactOptions | undefined","config: PinoRedactConfig","options: CreateLoggerOptions"],"sources":["../src/pino.ts"],"sourcesContent":["/**\n * Pino logger with built-in redaction support for sensitive data.\n *\n * @example\n * ```typescript\n * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';\n *\n * // Enable redaction with sensible defaults\n * const logger = createLogger({ redact: true });\n *\n * // Sensitive data is automatically masked\n * logger.info({ password: 'secret123', user: 'john' }, 'Login');\n * // Output: { password: '[Redacted]', user: 'john' } Login\n *\n * // Add custom paths (merged with defaults)\n * const logger2 = createLogger({ redact: ['user.ssn'] });\n *\n * // Override defaults for full control\n * const logger3 = createLogger({\n *   redact: {\n *     paths: ['onlyThis'],\n *     resolution: 'override',\n *   }\n * });\n * ```\n *\n * @module\n */\nimport { pino } from 'pino';\nimport type { CreateLoggerOptions, RedactOptions } from './types';\n\n/**\n * Default sensitive field paths for redaction.\n *\n * These paths are automatically used when `redact: true` is set,\n * and merged with custom paths unless `resolution: 'override'` is specified.\n *\n * Includes:\n * - Authentication: password, token, apiKey, authorization, credentials\n * - Headers: authorization, cookie, x-api-key, x-auth-token\n * - Personal data: ssn, creditCard, cvv, pin\n * - Secrets: secret, connectionString, databaseUrl\n * - Wildcards: *.password, *.secret, *.token (catches nested fields)\n */\nexport const DEFAULT_REDACT_PATHS: string[] = [\n  // Authentication & authorization\n  'password',\n  'pass',\n  'passwd',\n  'secret',\n  'token',\n  'accessToken',\n  'refreshToken',\n  'idToken',\n  'apiKey',\n  'api_key',\n  'apikey',\n  'auth',\n  'authorization',\n  'credential',\n  'credentials',\n\n  // Common nested patterns (headers, body, etc.)\n  '*.password',\n  '*.secret',\n  '*.token',\n  '*.apiKey',\n  '*.api_key',\n  '*.authorization',\n  '*.accessToken',\n  '*.refreshToken',\n\n  // HTTP headers (case variations)\n  'headers.authorization',\n  'headers.Authorization',\n  'headers[\"authorization\"]',\n  'headers[\"Authorization\"]',\n  'headers.cookie',\n  'headers.Cookie',\n  'headers[\"x-api-key\"]',\n  'headers[\"X-Api-Key\"]',\n  'headers[\"x-auth-token\"]',\n  'headers[\"X-Auth-Token\"]',\n\n  // Common sensitive data fields\n  'ssn',\n  'socialSecurityNumber',\n  'social_security_number',\n  'creditCard',\n  'credit_card',\n  'cardNumber',\n  'card_number',\n  'cvv',\n  'cvc',\n  'pin',\n\n  // Database & connection strings\n  'connectionString',\n  'connection_string',\n  'databaseUrl',\n  'database_url',\n];\n\n/**\n * Type for the resolved pino redact config (without our custom resolution field).\n */\ntype PinoRedactConfig =\n  | string[]\n  | {\n      paths: string[];\n      censor?: string | ((value: unknown, path: string[]) => unknown);\n      remove?: boolean;\n    };\n\n/**\n * Resolves redaction configuration from options.\n * Returns undefined if redaction is disabled, or a pino-compatible redact config.\n *\n * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.\n * With resolution: 'override', only the custom paths are used.\n */\nfunction resolveRedactConfig(\n  redact: boolean | RedactOptions | undefined,\n): PinoRedactConfig | undefined {\n  if (redact === undefined || redact === false) {\n    return undefined;\n  }\n\n  if (redact === true) {\n    return DEFAULT_REDACT_PATHS;\n  }\n\n  // Array syntax - merge with defaults\n  if (Array.isArray(redact)) {\n    return [...DEFAULT_REDACT_PATHS, ...redact];\n  }\n\n  // Object syntax - check resolution mode\n  const { resolution = 'merge', paths, censor, remove } = redact;\n\n  const resolvedPaths =\n    resolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];\n\n  // Return clean pino config without our resolution field\n  const config: PinoRedactConfig = { paths: resolvedPaths };\n  if (censor !== undefined) config.censor = censor;\n  if (remove !== undefined) config.remove = remove;\n\n  return config;\n}\n\n/**\n * Creates a pino logger instance with optional redaction support.\n *\n * @param options - Logger configuration options\n * @returns A configured pino logger instance\n *\n * @example\n * ```typescript\n * // Basic logger\n * const logger = createLogger({ level: 'debug' });\n *\n * // With redaction enabled\n * const secureLogger = createLogger({ redact: true });\n *\n * // Pretty printing in development\n * const devLogger = createLogger({ pretty: true, redact: true });\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}) {\n  // @ts-ignore\n  const pretty = options?.pretty && process.NODE_ENV !== 'production';\n  const baseOptions = pretty\n    ? {\n        transport: {\n          target: 'pino-pretty',\n          options: { colorize: true },\n        },\n      }\n    : {};\n\n  const redact = resolveRedactConfig(options.redact);\n\n  return pino({\n    ...baseOptions,\n    ...(options.level && { level: options.level }),\n    ...(redact && { redact }),\n    formatters: {\n      bindings() {\n        return { nodeVersion: process.version };\n      },\n      level: (label) => {\n        return { level: label.toUpperCase() };\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAaA,uBAAiC;CAE5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;AACD;;;;;;;;AAoBD,SAAS,oBACPC,QAC8B;AAC9B,KAAI,qBAAwB,WAAW,MACrC;AAGF,KAAI,WAAW,KACb,QAAO;AAIT,KAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,CAAC,GAAG,sBAAsB,GAAG,MAAO;CAI7C,MAAM,EAAE,aAAa,SAAS,OAAO,QAAQ,QAAQ,GAAG;CAExD,MAAM,gBACJ,eAAe,aAAa,QAAQ,CAAC,GAAG,sBAAsB,GAAG,KAAM;CAGzE,MAAMC,SAA2B,EAAE,OAAO,cAAe;AACzD,KAAI,kBAAsB,QAAO,SAAS;AAC1C,KAAI,kBAAsB,QAAO,SAAS;AAE1C,QAAO;AACR;;;;;;;;;;;;;;;;;;;AAoBD,SAAgB,aAAaC,UAA+B,CAAE,GAAE;CAE9D,MAAM,SAAS,SAAS,UAAU,QAAQ,aAAa;CACvD,MAAM,cAAc,SAChB,EACE,WAAW;EACT,QAAQ;EACR,SAAS,EAAE,UAAU,KAAM;CAC5B,EACF,IACD,CAAE;CAEN,MAAM,SAAS,oBAAoB,QAAQ,OAAO;AAElD,QAAO,eAAK;EACV,GAAG;EACH,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,MAAO;EAC7C,GAAI,UAAU,EAAE,OAAQ;EACxB,YAAY;GACV,WAAW;AACT,WAAO,EAAE,aAAa,QAAQ,QAAS;GACxC;GACD,OAAO,CAAC,UAAU;AAChB,WAAO,EAAE,OAAO,MAAM,aAAa,CAAE;GACtC;EACF;CACF,EAAC;AACH"}
+{"version":3,"file":"pino.cjs","names":["redact: boolean | RedactOptions | undefined","DEFAULT_REDACT_PATHS","config: PinoRedactConfig","options: CreateLoggerOptions"],"sources":["../src/pino.ts"],"sourcesContent":["/**\n * Pino logger with built-in redaction support for sensitive data.\n *\n * @example\n * ```typescript\n * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';\n *\n * // Enable redaction with sensible defaults\n * const logger = createLogger({ redact: true });\n *\n * // Sensitive data is automatically masked\n * logger.info({ password: 'secret123', user: 'john' }, 'Login');\n * // Output: { password: '[Redacted]', user: 'john' } Login\n *\n * // Add custom paths (merged with defaults)\n * const logger2 = createLogger({ redact: ['user.ssn'] });\n *\n * // Override defaults for full control\n * const logger3 = createLogger({\n *   redact: {\n *     paths: ['onlyThis'],\n *     resolution: 'override',\n *   }\n * });\n * ```\n *\n * @module\n */\nimport { pino } from 'pino';\nimport { DEFAULT_REDACT_PATHS } from './redact-paths';\nimport type { CreateLoggerOptions, RedactOptions } from './types';\n\n// Re-export for backwards compatibility\nexport { DEFAULT_REDACT_PATHS } from './redact-paths';\n\n/**\n * Type for the resolved pino redact config (without our custom resolution field).\n */\ntype PinoRedactConfig =\n  | string[]\n  | {\n      paths: string[];\n      censor?: string | ((value: unknown, path: string[]) => unknown);\n      remove?: boolean;\n    };\n\n/**\n * Resolves redaction configuration from options.\n * Returns undefined if redaction is disabled, or a pino-compatible redact config.\n *\n * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.\n * With resolution: 'override', only the custom paths are used.\n */\nfunction resolveRedactConfig(\n  redact: boolean | RedactOptions | undefined,\n): PinoRedactConfig | undefined {\n  if (redact === undefined || redact === false) {\n    return undefined;\n  }\n\n  if (redact === true) {\n    return DEFAULT_REDACT_PATHS;\n  }\n\n  // Array syntax - merge with defaults\n  if (Array.isArray(redact)) {\n    return [...DEFAULT_REDACT_PATHS, ...redact];\n  }\n\n  // Object syntax - check resolution mode\n  const { resolution = 'merge', paths, censor, remove } = redact;\n\n  const resolvedPaths =\n    resolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];\n\n  // Return clean pino config without our resolution field\n  const config: PinoRedactConfig = { paths: resolvedPaths };\n  if (censor !== undefined) config.censor = censor;\n  if (remove !== undefined) config.remove = remove;\n\n  return config;\n}\n\n/**\n * Creates a pino logger instance with optional redaction support.\n *\n * @param options - Logger configuration options\n * @returns A configured pino logger instance\n *\n * @example\n * ```typescript\n * // Basic logger\n * const logger = createLogger({ level: 'debug' });\n *\n * // With redaction enabled\n * const secureLogger = createLogger({ redact: true });\n *\n * // Pretty printing in development\n * const devLogger = createLogger({ pretty: true, redact: true });\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}) {\n  // @ts-ignore\n  const pretty = options?.pretty && process.NODE_ENV !== 'production';\n  const baseOptions = pretty\n    ? {\n        transport: {\n          target: 'pino-pretty',\n          options: { colorize: true },\n        },\n      }\n    : {};\n\n  const redact = resolveRedactConfig(options.redact);\n\n  return pino({\n    ...baseOptions,\n    ...(options.level && { level: options.level }),\n    ...(redact && { redact }),\n    formatters: {\n      bindings() {\n        return { nodeVersion: process.version };\n      },\n      level: (label) => {\n        return { level: label.toUpperCase() };\n      },\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAS,oBACPA,QAC8B;AAC9B,KAAI,qBAAwB,WAAW,MACrC;AAGF,KAAI,WAAW,KACb,QAAOC;AAIT,KAAI,MAAM,QAAQ,OAAO,CACvB,QAAO,CAAC,GAAGA,2CAAsB,GAAG,MAAO;CAI7C,MAAM,EAAE,aAAa,SAAS,OAAO,QAAQ,QAAQ,GAAG;CAExD,MAAM,gBACJ,eAAe,aAAa,QAAQ,CAAC,GAAGA,2CAAsB,GAAG,KAAM;CAGzE,MAAMC,SAA2B,EAAE,OAAO,cAAe;AACzD,KAAI,kBAAsB,QAAO,SAAS;AAC1C,KAAI,kBAAsB,QAAO,SAAS;AAE1C,QAAO;AACR;;;;;;;;;;;;;;;;;;;AAoBD,SAAgB,aAAaC,UAA+B,CAAE,GAAE;CAE9D,MAAM,SAAS,SAAS,UAAU,QAAQ,aAAa;CACvD,MAAM,cAAc,SAChB,EACE,WAAW;EACT,QAAQ;EACR,SAAS,EAAE,UAAU,KAAM;CAC5B,EACF,IACD,CAAE;CAEN,MAAM,SAAS,oBAAoB,QAAQ,OAAO;AAElD,QAAO,eAAK;EACV,GAAG;EACH,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,MAAO;EAC7C,GAAI,UAAU,EAAE,OAAQ;EACxB,YAAY;GACV,WAAW;AACT,WAAO,EAAE,aAAa,QAAQ,QAAS;GACxC;GACD,OAAO,CAAC,UAAU;AAChB,WAAO,EAAE,OAAO,MAAM,aAAa,CAAE;GACtC;EACF;CACF,EAAC;AACH"}

package/dist/pino.d.cts

@@ -1,22 +1,9 @@
 import { CreateLoggerOptions } from "./types-JxCFymH0.cjs";
+import { DEFAULT_REDACT_PATHS } from "./redact-paths-Br-tI2GZ.cjs";
 import * as pino0 from "pino";
 
 //#region src/pino.d.ts
 
-/**
- * Default sensitive field paths for redaction.
- *
- * These paths are automatically used when `redact: true` is set,
- * and merged with custom paths unless `resolution: 'override'` is specified.
- *
- * Includes:
- * - Authentication: password, token, apiKey, authorization, credentials
- * - Headers: authorization, cookie, x-api-key, x-auth-token
- * - Personal data: ssn, creditCard, cvv, pin
- * - Secrets: secret, connectionString, databaseUrl
- * - Wildcards: *.password, *.secret, *.token (catches nested fields)
- */
-declare const DEFAULT_REDACT_PATHS: string[];
 /**
  * Creates a pino logger instance with optional redaction support.
  *