logixia 1.13.3 → 2.0.4

package/dist/nest.d.ts

@@ -1,11 +1,463 @@
-import "./transport.types-DqVLZTyf.js";
-import { E as TraceIdConfig } from "./index-nZEeCr3X.js";
-import { _ as LogixiaServiceWithLevels, a as LogixiaExceptionFilter, c as LOGIXIA_LOGGER_PREFIX, d as LogixiaLoggerModule, f as LogixiaOptionsFactory, g as LogixiaServiceWith, h as LogixiaLoggerService, m as KafkaTraceInterceptor, n as LOGIXIA_EXCEPTION_FILTER_OPTIONS, o as LogixiaExceptionFilterOptions, p as WebSocketTraceInterceptor, s as LOGIXIA_LOGGER_CONFIG, u as LogixiaAsyncOptions } from "./nestjs-extras-mKrHE9S6.js";
-import { NestMiddleware } from "@nestjs/common";
+import { E as TraceIdConfig, v as LogLevelString, y as LoggerConfig } from "./index-DwozbmB4.js";
+import { t as LogixiaLogger } from "./logitron-logger-D2B75Oc7.js";
+import { ArgumentsHost, CallHandler, ExceptionFilter, ExecutionContext, InjectionToken, LoggerService, MiddlewareConsumer, ModuleMetadata, NestInterceptor, NestMiddleware, NestModule, OptionalFactoryDependency, Type } from "@nestjs/common";
+import { Observable } from "rxjs";
 import { NextFunction, Request, Response } from "express";
