@geekmidas/logger 0.0.1

package/README.md

@@ -0,0 +1,315 @@
+# @geekmidas/logger
+
+A simple and flexible structured logging library for Node.js and browsers with child logger support and context inheritance.
+
+## Features
+
+- ✅ **Standard Interface**: Common logger interface with multiple log levels (debug, info, warn, error, fatal, trace)
+- ✅ **Structured Logging**: Support for both structured (object + message) and simple (message only) logging
+- ✅ **Child Loggers**: Create child loggers with inherited context
+- ✅ **Automatic Timestamps**: Automatic timestamp injection on all log entries
+- ✅ **Console-Based**: Built-in ConsoleLogger implementation using standard console methods
+- ✅ **TypeScript**: Full TypeScript support with type-safe logging
+- ✅ **Zero Dependencies**: No external dependencies
+
+## Installation
+
+```bash
+pnpm add @geekmidas/logger
+```
+
+## Quick Start
+
+```typescript
+import { ConsoleLogger } from '@geekmidas/logger';
+
+// Create logger with initial context
+const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
+
+// Structured logging
+logger.info({ userId: 123, action: 'login' }, 'User logged in');
+// Output: { app: 'myApp', version: '1.0.0', userId: 123, action: 'login', ts: 1234567890 } User logged in
+
+// Simple logging
+logger.info('Application started');
+// Output: { app: 'myApp', version: '1.0.0', ts: 1234567890 } Application started
+
+// Error logging
+logger.error({ error, operation: 'fetchUser' }, 'Failed to fetch user');
+```
+
+## API Reference
+
+### Logger Interface
+
+```typescript
+interface Logger {
+  debug: LogFn;
+  info: LogFn;
+  warn: LogFn;
+  error: LogFn;
+  fatal: LogFn;
+  trace: LogFn;
+  child: (obj: object) => Logger;
+}
+```
+
+### Log Levels
+
+- **trace** - Most detailed information
+- **debug** - Verbose information for debugging
+- **info** - General informational messages
+- **warn** - Potentially harmful situations
+- **error** - Error events that might still allow the application to continue
+- **fatal** - Severe errors that will likely cause the application to abort
+
+### ConsoleLogger
+
+```typescript
+class ConsoleLogger implements Logger {
+  constructor(data?: object)
+
+  debug: LogFn
+  info: LogFn
+  warn: LogFn
+  error: LogFn
+  fatal: LogFn
+  trace: LogFn
+  child(obj: object): Logger
+}
+```
+
+## Usage Examples
+
+### Basic Logging
+
+```typescript
+import { ConsoleLogger } from '@geekmidas/logger';
+
+const logger = new ConsoleLogger({ service: 'api', environment: 'production' });
+
+// Different log levels
+logger.trace('Entering function');
+logger.debug({ query: 'SELECT * FROM users' }, 'Executing query');
+logger.info({ requestId: 'abc123' }, 'Request received');
+logger.warn({ memoryUsage: '90%' }, 'High memory usage detected');
+logger.error({ error: new Error('Connection failed') }, 'Database error');
+logger.fatal({ exitCode: 1 }, 'Critical system failure');
+```
+
+### Structured Logging
+
+```typescript
+const logger = new ConsoleLogger({ app: 'myApp' });
+
+// Log with context object
+logger.info(
+  {
+    userId: 123,
+    action: 'purchase',
+    productId: 'prod_456',
+    amount: 29.99
+  },
+  'Purchase completed'
+);
+
+// Multiple additional arguments
+logger.info(
+  { traceId: 'trace_123' },
+  'Request processed in %dms',
+  150
+);
+```
+
+### Child Loggers
+
+Child loggers inherit all context from their parent and add their own:
+
+```typescript
+const parentLogger = new ConsoleLogger({
+  app: 'myApp',
+  environment: 'production'
+});
+
+// Create child logger for authentication module
+const authLogger = parentLogger.child({ module: 'auth' });
+authLogger.info({ userId: 123 }, 'User authenticated');
+// Output: { app: 'myApp', environment: 'production', module: 'auth', userId: 123, ts: ... }
+
+// Create child logger for database module
+const dbLogger = parentLogger.child({ module: 'database' });
+dbLogger.debug({ query: 'SELECT ...' }, 'Query executed');
+// Output: { app: 'myApp', environment: 'production', module: 'database', query: 'SELECT ...', ts: ... }
+
+// Child loggers can be nested
+const userDbLogger = dbLogger.child({ table: 'users' });
+userDbLogger.info({ rowsAffected: 1 }, 'Record inserted');
+// Output: { app: 'myApp', environment: 'production', module: 'database', table: 'users', rowsAffected: 1, ts: ... }
+```
+
+### Request Context Pattern
+
+```typescript
+import type { Logger } from '@geekmidas/logger';
+
+function handleRequest(logger: Logger, requestId: string) {
+  // Create request-scoped logger
+  const requestLogger = logger.child({ requestId });
+
+  requestLogger.info('Processing request');
+
+  try {
+    processPayment(requestLogger);
+    requestLogger.info('Request completed');
+  } catch (error) {
+    requestLogger.error({ error }, 'Request failed');
+  }
+}
+
+function processPayment(logger: Logger) {
+  const paymentLogger = logger.child({ operation: 'payment' });
+  paymentLogger.debug({ amount: 100 }, 'Processing payment');
+  // All context is preserved: { requestId, operation, amount, ts }
+}
+```
+
+### Integration with Services
+
+```typescript
+class UserService {
+  private logger: Logger;
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ service: 'UserService' });
+  }
+
+  async createUser(data: UserData) {
+    this.logger.info({ email: data.email }, 'Creating user');
+
+    try {
+      const user = await this.db.insert(data);
+      this.logger.info({ userId: user.id }, 'User created successfully');
+      return user;
+    } catch (error) {
+      this.logger.error({ error, email: data.email }, 'Failed to create user');
+      throw error;
+    }
+  }
+
+  async deleteUser(userId: string) {
+    const logger = this.logger.child({ userId, operation: 'delete' });
+
+    logger.info('Deleting user');
+    await this.db.delete(userId);
+    logger.info('User deleted');
+  }
+}
+```
+
+## Custom Logger Implementation
+
+You can implement the `Logger` interface for custom logging backends:
+
+```typescript
+import type { Logger, LogFn } from '@geekmidas/logger';
+
+class CustomLogger implements Logger {
+  constructor(private context: object = {}) {}
+
+  private createLogFn(level: string): LogFn {
+    return (obj: any, msg?: string, ...args: any[]) => {
+      // Your custom logging implementation
+      const logEntry = {
+        level,
+        ...this.context,
+        ...obj,
+        timestamp: new Date().toISOString(),
+        message: msg
+      };
+
+      // Send to your logging service
+      yourLoggingService.send(logEntry);
+    };
+  }
+
+  debug: LogFn = this.createLogFn('debug');
+  info: LogFn = this.createLogFn('info');
+  warn: LogFn = this.createLogFn('warn');
+  error: LogFn = this.createLogFn('error');
+  fatal: LogFn = this.createLogFn('fatal');
+  trace: LogFn = this.createLogFn('trace');
+
+  child(obj: object): Logger {
+    return new CustomLogger({ ...this.context, ...obj });
+  }
+}
+```
+
+## TypeScript Support
+
+The library is written in TypeScript and provides full type definitions:
+
+```typescript
+import type { Logger, LogFn } from '@geekmidas/logger';
+
+// Use Logger type for dependency injection
+function createService(logger: Logger) {
+  return {
+    doWork() {
+      logger.info('Working...');
+    }
+  };
+}
+
+// LogFn type for custom implementations
+const customLog: LogFn = (obj, msg) => {
+  console.log(obj, msg);
+};
+```
+
+## Best Practices
+
+1. **Create Base Logger Early**: Initialize your base logger at application startup with static context
+   ```typescript
+   const baseLogger = new ConsoleLogger({
+     app: 'myApp',
+     version: process.env.APP_VERSION,
+     environment: process.env.NODE_ENV
+   });
+   ```
+
+2. **Use Child Loggers**: Create child loggers for different modules/contexts rather than passing context repeatedly
+   ```typescript
+   const authLogger = baseLogger.child({ module: 'auth' });
+   const dbLogger = baseLogger.child({ module: 'db' });
+   ```
+
+3. **Structured Over String**: Prefer structured logging with context objects over string concatenation
+   ```typescript
+   // Good
+   logger.info({ userId, action: 'login', ip }, 'User logged in');
+
+   // Avoid
+   logger.info(`User ${userId} logged in from ${ip}`);
+   ```
+
+4. **Include Context**: Add relevant context to make logs searchable and debuggable
+   ```typescript
+   logger.error({
+     error: err,
+     userId,
+     requestId,
+     operation: 'fetchUser'
+   }, 'Operation failed');
+   ```
+
+5. **Dependency Injection**: Pass logger as dependency rather than importing globally
+   ```typescript
+   class MyService {
+     constructor(private logger: Logger) {}
+   }
+   ```
+
+## License
+
+MIT

