@vritti/api-sdk 0.3.3 → 0.3.5

package/dist/logger.cjs

@@ -0,0 +1,862 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/logger/index.ts
+var logger_exports = {};
+__export(logger_exports, {
+  CorrelationIdMiddleware: () => CorrelationIdMiddleware,
+  DEFAULT_CORRELATION_HEADER: () => DEFAULT_CORRELATION_HEADER,
+  HttpLoggerInterceptor: () => HttpLoggerInterceptor,
+  LOGGER_MODULE_OPTIONS: () => LOGGER_MODULE_OPTIONS,
+  LoggerModule: () => LoggerModule,
+  LoggerService: () => LoggerService,
+  addCorrelationIdToResponse: () => addCorrelationIdToResponse,
+  correlationStorage: () => correlationStorage,
+  generateCorrelationId: () => generateCorrelationId,
+  getCorrelationContext: () => getCorrelationContext,
+  runWithCorrelationContext: () => runWithCorrelationContext,
+  updateCorrelationContext: () => updateCorrelationContext
+});
+module.exports = __toCommonJS(logger_exports);
+
+// src/logger/interceptors/http-logger.interceptor.ts
+var import_common4 = require("@nestjs/common");
+var import_operators = require("rxjs/operators");
+
+// src/exceptions/conflict.exception.ts
+var import_common2 = require("@nestjs/common");
+
+// src/exceptions/base-field.exception.ts
+var import_common = require("@nestjs/common");
+
+// src/filters/pg-error.translator.ts
+function findPgError(error, depth = 0) {
+  if (!error || typeof error !== "object" || depth > 5) return void 0;
+  const candidate = error;
+  if (typeof candidate.code === "string") return candidate;
+  return findPgError(candidate.cause, depth + 1);
+}
+__name(findPgError, "findPgError");
+
+// src/logger/services/logger.service.ts
+var import_common3 = require("@nestjs/common");
+var import_winston = require("winston");
+var import_winston_daily_rotate_file = __toESM(require("winston-daily-rotate-file"), 1);
+
+// src/logger/utils/index.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+var correlationStorage = new import_node_async_hooks.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 (0, import_node_crypto.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_decorate(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_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var LoggerService = 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 transports and format configuration
+  createWinstonLogger(opts) {
+    const level = opts.level ?? "debug";
+    const logFormat = opts.format ?? "text";
+    const baseFormatters = [
+      import_winston.format.timestamp({
+        format: "YYYY-MM-DDTHH:mm:ss.SSSZ"
+      }),
+      import_winston.format.errors({
+        stack: true
+      })
+    ];
+    const consoleTransport = logFormat === "json" ? new import_winston.transports.Console({
+      level,
+      format: import_winston.format.combine(...baseFormatters, import_winston.format.json())
+    }) : new import_winston.transports.Console({
+      level,
+      format: import_winston.format.combine(...baseFormatters, import_winston.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 += `
+${trace}`;
+        }
+        return output;
+      }), import_winston.format.colorize({
+        all: true
+      }))
+    });
+    const winstonTransports = [
+      consoleTransport
+    ];
+    if (opts.enableFileLogger) {
+      const filePath = opts.filePath ?? "./logs";
+      const maxFiles = opts.maxFiles ?? "14d";
+      winstonTransports.push(new import_winston_daily_rotate_file.default({
+        level,
+        filename: `${filePath}/%DATE%-combined.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: import_winston.format.combine(import_winston.format.timestamp(), import_winston.format.json())
+      }), new import_winston_daily_rotate_file.default({
+        level: "error",
+        filename: `${filePath}/%DATE%-error.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: import_winston.format.combine(import_winston.format.timestamp(), import_winston.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 (0, import_winston.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;
+  }
+  // Dispatches a log entry to either the Winston or NestJS logger implementation
+  _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 a message with custom metadata fields (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
+  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;
+  }
+};
+LoggerService = _ts_decorate([
+  (0, import_common3.Injectable)(),
+  _ts_param(0, (0, import_common3.Optional)()),
+  _ts_param(1, (0, import_common3.Optional)()),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof LoggerModuleOptions === "undefined" ? Object : LoggerModuleOptions,
+    typeof Logger === "undefined" ? Object : Logger
+  ])
+], LoggerService);
+
+// src/logger/interceptors/http-logger.interceptor.ts
+function _ts_decorate2(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_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_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((0, import_operators.tap)(() => {
+      if (this.enableResponseLog) {
+        const duration = Date.now() - startTime;
+        this.logResponse(request, response, duration);
+      }
+    }), (0, import_operators.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 err = error;
+      const statusCode = err.status ?? err.statusCode ?? response.statusCode ?? 500;
+      const pgCause = findPgError(error);
+      let errorMessage = err.message || err.detail || "Unknown error";
+      if (pgCause?.message && pgCause.message !== err.message) {
+        errorMessage = `${errorMessage} \u2014 cause: ${pgCause.message}${pgCause.code ? ` [${pgCause.code}]` : ""}`;
+      }
+      const metadata = {
+        type: "http_error",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId,
+        errorName: err.name || "Error",
+        errorMessage
+      };
+      if (pgCause) {
+        metadata.pgError = pgCause;
+      }
+      if (err.stack) {
+        metadata.trace = err.stack;
+      }
+      if (err.response) {
+        metadata.errorDetails = err.response;
+      }
+      const message = `ERROR ${request.method} ${request.url} ${statusCode} - ${errorMessage}`;
+      this.logger.logWithMetadata("error", message, metadata);
+    } catch (loggingError) {
+      this.logger.error("Failed to log HTTP error", loggingError.stack);
+    }
+  }
+};
+HttpLoggerInterceptor = _ts_decorate2([
+  (0, import_common4.Injectable)(),
+  _ts_param2(1, (0, import_common4.Optional)()),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof HttpLoggerOptions === "undefined" ? Object : HttpLoggerOptions
+  ])
+], HttpLoggerInterceptor);
+
+// src/logger/logger.module.ts
+var import_common6 = require("@nestjs/common");
+
+// src/logger/middleware/correlation-id.middleware.ts
+var import_common5 = require("@nestjs/common");
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_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;
+  }
+  // Generates and stores a correlation ID for the incoming request
+  use(_req, reply, next) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    runWithCorrelationContext({
+      correlationId
+    }, () => {
+      next();
+    });
+  }
+  // Fastify onRequest hook that initializes correlation context in AsyncLocalStorage
+  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_decorate3([
+  (0, import_common5.Injectable)(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof CorrelationIdMiddlewareOptions === "undefined" ? Object : CorrelationIdMiddlewareOptions
+  ])
+], CorrelationIdMiddleware);
+
+// src/logger/logger.module.ts
+function _ts_decorate4(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_decorate4, "_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: {
+    provider: "winston",
+    level: "debug",
+    format: "text",
+    enableFileLogger: false,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 1e3
+    }
+  },
+  staging: {
+    provider: "winston",
+    level: "log",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 3e3
+    }
+  },
+  production: {
+    provider: "winston",
+    level: "warn",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: false,
+      enableResponseLog: true,
+      slowRequestThreshold: 5e3
+    }
+  },
+  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: import_common6.Logger,
+    useFactory: /* @__PURE__ */ __name(() => {
+      const logger = new import_common6.Logger();
+      if (options.level) {
+        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: LoggerService,
+    useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+      return new LoggerService(opts, defaultLogger);
+    }, "useFactory"),
+    inject: [
+      LOGGER_MODULE_OPTIONS,
+      {
+        token: import_common6.Logger,
+        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: [
+      LoggerService,
+      LOGGER_MODULE_OPTIONS
+    ]
+  });
+  return providers;
+}
+__name(createLoggerProviders, "createLoggerProviders");
+function getLevelsUpTo(level) {
+  const allLevels = [
+    "error",
+    "warn",
+    "log",
+    "debug",
+    "verbose"
+  ];
+  const isValidLevel = /* @__PURE__ */ __name((l) => allLevels.includes(l), "isValidLevel");
+  if (!isValidLevel(level)) {
+    return [
+      "error",
+      "warn",
+      "log"
+    ];
+  }
+  const levelIndex = allLevels.indexOf(level);
+  return allLevels.slice(0, levelIndex + 1);
+}
+__name(getLevelsUpTo, "getLevelsUpTo");
+var LoggerModule = class _LoggerModule {
+  static {
+    __name(this, "LoggerModule");
+  }
+  // Configures the logger module with static options and environment preset
+  static forRoot(options = {}) {
+    const providers = createLoggerProviders(options);
+    return {
+      module: _LoggerModule,
+      providers,
+      exports: [
+        LoggerService,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  // Configures the logger module with async options (useFactory, useClass, useExisting)
+  static forRootAsync(options) {
+    const asyncProviders = _LoggerModule.createAsyncProviders(options);
+    return {
+      module: _LoggerModule,
+      imports: options.imports || [],
+      providers: [
+        ...asyncProviders,
+        // Default logger provider
+        {
+          provide: import_common6.Logger,
+          useFactory: /* @__PURE__ */ __name((opts) => {
+            if (opts.provider === "default") {
+              const logger = new import_common6.Logger();
+              if (opts.level) {
+                const levels = getLevelsUpTo(opts.level);
+                logger.setLogLevels?.(levels);
+              }
+              return logger;
+            }
+            return null;
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS
+          ]
+        },
+        // Unified logger service
+        {
+          provide: LoggerService,
+          useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+            return new LoggerService(opts, defaultLogger);
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS,
+            {
+              token: import_common6.Logger,
+              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: [
+            LoggerService,
+            LOGGER_MODULE_OPTIONS
+          ]
+        }
+      ],
+      exports: [
+        LoggerService,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  // Middleware registration is handled globally in main.ts via Fastify hooks
+  configure(_consumer) {
+  }
+  // Creates async providers for dynamic module configuration
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        _LoggerModule.createAsyncOptionsProvider(options)
+      ];
+    }
+    const providers = [
+      _LoggerModule.createAsyncOptionsProvider(options)
+    ];
+    if (options.useClass) {
+      providers.push({
+        provide: options.useClass,
+        useClass: options.useClass
+      });
+    }
+    return providers;
+  }
+  // Creates the DI provider that resolves and merges async logger options
+  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_decorate4([
+  (0, import_common6.Global)(),
+  (0, import_common6.Module)({})
+], LoggerModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CorrelationIdMiddleware,
+  DEFAULT_CORRELATION_HEADER,
+  HttpLoggerInterceptor,
+  LOGGER_MODULE_OPTIONS,
+  LoggerModule,
+  LoggerService,
+  addCorrelationIdToResponse,
+  correlationStorage,
+  generateCorrelationId,
+  getCorrelationContext,
+  runWithCorrelationContext,
+  updateCorrelationContext
+});
+//# sourceMappingURL=logger.cjs.map