-
-//#region src/core/trace.middleware.d.ts
-
+/**
+ * Level names that already have proper typed implementations on LogixiaLoggerService.
+ * These are excluded from the auto-generated method type so we don't produce
+ * duplicate / conflicting signatures.
+ */
+type _ServiceBuiltinLevels = 'error' | 'warn' | 'info' | 'debug' | 'verbose' | 'trace' | 'log' | 'logLevel';
+/**
+ * Mapped type that adds one method per *custom* level (i.e. every key in TLevels
+ * that is not already a built-in method on LogixiaLoggerService).
+ *
+ * @example
+ * ServiceCustomLevelMethods<{ kafka: 3; mysql: 4; payment: 5 }>
+ * // → { kafka(msg, data?): Promise<void>; mysql(...): …; payment(...): … }
+ */
+type ServiceCustomLevelMethods<TLevels extends Record<string, number>> = { readonly [K in keyof TLevels as K extends _ServiceBuiltinLevels ? never : K & string]: (message: string, data?: Record<string, unknown>) => Promise<void>; };
+/**
+ * The return type of `LogixiaLoggerService.create<T>(config)`.
+ *
+ * When `T` carries `levelOptions.levels`, this type intersects
+ * `LogixiaLoggerService` with a method for every *custom* level so the IDE
+ * suggests `service.kafka(...)`, `service.payment(...)`, etc.
+ */
+export type LogixiaServiceWithLevels<T extends LoggerConfig<Record<string, number>>> = T['levelOptions'] extends {
+  levels: infer L;
+} ? L extends Record<string, number> ? LogixiaLoggerService & ServiceCustomLevelMethods<L> : LogixiaLoggerService : LogixiaLoggerService;
+/**
+ * Helper — extracts custom level names from a config object's `levelOptions.levels`.
+ */
+type _ExtractCustomLevelNames<T> = T extends {
+  levelOptions?: {
+    levels?: infer L;
+  };
+} ? L extends Record<string, number> ? Exclude<keyof L & string, _ServiceBuiltinLevels> : never : never;
+/**
+ * Typed `LogixiaLoggerService` with autocomplete for custom levels.
+ *
+ * Accepts either:
+ *   - **string union** of custom level names: `LogixiaServiceWith<'kafka' | 'payment'>`
+ *   - **config object type** (via `typeof`): `LogixiaServiceWith<typeof logixiaConfig>`
+ *
+ * Define your config with `as const` once, derive the type everywhere:
+ *
+ * @example
+ * ```ts
+ * // logger.config.ts — define once
+ * export const logixiaConfig = {
+ *   levelOptions: {
+ *     levels: { error: 0, warn: 1, info: 2, debug: 3, verbose: 4, kafka: 5, payment: 6 },
+ *   },
+ * } as const;
+ * export type AppLogger = LogixiaServiceWith<typeof logixiaConfig>;
+ *
+ * // any.controller.ts — use everywhere, no casting
+ * constructor(private readonly logger: AppLogger) {}
+ * // this.logger.kafka('msg')  ← fully typed
+ * // this.logger.payment('msg') ← fully typed
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Or use string union directly:
+ * type AppLogger = LogixiaServiceWith<'kafka' | 'payment'>;
+ * ```
+ */
+export type LogixiaServiceWith<T extends string | Record<string, unknown>> = LogixiaLoggerService & { readonly [K in T extends string ? Exclude<T, _ServiceBuiltinLevels> : _ExtractCustomLevelNames<T>]: (message: string, data?: Record<string, unknown>) => Promise<void>; };
+export declare class LogixiaLoggerService implements LoggerService {
+  [K: string]: any;
+  private logger;
+  private context?;
+  private _mergedConfig;
+  constructor(config?: LoggerConfig);
+  private _createCustomLevelMethods;
+  /**
+   * NestJS `LoggerService.log` — void, string context.
+   * Maps internally to `info`.
+   *
+   * @example `logger.log('User signed up', 'AuthService')`
+   */
+  log(message: unknown, context?: string): void;
+  /**
+   * Native async `info` — structured data, returns `Promise<void>`.
+   *
+   * @example `await logger.info('User signed up', { userId: 'u_abc' })`
+   */
+  info(message: string, data?: Record<string, unknown>): Promise<void>;
+  /**
+   * Native async overload — structured metadata, returns `Promise<void>`.
+   *
+   * @example `await logger.error(new Error('DB timeout'), { requestId: 'req_abc' })`
+   * @example `await logger.error('Login failed', { userId: 'u_abc' })`
+   */
+  error(message: string | Error, data: Record<string, unknown>): Promise<void>;
+  /**
+   * NestJS compat overload — string trace + optional context, returns `void`.
+   *
+   * @example `logger.error('Something failed', err.stack, 'AuthService')`
+   */
+  error(message: unknown, trace?: string, context?: string): void;
+  /**
+   * Native async overload — structured metadata, returns `Promise<void>`.
+   *
+   * @example `await logger.warn('Rate limit approaching', { userId: 'u_abc', count: 90 })`
+   */
+  warn(message: string, data: Record<string, unknown>): Promise<void>;
+  /**
+   * NestJS compat overload — optional context string, returns `void`.
+   *
+   * @example `logger.warn('Deprecated API used', 'PaymentService')`
+   */
+  warn(message: unknown, context?: string): void;
+  /**
+   * Native async overload — structured metadata, returns `Promise<void>`.
+   *
+   * @example `await logger.debug('Cache miss', { key: 'user:abc', ttl: 300 })`
+   */
+  debug(message: string, data: Record<string, unknown>): Promise<void>;
+  /**
+   * NestJS compat overload — optional context string, returns `void`.
+   *
+   * @example `logger.debug('Processing request', 'OrderService')`
+   */
+  debug(message: unknown, context?: string): void;
+  /**
+   * Native async overload — structured metadata, returns `Promise<void>`.
+   * Maps to `trace` level internally.
+   *
+   * @example `await logger.verbose('Socket message received', { event: 'ping', size: 42 })`
+   */
+  verbose(message: string, data: Record<string, unknown>): Promise<void>;
+  /**
+   * NestJS compat overload — optional context string, returns `void`.
+   *
+   * @example `logger.verbose('Connection established', 'WebSocketGateway')`
+   */
+  verbose(message: unknown, context?: string): void;
+  /**
+   * Native async `trace` — lowest verbosity level, structured data.
+   */
+  trace(message: string, data?: Record<string, unknown>): Promise<void>;
+  /**
+   * Log at any named level with structured data.
+   */
+  logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
+  time(label: string): void;
+  timeEnd(label: string): Promise<number | undefined>;
+  timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
+  setContext(context: string): void;
+  getContext(): string | undefined;
+  setLevel(level: LogLevelString): void;
+  getLevel(): LogLevelString;
+  child(context: string, data?: Record<string, unknown>): LogixiaLoggerService;
+  getCurrentTraceId(): string | undefined;
+  /** Returns the AsyncLocalStorage key currently used to store the trace ID. */
+  get traceContextKey(): string;
+  close(): Promise<void>;
+  static create<T extends LoggerConfig<Record<string, number>>>(config?: T): LogixiaServiceWithLevels<T>;
+  getLogger(): LogixiaLogger;
+  private setContextIfProvided;
+  private formatMessage;
+}
+/**
+ * Observable counters exposed for monitoring Kafka consumer trace hygiene.
+ *
+ * Usage:
+ *   import { KafkaTraceInterceptor } from 'logixia/nest';
+ *   setInterval(() => {
+ *     myMetrics.gauge('kafka.trace.dropped', KafkaTraceInterceptor.metrics.dropped);
+ *   }, 10_000);
+ */
+interface KafkaTraceMetrics {
+  /** Messages processed where a traceId was successfully resolved (body/header/ALS). */
+  accepted: number;
+  /** Messages handled without any traceId — `requireTraceId: false`. */
+  acceptedWithoutTrace: number;
+  /** Messages dropped because `requireTraceId: true` and no traceId was found. */
+  dropped: number;
+}
+export declare class KafkaTraceInterceptor implements NestInterceptor {
+  private readonly requireTraceId;
+  /**
+   * Process-wide counters. Readable from anywhere — scrape into your metrics
+   * system (Prometheus, Datadog, CloudWatch) on an interval.
+   */
+  static readonly metrics: KafkaTraceMetrics;
+  /** Reset counters (tests). */
+  static resetMetrics(): void;
+  private readonly ctx;
+  private readonly config;
+  /**
+   * @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
+   * @param requireTraceId - When true, messages with no traceId are silently skipped
+   *                         (EMPTY Observable — message is ack'd, consumer stays alive).
+   *                         A WARN is logged AND `KafkaTraceInterceptor.metrics.dropped`
+   *                         increments so the missing traceId is observable end-to-end.
+   *                         Default: false (handler runs without trace context).
+   */
+  constructor(config?: TraceIdConfig, requireTraceId?: boolean);
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+export declare class WebSocketTraceInterceptor implements NestInterceptor {
+  private readonly ctx;
+  private readonly config;
+  constructor(config?: TraceIdConfig);
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+export declare const LOGIXIA_LOGGER_CONFIG = "LOGIXIA_LOGGER_CONFIG";
+export declare const LOGIXIA_TRACE_CONFIG = "TRACE_CONFIG";
+export declare const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
+export interface LogixiaAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  useExisting?: Type<LogixiaOptionsFactory>;
+  useClass?: Type<LogixiaOptionsFactory>;
+  useFactory?: (...args: unknown[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
+  inject?: Array<InjectionToken | OptionalFactoryDependency>;
+}
+export interface LogixiaOptionsFactory {
+  createLogixiaOptions(): Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
+}
+/**
+ * Logixia Logger Module for NestJS dependency injection
+ */
+export declare class LogixiaLoggerModule implements NestModule {
+  private config;
+  private static loggerConfig;
+  /**
+   * @internal Backing field for the global logger. Do not read or write
+   * directly — use {@link getGlobalLogger} / {@link _setGlobalLogger} which
+   * enforce single-init semantics.
+   */
+  static _globalLogger: LogixiaLoggerService | null;
+  /**
+   * @internal Set the global logger exactly once.
+   *
+   * Called from the module's forRoot / forRootAsync factory. If the module is
+   * initialised more than once in the same process (nested DI context, test
+   * harness creating multiple apps, hot reload, etc.) a warning is written to
+   * stderr and the first logger wins — silently overwriting would allow the
+   * newer instance's transport config to replace the live one while the old
+   * one is still being used by registered shutdown hooks, decorators, etc.
+   *
+   * Use {@link _resetGlobalLogger} in tests to reset between runs.
+   */
+  static _setGlobalLogger(service: LogixiaLoggerService): void;
+  /** @internal Clear the global logger. Tests only. */
+  static _resetGlobalLogger(): void;
+  /**
+   * Returns the global LogixiaLoggerService instance that was created when the
+   * module booted. Useful for logging outside of NestJS DI — utility functions,
+   * plain scripts, decorators — without injecting the service everywhere.
+   *
+   * Returns `null` if called before `LogixiaLoggerModule.forRoot[Async]()` has
+   * been initialised (i.e. before the NestJS app has started).
+   *
+   * @example
+   * ```ts
+   * // some-util.ts
+   * import { LogixiaLoggerModule } from 'logixia/nest';
+   *
+   * export function doSomething() {
+   *   LogixiaLoggerModule.getGlobalLogger()?.info('doing something');
+   * }
+   * ```
+   */
+  static getGlobalLogger(): LogixiaLoggerService | null;
+  configure(consumer: MiddlewareConsumer): void;
+  /**
+   * Configure the module with synchronous options
+   */
+  static forRoot(config?: Partial<LoggerConfig>): {
+    module: typeof LogixiaLoggerModule;
+    providers: ({
+      provide: string;
+      useValue: Partial<LoggerConfig<Record<string, number>>>;
+      useFactory?: never;
+      inject?: never;
+    } | {
+      provide: string;
+      useValue: TraceIdConfig;
+      useFactory?: never;
+      inject?: never;
+    } | {
+      provide: typeof LogixiaLoggerService;
+      useFactory: (loggerConfig: Partial<LoggerConfig>) => LogixiaLoggerService;
+      inject: string[];
+      useValue?: never;
+    } | {
+      provide: typeof KafkaTraceInterceptor;
+      useFactory: (traceConfig: TraceIdConfig | undefined) => KafkaTraceInterceptor;
+      inject: string[];
+      useValue?: never;
+    } | {
+      provide: typeof WebSocketTraceInterceptor;
+      useFactory: (traceConfig: TraceIdConfig | undefined) => WebSocketTraceInterceptor;
+      inject: string[];
+      useValue?: never;
+    })[];
+    exports: (string | typeof LogixiaLoggerService | typeof KafkaTraceInterceptor | typeof WebSocketTraceInterceptor)[];
+    global: boolean;
+  };
+  /**
+   * Configure the module with asynchronous options
+   */
+  static forRootAsync(options: LogixiaAsyncOptions): {
+    module: typeof LogixiaLoggerModule;
+    imports: (Type<any> | import("@nestjs/common").DynamicModule | Promise<import("@nestjs/common").DynamicModule> | import("@nestjs/common").ForwardReference<any>)[];
+    providers: ({
+      provide: string;
+      useFactory: (...args: unknown[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
+      inject: (InjectionToken | OptionalFactoryDependency)[];
+    } | {
+      provide: string;
+      useFactory: (optionsFactory: LogixiaOptionsFactory) => Promise<Partial<LoggerConfig<Record<string, number>>>>;
+      inject: Type<LogixiaOptionsFactory>[];
+    } | {
+      provide: Type<LogixiaOptionsFactory>;
+      useClass: Type<LogixiaOptionsFactory>;
+    } | {
+      provide: string;
+      useFactory: (loggerConfig: Partial<LoggerConfig>) => TraceIdConfig;
+      inject: string[];
+    } | {
+      provide: typeof LogixiaLoggerService;
+      useFactory: (loggerConfig: Partial<LoggerConfig>) => LogixiaLoggerService;
+      inject: string[];
+    } | {
+      provide: typeof KafkaTraceInterceptor;
+      useFactory: (traceConfig: TraceIdConfig | undefined) => KafkaTraceInterceptor;
+      inject: string[];
+    } | {
+      provide: typeof WebSocketTraceInterceptor;
+      useFactory: (traceConfig: TraceIdConfig | undefined) => WebSocketTraceInterceptor;
+      inject: string[];
+    })[];
+    exports: (string | typeof LogixiaLoggerService | typeof KafkaTraceInterceptor | typeof WebSocketTraceInterceptor)[];
+    global: boolean;
+  };
+  /**
+   * Create feature-specific logger instances
+   */
+  static forFeature(context: string): {
+    module: typeof LogixiaLoggerModule;
+    providers: {
+      provide: string;
+      useFactory: (baseLogger: LogixiaLoggerService) => LogixiaLoggerService;
+      inject: (typeof LogixiaLoggerService)[];
+    }[];
+    exports: string[];
+  };
+  private static createAsyncProviders;
+  private static createAsyncOptionsProvider;
+}
+/**
+ * Inject the Logixia logger registered in the current NestJS DI container.
+ *
+ * Equivalent to `@Inject(LOGIXIA_LOGGER_TOKEN)` but without needing to import
+ * the internal token constant yourself.
+ *
+ * @example
+ * ```ts
+ * constructor(@InjectLogger() private readonly logger: LogixiaLoggerService) {}
+ * ```
+ */
+export declare const InjectLogger: () => ParameterDecorator;
+interface LogMethodOptions {
+  /**
+   * Log level to use for entry / exit messages.
+   * @default 'debug'
+   */
+  level?: LogLevelString;
+  /**
+   * Whether to log the arguments passed to the method.
+   * Disable for high-throughput hot paths.
+   * @default true
+   */
+  logArgs?: boolean;
+  /**
+   * Whether to log the return value of the method.
+   * @default false
+   */
+  logResult?: boolean;
+  /**
+   * Whether to log error stack traces for thrown errors.
+   * @default true
+   */
+  logErrors?: boolean;
+  /**
+   * Custom label used in log messages instead of the auto-detected class.method name.
+   */
+  label?: string;
+}
+/**
+ * Method decorator that auto-logs entry, exit, duration, and errors.
+ *
+ * Preserves the original method's sync/async contract: a synchronous method
+ * stays synchronous (returns its value directly, with logs emitted
+ * fire-and-forget), and an async method is awaited so exit/error logs reflect
+ * the resolved result. Attaches to the logger found on the class instance via a
+ * `logger` property (the conventional NestJS name).
+ *
+ * @example
+ * ```ts
+ * @LogMethod({ level: 'info', logArgs: true })
+ * async processPayment(orderId: string): Promise<void> { … }
+ * ```
+ */
+export declare function LogMethod(options?: LogMethodOptions): MethodDecorator;
+/**
+ * Global NestJS exception filter that converts any exception into the standard
+ * `LogixiaErrorResponse` wire format and logs it with full request context.
+ *
+ * Handles three exception types in priority order:
+ *  1. `LogixiaException`     — typed fields used directly
+ *  2. NestJS `HttpException` — status + message extracted
+ *  3. Unknown / plain Error  — falls back to 500 `server_error`
+ *
+ * **Debug block (off by default):**
+ * Responses never include the `debug` block (stack trace, service, duration)
+ * unless `exposeDebug: true` is passed in the filter options. The underlying
+ * `cause` is only added when `exposeCause: true` is also set. Enable explicitly
+ * for local development only, e.g.
+ * `new LogixiaExceptionFilter(logger, undefined, { exposeDebug: process.env.NODE_ENV === 'development' })`.
+ *
+ * **Trace ID headers:**
+ * `X-Trace-ID` and `X-Request-ID` are echoed back on every error response so
+ * clients can correlate with server logs.
+ *
+ * **Retry-After header:**
+ * Automatically added for `429` responses (`Retry-After: 60`).
+ *
+ * Register in `main.ts`:
+ * ```ts
+ * const logger = app.get(LogixiaLoggerService);
+ * app.useGlobalFilters(new LogixiaExceptionFilter(logger));
+ * ```
+ */
+interface LogixiaExceptionFilterOptions {
+  /**
+   * Include the `debug` block (stack trace, service, duration) in error responses.
+   * @default false
+   */
+  exposeDebug?: boolean;
+  /**
+   * Include `debug.cause` as well. Requires `exposeDebug`.
+   * @default false
+   */
+  exposeCause?: boolean;
+}
+/** Injection token for {@link LogixiaExceptionFilterOptions}. */
+export declare const LOGIXIA_EXCEPTION_FILTER_OPTIONS = "LOGIXIA_EXCEPTION_FILTER_OPTIONS";
+export declare class LogixiaExceptionFilter implements ExceptionFilter {
+  private readonly _logger;
+  private readonly _traceConfig;
+  private readonly _options;
+  constructor(logger?: LogixiaLoggerService, loggerConfig?: Partial<LoggerConfig>, options?: LogixiaExceptionFilterOptions);
+  catch(exception: unknown, host: ArgumentsHost): void;
+}
 declare global {
   namespace Express {
     interface Request {
@@ -13,12 +465,17 @@ declare global {
     }
   }
 }
-declare class TraceMiddleware implements NestMiddleware {
+export declare class TraceMiddleware implements NestMiddleware {
   private readonly config?;
   private readonly ctx;
   constructor(config?: TraceIdConfig | undefined);
   use(req: Request, res: Response, next: NextFunction): void;
 }
-//#endregion
-export { KafkaTraceInterceptor, LOGIXIA_EXCEPTION_FILTER_OPTIONS, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, type LogixiaAsyncOptions, LogixiaExceptionFilter, type LogixiaExceptionFilterOptions, LogixiaLoggerModule, LogixiaLoggerService, type LogixiaOptionsFactory, type LogixiaServiceWith, type LogixiaServiceWithLevels, TraceMiddleware, WebSocketTraceInterceptor };
+/**
+ * Create a new Logixia logger service for NestJS
+ * @param config - Logger configuration
+ * @returns LogixiaLoggerService instance
+ */
+export declare function createLoggerService(config?: Partial<LoggerConfig>): LogixiaLoggerService;
+export type { LogMethodOptions, LogixiaExceptionFilterOptions };
 //# sourceMappingURL=nest.d.ts.map

package/dist/nest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nest.d.ts","names":[],"sources":["../src/core/trace.middleware.ts"],"sourcesContent":[],"mappings":";;;;;;;;QAmFyB,MAAA,CAAA;EAAgB,UAAA,OAAA,CAAA;IAxBD,UAAA,OAAA,CAAA;MAAc,OAAA,CAAA,EAAA,MAAA;;;;cAAzC,eAAA,YAA2B;;;uBAGY;WAqBzC,cAAc,gBAAgB"}
+{"version":3,"file":"nest.d.ts","names":[],"sources":["../src/core/logitron-nestjs.service.ts","../src/core/kafka-trace.interceptor.ts","../src/core/websocket-trace.interceptor.ts","../src/core/logitron-logger.module.ts","../src/core/nestjs-extras.ts","../src/core/trace.middleware.ts","../src/nest.ts"],"mappings":"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"}