package/dist/console.cjs

@@ -0,0 +1,94 @@
+
+//#region src/console.ts
+var ConsoleLogger = class ConsoleLogger {
+	/**
+	* Creates a new ConsoleLogger instance.
+	*
+	* @param data - Initial context data to include in all log messages
+	*/
+	constructor(data = {}) {
+		this.data = data;
+	}
+	/**
+	* Creates a logging function that merges context data and adds timestamps.
+	*
+	* @param logMethod - The console method to use (e.g., console.log, console.error)
+	* @returns A LogFn that handles both structured and simple logging
+	* @private
+	*/
+	createLogFn(logMethod) {
+		return (obj, msg, ...args) => {
+			const ts = Date.now();
+			const mergedData = {
+				...this.data,
+				...obj,
+				ts
+			};
+			if (msg) logMethod(mergedData, msg, ...args);
+			else logMethod(mergedData, ...args);
+		};
+	}
+	/** Debug level logging function */
+	debug = this.createLogFn(console.debug.bind(console));
+	/** Info level logging function */
+	info = this.createLogFn(console.info.bind(console));
+	/** Warning level logging function */
+	warn = this.createLogFn(console.warn.bind(console));
+	/** Error level logging function */
+	error = this.createLogFn(console.error.bind(console));
+	/** 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));
+	/**
+	* Creates a child logger with additional context data.
+	* The child logger inherits all context from the parent and adds its own.
+	*
+	* @param obj - Additional context data for the child logger
+	* @returns A new ConsoleLogger instance with merged context
+	*
+	* @example
+	* ```typescript
+	* const parentLogger = new ConsoleLogger({ app: 'myApp' });
+	* const childLogger = parentLogger.child({ module: 'database' });
+	* childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');
+	* // Context includes both { app: 'myApp' } and { module: 'database' }
+	* ```
+	*/
+	child(obj) {
+		return new ConsoleLogger({
+			...this.data,
+			...obj
+		});
+	}
+};
+/**
+* @example Basic usage
+* ```typescript
+* const logger = new ConsoleLogger({ app: 'myApp' });
+* logger.info({ action: 'start' }, 'Application starting');
+* // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+* ```
+*
+* @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
+* ```
+*
+* @example Error logging with context
+* ```typescript
+* try {
+*   await someOperation();
+* } catch (error) {
+*   logger.error({ error, operation: 'someOperation' }, 'Operation failed');
+* }
+* ```
+*/
+const DEFAULT_LOGGER = new ConsoleLogger();
+
+//#endregion
+exports.ConsoleLogger = ConsoleLogger;
+exports.DEFAULT_LOGGER = DEFAULT_LOGGER;
+//# sourceMappingURL=console.cjs.map

