@vritti/api-sdk 0.0.8 → 0.0.9

package/dist/index.js

@@ -1942,7 +1942,9 @@ var HttpExceptionFilter = class _HttpExceptionFilter {
         detail = exceptionResponse;
       }
     } else {
-      this.logger.error("Unexpected error:", exception);
+      const errorMessage = exception instanceof Error ? exception.message : "Unknown error";
+      const stack = exception instanceof Error ? exception.stack : void 0;
+      this.logger.error(`Unexpected error: ${errorMessage}`, stack);
       errors = [
         {
           message: "An unexpected error occurred"
@@ -2345,19 +2347,903 @@ var BadGatewayException = class extends BaseFieldException {
     }
   }
 };
+
+// src/logger/logger.module.ts
+import { Global as Global4, Module as Module5, Logger as Logger11 } from "@nestjs/common";
+
+// src/logger/services/logger.service.ts
+import { Injectable as Injectable9, Logger as Logger10, Optional } from "@nestjs/common";
+import { createLogger, format, transports } from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+
+// src/logger/utils/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+var correlationStorage = new AsyncLocalStorage();
+function getCorrelationContext() {
+  return correlationStorage.getStore();
+}
+__name(getCorrelationContext, "getCorrelationContext");
+function runWithCorrelationContext(context, callback) {
+  return correlationStorage.run(context, callback);
+}
+__name(runWithCorrelationContext, "runWithCorrelationContext");
+function updateCorrelationContext(updates) {
+  const context = correlationStorage.getStore();
+  if (context) {
+    Object.assign(context, updates);
+  }
+}
+__name(updateCorrelationContext, "updateCorrelationContext");
+var DEFAULT_CORRELATION_HEADER = "x-correlation-id";
+function generateCorrelationId() {
+  return randomUUID();
+}
+__name(generateCorrelationId, "generateCorrelationId");
+function addCorrelationIdToResponse(reply, correlationId, headerName = DEFAULT_CORRELATION_HEADER) {
+  if (typeof reply.header === "function") {
+    reply.header(headerName, correlationId);
+  } else if (reply.raw && typeof reply.raw.setHeader === "function") {
+    reply.raw.setHeader(headerName, correlationId);
+  }
+}
+__name(addCorrelationIdToResponse, "addCorrelationIdToResponse");
+
+// src/logger/services/logger.service.ts
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var LoggerService2 = class _LoggerService {
+  static {
+    __name(this, "LoggerService");
+  }
+  defaultLogger;
+  activeLogger;
+  options;
+  context;
+  constructor(options = {}, defaultLogger) {
+    this.defaultLogger = defaultLogger;
+    this.options = options;
+    const provider = options.provider ?? "winston";
+    if (provider === "default") {
+      if (!this.defaultLogger) {
+        throw new Error("LoggerService: Default Logger not provided");
+      }
+      this.activeLogger = this.defaultLogger;
+    } else {
+      this.activeLogger = this.createWinstonLogger(options);
+    }
+  }
+  /**
+  * Creates a Winston logger instance with inline configuration.
+  * Consolidates winston-config.factory.ts logic.
+  */
+  createWinstonLogger(opts) {
+    const level = opts.level ?? "debug";
+    const logFormat = opts.format ?? "text";
+    const baseFormatters = [
+      format.timestamp({
+        format: "YYYY-MM-DDTHH:mm:ss.SSSZ"
+      }),
+      format.errors({
+        stack: true
+      })
+    ];
+    const consoleTransport = logFormat === "json" ? new transports.Console({
+      level,
+      format: format.combine(...baseFormatters, format.json())
+    }) : new transports.Console({
+      level,
+      format: format.combine(...baseFormatters, format.printf((info) => {
+        const { timestamp, level: level2, message, context, correlationId, trace } = info;
+        const parts = [
+          timestamp,
+          level2.toUpperCase().padEnd(7),
+          correlationId ? `[${correlationId.toString().slice(-6)}]` : "",
+          context ? `[${context}]` : "",
+          message
+        ].filter(Boolean);
+        let output = parts.join(" ");
+        if (trace) {
+          output += "\n" + trace;
+        }
+        return output;
+      }), format.colorize({
+        all: true
+      }))
+    });
+    const winstonTransports = [
+      consoleTransport
+    ];
+    if (opts.enableFileLogger) {
+      const filePath = opts.filePath ?? "./logs";
+      const maxFiles = opts.maxFiles ?? "14d";
+      winstonTransports.push(new DailyRotateFile({
+        level,
+        filename: `${filePath}/%DATE%-combined.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: format.combine(format.timestamp(), format.json())
+      }), new DailyRotateFile({
+        level: "error",
+        filename: `${filePath}/%DATE%-error.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: format.combine(format.timestamp(), format.json())
+      }));
+    }
+    const config = {
+      level,
+      transports: winstonTransports,
+      exitOnError: false
+    };
+    if (opts.defaultMeta || opts.appName) {
+      config.defaultMeta = {
+        ...opts.defaultMeta,
+        appName: opts.appName,
+        environment: opts.environment
+      };
+    }
+    return createLogger(config);
+  }
+  // NestJS LoggerService interface methods
+  log(message, context) {
+    this._log("log", message, context);
+  }
+  error(message, trace, context) {
+    this._log("error", message, context, trace);
+  }
+  warn(message, context) {
+    this._log("warn", message, context);
+  }
+  debug(message, context) {
+    this._log("debug", message, context);
+  }
+  verbose(message, context) {
+    this._log("verbose", message, context);
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  /**
+  * Unified internal logging method that handles both Winston and NestJS Logger.
+  */
+  _log(level, message, context, trace) {
+    const ctx = context ?? this.context;
+    if ("format" in this.activeLogger && "transports" in this.activeLogger) {
+      const winstonLogger = this.activeLogger;
+      const winstonLevel = level === "log" ? "info" : level;
+      const formattedMessage = this.formatMessage(message);
+      const metadata = this.enrichMetadata({}, ctx, trace);
+      winstonLogger.log({
+        level: winstonLevel,
+        message: formattedMessage,
+        ...metadata
+      });
+    } else {
+      const nestLogger = this.activeLogger;
+      if (level === "error" && trace) {
+        ctx ? nestLogger.error(message, trace, ctx) : nestLogger.error(message, trace);
+      } else if (level === "log") {
+        ctx ? nestLogger.log(message, ctx) : nestLogger.log(message);
+      } else if (level === "warn") {
+        ctx ? nestLogger.warn(message, ctx) : nestLogger.warn(message);
+      } else if (level === "debug" && nestLogger.debug) {
+        ctx ? nestLogger.debug(message, ctx) : nestLogger.debug(message);
+      } else if (level === "verbose" && nestLogger.verbose) {
+        ctx ? nestLogger.verbose(message, ctx) : nestLogger.verbose(message);
+      }
+    }
+  }
+  /**
+  * Logs with custom metadata (Winston only).
+  */
+  logWithMetadata(level, message, metadata, context) {
+    const ctx = context ?? this.context;
+    if ("format" in this.activeLogger && "transports" in this.activeLogger) {
+      const winstonLogger = this.activeLogger;
+      const winstonLevel = level === "log" ? "info" : level;
+      winstonLogger.log({
+        level: winstonLevel,
+        message: this.formatMessage(message),
+        ...metadata
+      });
+    } else {
+      const messageWithMeta = metadata ? `${message} ${JSON.stringify(metadata)}` : message;
+      this[level](messageWithMeta, ctx);
+    }
+  }
+  formatMessage(message) {
+    if (message instanceof Error) return message.message;
+    if (typeof message === "object" && message !== null) {
+      try {
+        return JSON.stringify(message);
+      } catch {
+        return String(message);
+      }
+    }
+    return String(message);
+  }
+  /**
+  * Enriches metadata with correlation context from AsyncLocalStorage.
+  * Inline from winston-logger.service.ts
+  */
+  enrichMetadata(metadata = {}, context, trace) {
+    const enriched = {
+      ...metadata
+    };
+    if (context) enriched.context = context;
+    const correlationContext = getCorrelationContext();
+    if (correlationContext) {
+      if (correlationContext.correlationId) enriched.correlationId = correlationContext.correlationId;
+      for (const [key, value] of Object.entries(correlationContext)) {
+        if (key !== "correlationId") {
+          enriched[key] = value;
+        }
+      }
+    }
+    if (trace) enriched.trace = trace;
+    return enriched;
+  }
+  child(context) {
+    const childLogger = new _LoggerService(this.options, this.defaultLogger);
+    childLogger.setContext(context);
+    return childLogger;
+  }
+};
+LoggerService2 = _ts_decorate14([
+  Injectable9(),
+  _ts_param4(0, Optional()),
+  _ts_param4(1, Optional()),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof LoggerModuleOptions === "undefined" ? Object : LoggerModuleOptions,
+    typeof Logger10 === "undefined" ? Object : Logger10
+  ])
+], LoggerService2);
+
+// src/logger/middleware/correlation-id.middleware.ts
+import { Injectable as Injectable10 } from "@nestjs/common";
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var CorrelationIdMiddleware = class {
+  static {
+    __name(this, "CorrelationIdMiddleware");
+  }
+  includeInResponse;
+  responseHeader;
+  constructor(options = {}) {
+    this.includeInResponse = options.includeInResponse ?? true;
+    this.responseHeader = options.responseHeader ?? DEFAULT_CORRELATION_HEADER;
+  }
+  /**
+  * Middleware handler for processing requests.
+  */
+  use(req, reply, next) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    runWithCorrelationContext({
+      correlationId
+    }, () => {
+      next();
+    });
+  }
+  /**
+  * Fastify hook handler for onRequest.
+  * This is an async function that returns a Promise, ensuring the AsyncLocalStorage
+  * context persists throughout the entire request lifecycle.
+  */
+  async onRequest(req, reply) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    const store = correlationStorage.getStore();
+    if (!store) {
+      correlationStorage.enterWith({
+        correlationId
+      });
+    }
+  }
+};
+CorrelationIdMiddleware = _ts_decorate15([
+  Injectable10(),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof CorrelationIdMiddlewareOptions === "undefined" ? Object : CorrelationIdMiddlewareOptions
+  ])
+], CorrelationIdMiddleware);
+
+// src/logger/interceptors/http-logger.interceptor.ts
+import { Injectable as Injectable11, Optional as Optional2 } from "@nestjs/common";
+import { tap as tap2, catchError } from "rxjs/operators";
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var HttpLoggerInterceptor = class {
+  static {
+    __name(this, "HttpLoggerInterceptor");
+  }
+  logger;
+  enableRequestLog;
+  enableResponseLog;
+  slowRequestThreshold;
+  constructor(logger, options) {
+    this.logger = logger;
+    this.enableRequestLog = options?.enableRequestLog ?? true;
+    this.enableResponseLog = options?.enableResponseLog ?? true;
+    this.slowRequestThreshold = options?.slowRequestThreshold ?? 3e3;
+  }
+  intercept(context, next) {
+    if (context.getType() !== "http") {
+      return next.handle();
+    }
+    const httpContext = context.switchToHttp();
+    const request = httpContext.getRequest();
+    const response = httpContext.getResponse();
+    const startTime = Date.now();
+    if (this.enableRequestLog) {
+      this.logRequest(request);
+    }
+    return next.handle().pipe(tap2(() => {
+      if (this.enableResponseLog) {
+        const duration = Date.now() - startTime;
+        this.logResponse(request, response, duration);
+      }
+    }), catchError((error) => {
+      const duration = Date.now() - startTime;
+      this.logError(request, response, duration, error);
+      throw error;
+    }));
+  }
+  logRequest(request) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const metadata = {
+        type: "http_request",
+        method: request.method,
+        url: request.url,
+        correlationId: correlationContext?.correlationId,
+        ip: request.ip,
+        userAgent: request.headers["user-agent"]
+      };
+      this.logger.logWithMetadata("log", `Incoming ${request.method} ${request.url}`, metadata);
+    } catch (error) {
+      this.logger.error("Failed to log HTTP request", error.stack);
+    }
+  }
+  logResponse(request, response, duration) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const statusCode = response.statusCode;
+      const logLevel = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "log";
+      const metadata = {
+        type: "http_response",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId
+      };
+      if (duration > this.slowRequestThreshold) {
+        metadata.slowRequest = true;
+      }
+      const message = metadata.slowRequest ? `SLOW ${request.method} ${request.url} ${statusCode} - ${duration}ms` : `${request.method} ${request.url} ${statusCode} - ${duration}ms`;
+      this.logger.logWithMetadata(logLevel, message, metadata);
+    } catch (error) {
+      this.logger.error("Failed to log HTTP response", error.stack);
+    }
+  }
+  logError(request, response, duration, error) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const statusCode = response.statusCode || 500;
+      const metadata = {
+        type: "http_error",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId,
+        errorName: error?.name || "Error",
+        errorMessage: error?.message || "Unknown error"
+      };
+      if (error?.stack) {
+        metadata.trace = error.stack;
+      }
+      if (error?.response) {
+        metadata.errorDetails = error.response;
+      }
+      const message = `ERROR ${request.method} ${request.url} ${statusCode} - ${error?.message || "Unknown error"}`;
+      this.logger.logWithMetadata("error", message, metadata);
+    } catch (loggingError) {
+      this.logger.error("Failed to log HTTP error", loggingError.stack);
+    }
+  }
+};
+HttpLoggerInterceptor = _ts_decorate16([
+  Injectable11(),
+  _ts_param5(1, Optional2()),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof HttpLoggerOptions === "undefined" ? Object : HttpLoggerOptions
+  ])
+], HttpLoggerInterceptor);
+
+// src/logger/logger.module.ts
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+var LOGGER_MODULE_OPTIONS = Symbol("LOGGER_MODULE_OPTIONS");
+var DEFAULT_LOGGER_OPTIONS = {
+  provider: "winston",
+  enableCorrelationId: true,
+  enableHttpLogger: true,
+  filePath: "./logs",
+  maxFiles: "14d"
+};
+var ENVIRONMENT_PRESETS = {
+  /**
+  * Development preset - maximum verbosity for local development
+  */
+  development: {
+    provider: "winston",
+    level: "debug",
+    format: "text",
+    enableFileLogger: false,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 1e3
+    }
+  },
+  /**
+  * Staging preset - moderate verbosity with file logging
+  */
+  staging: {
+    provider: "winston",
+    level: "log",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 3e3
+    }
+  },
+  /**
+  * Production preset - minimal verbosity with all safety features enabled
+  */
+  production: {
+    provider: "winston",
+    level: "warn",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: false,
+      enableResponseLog: true,
+      slowRequestThreshold: 5e3
+    }
+  },
+  /**
+  * Test preset - errors only, minimal features for faster test execution
+  */
+  test: {
+    provider: "winston",
+    level: "error",
+    format: "json",
+    enableFileLogger: false,
+    enableCorrelationId: false,
+    enableHttpLogger: false
+  }
+};
+function mergeWithDefaults(options = {}) {
+  const preset = options.environment ? ENVIRONMENT_PRESETS[options.environment] ?? ENVIRONMENT_PRESETS.development : ENVIRONMENT_PRESETS.development;
+  const filteredOptions = Object.fromEntries(Object.entries(options).filter(([_, value]) => value !== void 0));
+  if (filteredOptions.httpLogger && preset?.httpLogger) {
+    filteredOptions.httpLogger = {
+      ...preset.httpLogger,
+      ...Object.fromEntries(Object.entries(filteredOptions.httpLogger).filter(([_, value]) => value !== void 0))
+    };
+  }
+  const merged = {
+    ...DEFAULT_LOGGER_OPTIONS,
+    ...preset,
+    ...filteredOptions
+  };
+  return merged;
+}
+__name(mergeWithDefaults, "mergeWithDefaults");
+function createDefaultLoggerProvider(options) {
+  return {
+    provide: Logger11,
+    useFactory: /* @__PURE__ */ __name(() => {
+      const logger = new Logger11();
+      if (options.level && typeof logger.setLogLevels === "function") {
+        const levels = getLevelsUpTo(options.level);
+        logger.setLogLevels(levels);
+      }
+      return logger;
+    }, "useFactory")
+  };
+}
+__name(createDefaultLoggerProvider, "createDefaultLoggerProvider");
+function createLoggerProviders(options = {}) {
+  const mergedOptions = mergeWithDefaults(options);
+  const providers = [
+    // Options provider
+    {
+      provide: LOGGER_MODULE_OPTIONS,
+      useValue: mergedOptions
+    }
+  ];
+  if (mergedOptions.provider === "default") {
+    providers.push(createDefaultLoggerProvider(mergedOptions));
+  }
+  providers.push({
+    provide: LoggerService2,
+    useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+      return new LoggerService2(opts, defaultLogger);
+    }, "useFactory"),
+    inject: [
+      LOGGER_MODULE_OPTIONS,
+      {
+        token: Logger11,
+        optional: true
+      }
+    ]
+  });
+  providers.push({
+    provide: CorrelationIdMiddleware,
+    useFactory: /* @__PURE__ */ __name(() => {
+      return new CorrelationIdMiddleware({
+        includeInResponse: true,
+        responseHeader: "x-correlation-id"
+      });
+    }, "useFactory")
+  });
+  providers.push({
+    provide: HttpLoggerInterceptor,
+    useFactory: /* @__PURE__ */ __name((logger, opts) => {
+      const httpLoggerOptions = opts.httpLogger ?? {
+        enableRequestLog: opts.enableHttpLogger,
+        enableResponseLog: opts.enableHttpLogger
+      };
+      return new HttpLoggerInterceptor(logger, httpLoggerOptions);
+    }, "useFactory"),
+    inject: [
+      LoggerService2,
+      LOGGER_MODULE_OPTIONS
+    ]
+  });
+  return providers;
+}
+__name(createLoggerProviders, "createLoggerProviders");
+function getLevelsUpTo(level) {
+  const allLevels = [
+    "error",
+    "warn",
+    "log",
+    "debug",
+    "verbose"
+  ];
+  const levelIndex = allLevels.indexOf(level);
+  if (levelIndex === -1) {
+    return [
+      "error",
+      "warn",
+      "log"
+    ];
+  }
+  return allLevels.slice(0, levelIndex + 1);
+}
+__name(getLevelsUpTo, "getLevelsUpTo");
+var LoggerModule = class _LoggerModule {
+  static {
+    __name(this, "LoggerModule");
+  }
+  /**
+  * Configures the logger module with static options.
+  *
+  * Users must explicitly pass `environment` to select a preset.
+  * All preset values can be overridden by passing explicit options.
+  *
+  * @param options - Logger configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * ```typescript
+  * // Production preset with app name
+  * LoggerModule.forRoot({
+  *   environment: 'production',
+  *   appName: 'my-service'
+  * })
+  *
+  * // Development preset with custom level
+  * LoggerModule.forRoot({
+  *   environment: 'development',
+  *   level: 'verbose',
+  *   enableFileLogger: true
+  * })
+  *
+  * // Use default NestJS logger
+  * LoggerModule.forRoot({
+  *   provider: 'default',
+  *   environment: 'development'
+  * })
+  * ```
+  */
+  static forRoot(options = {}) {
+    const providers = createLoggerProviders(options);
+    return {
+      module: _LoggerModule,
+      providers,
+      exports: [
+        LoggerService2,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Configures the logger module with async options.
+  *
+  * Supports dynamic configuration using:
+  * - `useFactory`: Factory function with dependency injection
+  * - `useClass`: Class implementing `LoggerOptionsFactory`
+  * - `useExisting`: Existing provider implementing `LoggerOptionsFactory`
+  *
+  * Options from the factory/class are merged with environment preset defaults.
+  *
+  * @param options - Async configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * ```typescript
+  * // Factory with ConfigService
+  * LoggerModule.forRootAsync({
+  *   imports: [ConfigModule],
+  *   useFactory: (config: ConfigService) => ({
+  *     environment: config.get('NODE_ENV', 'development'),
+  *     provider: config.get('LOG_PROVIDER', 'winston'),
+  *     level: config.get('LOG_LEVEL'),
+  *     appName: config.get('APP_NAME'),
+  *   }),
+  *   inject: [ConfigService]
+  * })
+  *
+  * // Factory class
+  * @Injectable()
+  * class LoggerConfigService implements LoggerOptionsFactory {
+  *   createLoggerOptions(): LoggerModuleOptions {
+  *     return {
+  *       environment: 'production',
+  *       appName: 'my-service'
+  *     };
+  *   }
+  * }
+  *
+  * LoggerModule.forRootAsync({
+  *   useClass: LoggerConfigService
+  * })
+  * ```
+  */
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: _LoggerModule,
+      imports: options.imports || [],
+      providers: [
+        ...asyncProviders,
+        // Default logger provider
+        {
+          provide: Logger11,
+          useFactory: /* @__PURE__ */ __name((opts) => {
+            if (opts.provider === "default") {
+              const logger = new Logger11();
+              if (opts.level && typeof logger.setLogLevels === "function") {
+                const levels = getLevelsUpTo(opts.level);
+                logger.setLogLevels(levels);
+              }
+              return logger;
+            }
+            return null;
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS
+          ]
+        },
+        // Unified logger service
+        {
+          provide: LoggerService2,
+          useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+            return new LoggerService2(opts, defaultLogger);
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS,
+            {
+              token: Logger11,
+              optional: true
+            }
+          ]
+        },
+        // Correlation ID middleware
+        {
+          provide: CorrelationIdMiddleware,
+          useFactory: /* @__PURE__ */ __name(() => {
+            return new CorrelationIdMiddleware({
+              includeInResponse: true,
+              responseHeader: "x-correlation-id"
+            });
+          }, "useFactory")
+        },
+        // HTTP logger interceptor
+        {
+          provide: HttpLoggerInterceptor,
+          useFactory: /* @__PURE__ */ __name((logger, opts) => {
+            const httpLoggerOptions = opts.httpLogger ?? {
+              enableRequestLog: opts.enableHttpLogger,
+              enableResponseLog: opts.enableHttpLogger
+            };
+            return new HttpLoggerInterceptor(logger, httpLoggerOptions);
+          }, "useFactory"),
+          inject: [
+            LoggerService2,
+            LOGGER_MODULE_OPTIONS
+          ]
+        }
+      ],
+      exports: [
+        LoggerService2,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Configures middleware for the module.
+  * Middleware is registered globally in main.ts using Fastify hooks.
+  */
+  configure(consumer) {
+  }
+  /**
+  * Creates async providers for dynamic module configuration.
+  */
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        this.createAsyncOptionsProvider(options)
+      ];
+    }
+    const providers = [
+      this.createAsyncOptionsProvider(options)
+    ];
+    if (options.useClass) {
+      providers.push({
+        provide: options.useClass,
+        useClass: options.useClass
+      });
+    }
+    return providers;
+  }
+  /**
+  * Creates the async options provider.
+  */
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (...args) => {
+          const userOptions = await options.useFactory(...args);
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: options.inject || []
+      };
+    }
+    if (options.useClass) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (optionsFactory) => {
+          const userOptions = await optionsFactory.createLoggerOptions();
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: [
+          options.useClass
+        ]
+      };
+    }
+    if (options.useExisting) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (optionsFactory) => {
+          const userOptions = await optionsFactory.createLoggerOptions();
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: [
+          options.useExisting
+        ]
+      };
+    }
+    throw new Error("LoggerModule.forRootAsync() requires one of: useFactory, useClass, or useExisting");
+  }
+};
+LoggerModule = _ts_decorate17([
+  Global4(),
+  Module5({})
+], LoggerModule);
 export {
   AuthConfigModule,
   BadGatewayException,
   BadRequestException,
   BaseFieldException,
   ConflictException,
+  CorrelationIdMiddleware,
   CsrfGuard,
+  DEFAULT_CORRELATION_HEADER,
   DatabaseModule,
   ForbiddenException2 as ForbiddenException,
   GoneException,
   HttpExceptionFilter,
+  HttpLoggerInterceptor,
   HttpModule,
   InternalServerErrorException3 as InternalServerErrorException,
+  LOGGER_MODULE_OPTIONS,
+  LoggerModule,
+  LoggerService2 as LoggerService,
   MethodNotAllowedException,
   NotAcceptableException,
   NotFoundException,
@@ -2379,6 +3265,12 @@ export {
   UnsupportedMediaTypeException,
   ValidationException,
   VrittiAuthGuard,
-  getHttpStatusTitle
+  addCorrelationIdToResponse,
+  correlationStorage,
+  generateCorrelationId,
+  getCorrelationContext,
+  getHttpStatusTitle,
+  runWithCorrelationContext,
+  updateCorrelationContext
 };
 //# sourceMappingURL=index.js.map