@geekmidas/logger 9.0.2 → 10.0.0-alpha.0

package/src/console.ts

@@ -1,165 +0,0 @@
-import type { CreateLoggerOptions, LogFn, Logger } from './types';
-import { LogLevel } from './types';
-
-/**
- * Numeric priority for log levels (higher = more severe)
- */
-const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
-	[LogLevel.Trace]: 10,
-	[LogLevel.Debug]: 20,
-	[LogLevel.Info]: 30,
-	[LogLevel.Warn]: 40,
-	[LogLevel.Error]: 50,
-	[LogLevel.Fatal]: 60,
-	[LogLevel.Silent]: 70,
-};
-
-export class ConsoleLogger implements Logger {
-	private readonly level: LogLevel;
-
-	/**
-	 * 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(
-		readonly data: object = {},
-		level: LogLevel = LogLevel.Info,
-	) {
-		this.level = level;
-	}
-
-	/**
-	 * Checks if a log level should be output based on the configured minimum level.
-	 */
-	private shouldLog(level: LogLevel): boolean {
-		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
-	 */
-	private createLogFn(
-		logMethod: (...args: any[]) => void,
-		level: LogLevel,
-	): LogFn {
-		return <T extends object>(
-			objOrMsg: T | string,
-			msg?: string,
-			...args: any[]
-		): void => {
-			if (!this.shouldLog(level)) {
-				return;
-			}
-
-			const ts = Date.now();
-
-			// Handle simple string logging: logger.info('message')
-			if (typeof objOrMsg === 'string') {
-				const logData = { ...this.data, msg: objOrMsg, ts };
-				logMethod(logData, ...args);
-				return;
-			}
-
-			// Handle structured logging: logger.info({ data }, 'message')
-			const logData = msg
-				? { ...this.data, ...objOrMsg, msg, ts }
-				: { ...this.data, ...objOrMsg, ts };
-			logMethod(logData, ...args);
-		};
-	}
-
-	/** Trace level logging function */
-	trace: LogFn = this.createLogFn(console.trace.bind(console), LogLevel.Trace);
-	/** Debug level logging function */
-	debug: LogFn = this.createLogFn(console.debug.bind(console), LogLevel.Debug);
-	/** Info level logging function */
-	info: LogFn = this.createLogFn(console.info.bind(console), LogLevel.Info);
-	/** Warning level logging function */
-	warn: LogFn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);
-	/** Error level logging function */
-	error: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Error);
-	/** Fatal level logging function (uses console.error) */
-	fatal: LogFn = 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.
-	 *
-	 * @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 {
-		return new ConsoleLogger(
-			{
-				...this.data,
-				...obj,
-			},
-			this.level,
-		);
-	}
-}
-
-/**
- * @example Basic usage
- * ```typescript
- * const logger = new ConsoleLogger({ app: 'myApp' });
- * logger.info({ action: 'start' }, '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, msg: 'User authenticated', ts: 1234567891 }
- * ```
- *
- * @example Error logging with context
- * ```typescript
- * try {
- *   await someOperation();
- * } catch (error) {
- *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');
- * }
- * ```
- */
-
-export const DEFAULT_LOGGER = new ConsoleLogger() as any;
-
-/**
- * Creates a console logger with the same API as pino's createLogger.
- *
- * @param options - Logger configuration options
- * @returns A ConsoleLogger instance
- *
- * @example
- * ```typescript
- * import { createLogger } from '@geekmidas/logger/console';
- * import { LogLevel } from '@geekmidas/logger';
- *
- * const logger = createLogger({ level: LogLevel.Debug });
- * logger.debug('This will be logged');
- * logger.trace('This will NOT be logged (below Debug level)');
- * ```
- */
-export function createLogger(options: CreateLoggerOptions = {}): Logger {
-	return new ConsoleLogger({}, options.level ?? LogLevel.Info);
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export {
-	type CreateLoggerOptions,
-	type LogFn,
-	type Logger,
-	LogLevel,
-	type RedactOptions,
-} from './types';

package/src/pino.ts

@@ -1,129 +0,0 @@
-/**
- * Pino logger with built-in redaction support for sensitive data.
- *
- * @example
- * ```typescript
- * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';
- *
- * // Enable redaction with sensible defaults
- * const logger = createLogger({ redact: true });
- *
- * // Sensitive data is automatically masked
- * logger.info({ password: 'secret123', user: 'john' }, 'Login');
- * // Output: { password: '[Redacted]', user: 'john' } Login
- *
- * // Add custom paths (merged with defaults)
- * const logger2 = createLogger({ redact: ['user.ssn'] });
- *
- * // Override defaults for full control
- * const logger3 = createLogger({
- *   redact: {
- *     paths: ['onlyThis'],
- *     resolution: 'override',
- *   }
- * });
- * ```
- *
- * @module
- */
-import { pino } from 'pino';
-import { DEFAULT_REDACT_PATHS } from './redact-paths';
-import type { CreateLoggerOptions, RedactOptions } from './types';
-
-// Re-export for backwards compatibility
-export { DEFAULT_REDACT_PATHS } from './redact-paths';
-
-/**
- * Type for the resolved pino redact config (without our custom resolution field).
- */
-type PinoRedactConfig =
-	| string[]
-	| {
-			paths: string[];
-			censor?: string | ((value: unknown, path: string[]) => unknown);
-			remove?: boolean;
-	  };
-
-/**
- * Resolves redaction configuration from options.
- * Returns undefined if redaction is disabled, or a pino-compatible redact config.
- *
- * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.
- * With resolution: 'override', only the custom paths are used.
- */
-function resolveRedactConfig(
-	redact: boolean | RedactOptions | undefined,
-): PinoRedactConfig | undefined {
-	if (redact === undefined || redact === false) {
-		return undefined;
-	}
-
-	if (redact === true) {
-		return DEFAULT_REDACT_PATHS;
-	}
-
-	// Array syntax - merge with defaults
-	if (Array.isArray(redact)) {
-		return [...DEFAULT_REDACT_PATHS, ...redact];
-	}
-
-	// Object syntax - check resolution mode
-	const { resolution = 'merge', paths, censor, remove } = redact;
-
-	const resolvedPaths =
-		resolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];
-
-	// Return clean pino config without our resolution field
-	const config: PinoRedactConfig = { paths: resolvedPaths };
-	if (censor !== undefined) config.censor = censor;
-	if (remove !== undefined) config.remove = remove;
-
-	return config;
-}
-
-/**
- * Creates a pino logger instance with optional redaction support.
- *
- * @param options - Logger configuration options
- * @returns A configured pino logger instance
- *
- * @example
- * ```typescript
- * // Basic logger
- * const logger = createLogger({ level: 'debug' });
- *
- * // With redaction enabled
- * const secureLogger = createLogger({ redact: true });
- *
- * // Pretty printing in development
- * const devLogger = createLogger({ pretty: true, redact: true });
- * ```
- */
-export function createLogger(options: CreateLoggerOptions = {}) {
-	// @ts-expect-error
-	const pretty = options?.pretty && process.NODE_ENV !== 'production';
-	const baseOptions = pretty
-		? {
-				transport: {
-					target: 'pino-pretty',
-					options: { colorize: true },
-				},
-			}
-		: {};
-
-	const redact = resolveRedactConfig(options.redact);
-
-	return pino({
-		...baseOptions,
-		...(options.level && { level: options.level }),
-		...(redact && { redact }),
-		formatters: {
-			bindings() {
-				return { nodeVersion: process.version };
-			},
-			level: (label) => {
-				return { level: label.toUpperCase() };
-			},
-		},
-	});
-}