package/dist/console.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.cjs","names":["data: object","logMethod: (...args: any[]) => void","obj: T","msg?: string","obj: object"],"sources":["../src/console.ts"],"sourcesContent":["import type { 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>(obj: T, msg?: string, ...args: any[]): void => {\n      // Merge the logger's context data with the provided object\n      const ts = Date.now();\n      const mergedData = { ...this.data, ...obj, ts };\n\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"],"mappings":";;AAEA,IAAa,gBAAb,MAAa,cAAgC;;;;;;CAM3C,YAAqBA,OAAe,CAAE,GAAE;EAAnB;CAAqB;;;;;;;;CAS1C,AAAQ,YAAYC,WAA4C;AAC9D,SAAO,CAAmBC,KAAQC,KAAc,GAAG,SAAsB;GAEvE,MAAM,KAAK,KAAK,KAAK;GACrB,MAAM,aAAa;IAAE,GAAG,KAAK;IAAM,GAAG;IAAK;GAAI;AAE/C,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"}

package/dist/console.d.cts

@@ -0,0 +1,76 @@
+import { LogFn, Logger } from "./types-DXdmn7h5.cjs";
+
+//#region src/console.d.ts
+declare class ConsoleLogger implements Logger {
+  readonly data: object;
+  /**
+   * Creates a new ConsoleLogger instance.
+   *
+   * @param data - Initial context data to include in all log messages
+   */
+  constructor(data?: object);
+  /**
+   * Creates a logging function that merges context data and adds timestamps.
+   *
+   * @param logMethod - The console method to use (e.g., console.log, console.error)
+   * @returns A LogFn that handles both structured and simple logging
+   * @private
+   */
+  private createLogFn;
+  /** Debug level logging function */
+  debug: LogFn;
+  /** Info level logging function */
+  info: LogFn;
+  /** Warning level logging function */
+  warn: LogFn;
+  /** Error level logging function */
+  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.
+   *
+   * @param obj - Additional context data for the child logger
+   * @returns A new ConsoleLogger instance with merged context
+   *
+   * @example
+   * ```typescript
+   * const parentLogger = new ConsoleLogger({ app: 'myApp' });
+   * const childLogger = parentLogger.child({ module: 'database' });
+   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');
+   * // Context includes both { app: 'myApp' } and { module: 'database' }
+   * ```
+   */
+  child(obj: object): Logger;
+}
+/**
+ * @example Basic usage
+ * ```typescript
+ * const logger = new ConsoleLogger({ app: 'myApp' });
+ * logger.info({ action: 'start' }, 'Application starting');
+ * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+ * ```
+ *
+ * @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
+ * ```
+ *
+ * @example Error logging with context
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');
+ * }
+ * ```
+ */
+declare const DEFAULT_LOGGER: any;
+//#endregion
+export { ConsoleLogger, DEFAULT_LOGGER };
+//# sourceMappingURL=console.d.cts.map

package/dist/console.d.mts

@@ -0,0 +1,76 @@
+import { LogFn, Logger } from "./types-C1RfRbo6.mjs";
+
+//#region src/console.d.ts
+declare class ConsoleLogger implements Logger {
+  readonly data: object;
+  /**
+   * Creates a new ConsoleLogger instance.
+   *
+   * @param data - Initial context data to include in all log messages
+   */
+  constructor(data?: object);
+  /**
+   * Creates a logging function that merges context data and adds timestamps.
+   *
+   * @param logMethod - The console method to use (e.g., console.log, console.error)
+   * @returns A LogFn that handles both structured and simple logging
+   * @private
+   */
+  private createLogFn;
+  /** Debug level logging function */
+  debug: LogFn;
+  /** Info level logging function */
+  info: LogFn;
+  /** Warning level logging function */
+  warn: LogFn;
+  /** Error level logging function */
+  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.
+   *
+   * @param obj - Additional context data for the child logger
+   * @returns A new ConsoleLogger instance with merged context
+   *
+   * @example
+   * ```typescript
+   * const parentLogger = new ConsoleLogger({ app: 'myApp' });
+   * const childLogger = parentLogger.child({ module: 'database' });
+   * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');
+   * // Context includes both { app: 'myApp' } and { module: 'database' }
+   * ```
+   */
+  child(obj: object): Logger;
+}
+/**
+ * @example Basic usage
+ * ```typescript
+ * const logger = new ConsoleLogger({ app: 'myApp' });
+ * logger.info({ action: 'start' }, 'Application starting');
+ * // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+ * ```
+ *
+ * @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
+ * ```
+ *
+ * @example Error logging with context
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');
+ * }
+ * ```
+ */
+declare const DEFAULT_LOGGER: any;
+//#endregion
+export { ConsoleLogger, DEFAULT_LOGGER };
+//# sourceMappingURL=console.d.mts.map

package/dist/console.mjs

@@ -0,0 +1,92 @@
+//#region src/console.ts
+var ConsoleLogger = class ConsoleLogger {
+	/**
+	* Creates a new ConsoleLogger instance.
+	*
+	* @param data - Initial context data to include in all log messages
+	*/
+	constructor(data = {}) {
+		this.data = data;
+	}
+	/**
+	* Creates a logging function that merges context data and adds timestamps.
+	*
+	* @param logMethod - The console method to use (e.g., console.log, console.error)
+	* @returns A LogFn that handles both structured and simple logging
+	* @private
+	*/
+	createLogFn(logMethod) {
+		return (obj, msg, ...args) => {
+			const ts = Date.now();
+			const mergedData = {
+				...this.data,
+				...obj,
+				ts
+			};
+			if (msg) logMethod(mergedData, msg, ...args);
+			else logMethod(mergedData, ...args);
+		};
+	}
+	/** Debug level logging function */
+	debug = this.createLogFn(console.debug.bind(console));
+	/** Info level logging function */
+	info = this.createLogFn(console.info.bind(console));
+	/** Warning level logging function */
+	warn = this.createLogFn(console.warn.bind(console));
+	/** Error level logging function */
+	error = this.createLogFn(console.error.bind(console));
+	/** 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));
+	/**
+	* Creates a child logger with additional context data.
+	* The child logger inherits all context from the parent and adds its own.
+	*
+	* @param obj - Additional context data for the child logger
+	* @returns A new ConsoleLogger instance with merged context
+	*
+	* @example
+	* ```typescript
+	* const parentLogger = new ConsoleLogger({ app: 'myApp' });
+	* const childLogger = parentLogger.child({ module: 'database' });
+	* childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');
+	* // Context includes both { app: 'myApp' } and { module: 'database' }
+	* ```
+	*/
+	child(obj) {
+		return new ConsoleLogger({
+			...this.data,
+			...obj
+		});
+	}
+};
+/**
+* @example Basic usage
+* ```typescript
+* const logger = new ConsoleLogger({ app: 'myApp' });
+* logger.info({ action: 'start' }, 'Application starting');
+* // Logs: { app: 'myApp', action: 'start', ts: 1234567890 } Application starting
+* ```
+*
+* @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
+* ```
+*
+* @example Error logging with context
+* ```typescript
+* try {
+*   await someOperation();
+* } catch (error) {
+*   logger.error({ error, operation: 'someOperation' }, 'Operation failed');
+* }
+* ```
+*/
+const DEFAULT_LOGGER = new ConsoleLogger();
+
+//#endregion
+export { ConsoleLogger, DEFAULT_LOGGER };
+//# sourceMappingURL=console.mjs.map

package/dist/console.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.mjs","names":["data: object","logMethod: (...args: any[]) => void","obj: T","msg?: string","obj: object"],"sources":["../src/console.ts"],"sourcesContent":["import type { 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>(obj: T, msg?: string, ...args: any[]): void => {\n      // Merge the logger's context data with the provided object\n      const ts = Date.now();\n      const mergedData = { ...this.data, ...obj, ts };\n\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"],"mappings":";AAEA,IAAa,gBAAb,MAAa,cAAgC;;;;;;CAM3C,YAAqBA,OAAe,CAAE,GAAE;EAAnB;CAAqB;;;;;;;;CAS1C,AAAQ,YAAYC,WAA4C;AAC9D,SAAO,CAAmBC,KAAQC,KAAc,GAAG,SAAsB;GAEvE,MAAM,KAAK,KAAK,KAAK;GACrB,MAAM,aAAa;IAAE,GAAG,KAAK;IAAM,GAAG;IAAK;GAAI;AAE/C,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"}

package/dist/index.cjs

@@ -0,0 +1,3 @@
+const require_types = require('./types-ag_0Cvbg.cjs');
+
+exports.LogLevel = require_types.LogLevel;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import { CreateLoggerOptions, LogFn, LogLevel, Logger } from "./types-DXdmn7h5.cjs";
+export { CreateLoggerOptions, LogFn, LogLevel, Logger };

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { LogLevel } from "./types-yQ6XOihF.mjs";
+
+export { LogLevel };