package/src/redact-paths.ts

@@ -1,71 +0,0 @@
-/**
- * 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)
- */
-export const DEFAULT_REDACT_PATHS: string[] = [
-	// Authentication & authorization
-	'password',
-	'pass',
-	'passwd',
-	'secret',
-	'token',
-	'accessToken',
-	'refreshToken',
-	'idToken',
-	'apiKey',
-	'api_key',
-	'apikey',
-	'auth',
-	'authorization',
-	'credential',
-	'credentials',
-
-	// Common nested patterns (headers, body, etc.)
-	'*.password',
-	'*.secret',
-	'*.token',
-	'*.apiKey',
-	'*.api_key',
-	'*.authorization',
-	'*.accessToken',
-	'*.refreshToken',
-
-	// HTTP headers (case variations)
-	'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"]',
-
-	// Common sensitive data fields
-	'ssn',
-	'socialSecurityNumber',
-	'social_security_number',
-	'creditCard',
-	'credit_card',
-	'cardNumber',
-	'card_number',
-	'cvv',
-	'cvc',
-	'pin',
-
-	// Database & connection strings
-	'connectionString',
-	'connection_string',
-	'databaseUrl',
-	'database_url',
-];

package/src/types.ts

@@ -1,167 +0,0 @@
-/**
- * Logging function type that supports both structured and simple logging.
- * Can be called with an object for structured logging or just a message string.
- *
- * @example
- * ```typescript
- * // Structured logging with context object
- * logger.info({ userId: 123, action: 'login' }, 'User logged in');
- *
- * // Simple string logging
- * logger.info('Application started');
- * ```
- */
-export type LogFn = {
-	/** Structured logging with context object, optional message, and additional arguments */
-	<T extends object>(obj: T, msg?: string, ...args: any[]): void;
-	/** Simple string logging */
-	(msg: string): void;
-};
-
-/**
- * Standard logger interface with multiple log levels and child logger support.
- * Follows common logging patterns with structured logging capabilities.
- *
- * @interface Logger
- */
-export interface Logger {
-	/** Debug level logging - verbose information for debugging */
-	debug: LogFn;
-	/** Info level logging - general informational messages */
-	info: LogFn;
-	/** Warning level logging - potentially harmful situations */
-	warn: LogFn;
-	/** Error level logging - error events that might still allow the application to continue */
-	error: LogFn;
-	/** Fatal level logging - severe errors that will likely cause the application to abort */
-	fatal: LogFn;
-	/** Trace level logging - most detailed information */
-	trace: LogFn;
-	/**
-	 * Creates a child logger with additional context.
-	 * Child loggers inherit parent context and add their own.
-	 *
-	 * @param obj - Additional context to include in all child logger calls
-	 * @returns A new Logger instance with merged context
-	 */
-	child: (obj: object) => Logger;
-}
-
-/**
- * Console-based logger implementation that outputs to standard console methods.
- * Supports structured logging with automatic timestamp injection and context inheritance.
- *
- * @implements {Logger}
- *
- * @example
- * ```typescript
- * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
- * logger.info({ userId: 123 }, 'User action performed');
- * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed
- *
- * const childLogger = logger.child({ module: 'auth' });
- * childLogger.debug({ action: 'validate' }, 'Validating token');
- * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token
- * ```
- */
-export enum LogLevel {
-	Trace = 'trace',
-	Debug = 'debug',
-	Info = 'info',
-	Warn = 'warn',
-	Error = 'error',
-	Fatal = 'fatal',
-	Silent = 'silent',
-}
-
-/**
- * Redaction configuration for masking sensitive data in logs.
- * Uses pino's fast-redact library under the hood.
- *
- * By default, custom paths are merged with the default sensitive paths.
- * Use `resolution: 'override'` to use only your custom paths.
- *
- * @example
- * ```typescript
- * // Simple path array (merges with defaults)
- * redact: ['user.ssn', 'custom.field']
- *
- * // Override defaults completely
- * redact: {
- *   paths: ['only.these.paths'],
- *   resolution: 'override',
- * }
- *
- * // With custom censor
- * redact: {
- *   paths: ['extra.secret'],
- *   censor: '***',
- * }
- *
- * // Remove fields entirely
- * redact: {
- *   paths: ['temporary.data'],
- *   remove: true,
- * }
- * ```
- */
-export type RedactOptions =
-	| string[]
-	| {
-			/** Paths to redact using dot notation or bracket notation for special chars */
-			paths: string[];
-			/** Custom replacement text (default: '[REDACTED]') */
-			censor?: string | ((value: unknown, path: string[]) => unknown);
-			/** Remove the field entirely instead of replacing (default: false) */
-			remove?: boolean;
-			/**
-			 * How to combine custom paths with default sensitive paths.
-			 * - 'merge': Custom paths are added to default paths (default)
-			 * - 'override': Only custom paths are used, defaults are ignored
-			 */
-			resolution?: 'merge' | 'override';
-	  };
-
-export type CreateLoggerOptions = {
-	/** Enable pretty printing with colors (disabled in production) */
-	pretty?: boolean;
-	/** Minimum log level to output */
-	level?: LogLevel;
-	/**
-	 * Redaction configuration for masking sensitive data.
-	 *
-	 * - `true`: Uses default sensitive paths (password, token, secret, etc.)
-	 * - `false` or `undefined`: No redaction applied
-	 * - `string[]`: Custom paths merged with defaults
-	 * - `object`: Advanced config with paths, censor, remove, and resolution options
-	 *
-	 * By default, custom paths are **merged** with the default sensitive paths.
-	 * Use `resolution: 'override'` to disable defaults and use only your paths.
-	 *
-	 * @example
-	 * ```typescript
-	 * // Use defaults only
-	 * createLogger({ redact: true });
-	 *
-	 * // Add custom paths (merged with defaults)
-	 * createLogger({ redact: ['user.ssn', 'custom.field'] });
-	 *
-	 * // Override defaults completely
-	 * createLogger({
-	 *   redact: {
-	 *     paths: ['only.these.paths'],
-	 *     resolution: 'override',
-	 *   }
-	 * });
-	 *
-	 * // Merge with custom censor
-	 * createLogger({
-	 *   redact: {
-	 *     paths: ['extra.secret'],
-	 *     censor: '***',
-	 *   }
-	 * });
-	 * ```
-	 */
-	redact?: boolean | RedactOptions;
-};

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "composite": true
-  },
-  "include": ["src/**/*"]
-}

package/tsdown.config.ts

@@ -1,3 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({});