@globalart/nestjs-logger 1.0.5 → 1.0.7

package/dist/constants/index.d.ts

@@ -1,7 +1,10 @@
-export declare const LOGGER_CONFIG_TOKEN = "LOGGER_CONFIG";
-export declare const LOGGER_CONTEXT_METADATA = "LOGGER_CONTEXT";
-export declare const LOGGER_METADATA_METADATA = "LOGGER_METADATA";
-export declare const LOGGER_EXCLUDE_METADATA = "LOGGER_EXCLUDE";
+export declare const LOGGER_CONFIG_TOKEN: unique symbol;
+export declare const LOGGER_SERVICE_TOKEN: unique symbol;
+export declare const LOGGER_CONTEXT_SERVICE_TOKEN: (context: string) => symbol;
+export declare const DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN: unique symbol;
+export declare const LOGGER_CONTEXT_METADATA: unique symbol;
+export declare const LOGGER_METADATA_METADATA: unique symbol;
+export declare const LOGGER_EXCLUDE_METADATA: unique symbol;
 export declare const DEFAULT_SENSITIVE_FIELDS: readonly ["password", "pass", "token", "accessToken", "refreshToken", "secret", "key", "apiKey", "authorization", "auth", "credential", "credentials"];
 export declare const COLORS: {
     readonly reset: "\u001B[0m";

package/dist/constants/index.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_LOGGER_CONFIG = exports.COLORS = exports.DEFAULT_SENSITIVE_FIELDS = exports.LOGGER_EXCLUDE_METADATA = exports.LOGGER_METADATA_METADATA = exports.LOGGER_CONTEXT_METADATA = exports.LOGGER_CONFIG_TOKEN = void 0;
-exports.LOGGER_CONFIG_TOKEN = "LOGGER_CONFIG";
-exports.LOGGER_CONTEXT_METADATA = "LOGGER_CONTEXT";
-exports.LOGGER_METADATA_METADATA = "LOGGER_METADATA";
-exports.LOGGER_EXCLUDE_METADATA = "LOGGER_EXCLUDE";
+exports.DEFAULT_LOGGER_CONFIG = exports.COLORS = exports.DEFAULT_SENSITIVE_FIELDS = exports.LOGGER_EXCLUDE_METADATA = exports.LOGGER_METADATA_METADATA = exports.LOGGER_CONTEXT_METADATA = exports.DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN = exports.LOGGER_CONTEXT_SERVICE_TOKEN = exports.LOGGER_SERVICE_TOKEN = exports.LOGGER_CONFIG_TOKEN = void 0;
+exports.LOGGER_CONFIG_TOKEN = Symbol("LOGGER_CONFIG");
+exports.LOGGER_SERVICE_TOKEN = Symbol("LOGGER_SERVICE");
+const LOGGER_CONTEXT_SERVICE_TOKEN = (context) => Symbol(`LOGGER_SERVICE_${context}`);
+exports.LOGGER_CONTEXT_SERVICE_TOKEN = LOGGER_CONTEXT_SERVICE_TOKEN;
+exports.DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN = Symbol("DYNAMIC_CONTEXT_LOGGER_FACTORY");
+exports.LOGGER_CONTEXT_METADATA = Symbol("LOGGER_CONTEXT");
+exports.LOGGER_METADATA_METADATA = Symbol("LOGGER_METADATA");
+exports.LOGGER_EXCLUDE_METADATA = Symbol("LOGGER_EXCLUDE");
 exports.DEFAULT_SENSITIVE_FIELDS = [
     "password",
     "pass",

package/dist/contracts/index.d.ts

@@ -5,7 +5,6 @@ export interface ILogger {
     warn(options: LogOptions): void;
     debug(options: LogOptions): void;
     verbose(options: LogOptions): void;
-    setContext(context: string): void;
     logHttpRequest(entry: HttpRequestLogEntry): void;
 }
 export interface ILogFormatter {

package/dist/core/logger.di-tokens.d.ts

@@ -0,0 +1,3 @@
+export declare const InjectLogger: (context?: string) => PropertyDecorator & ParameterDecorator;
+export declare const getContextLoggerToken: (context: string) => symbol;
+export declare const getAllContextTokens: () => string[];

package/dist/core/logger.di-tokens.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllContextTokens = exports.getContextLoggerToken = exports.InjectLogger = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const contextLoggerCache = new Map();
+const InjectLogger = (context) => {
+    if (context) {
+        if (!contextLoggerCache.has(context)) {
+            contextLoggerCache.set(context, Symbol(`LOGGER_CONTEXT_${context}`));
+        }
+        return (0, common_1.Inject)(contextLoggerCache.get(context));
+    }
+    return (0, common_1.Inject)(constants_1.LOGGER_SERVICE_TOKEN);
+};
+exports.InjectLogger = InjectLogger;
+const getContextLoggerToken = (context) => {
+    if (!contextLoggerCache.has(context)) {
+        contextLoggerCache.set(context, Symbol(`LOGGER_CONTEXT_${context}`));
+    }
+    return contextLoggerCache.get(context);
+};
+exports.getContextLoggerToken = getContextLoggerToken;
+const getAllContextTokens = () => {
+    return Array.from(contextLoggerCache.keys());
+};
+exports.getAllContextTokens = getAllContextTokens;

package/dist/core/logger.module.d.ts

@@ -19,4 +19,5 @@ export declare class LoggerModule {
     private static createConfiguration;
     private static createProviders;
     private static createCoreProviders;
+    private static createDynamicContextProviders;
 }

package/dist/core/logger.module.js

@@ -13,19 +13,27 @@ const core_1 = require("@nestjs/core");
 const logger_service_1 = require("./logger.service");
 const http_logger_interceptor_1 = require("./http-logger.interceptor");
 const formatter_factory_1 = require("../factories/formatter.factory");
+const dynamic_context_logger_factory_1 = require("../factories/dynamic-context-logger.factory");
 const console_writer_1 = require("../writers/console-writer");
 const context_resolver_1 = require("../utils/context-resolver");
 const data_sanitizer_1 = require("../utils/data-sanitizer");
 const request_id_generator_1 = require("../utils/request-id-generator");
 const constants_1 = require("../constants");
+const logger_di_tokens_1 = require("./logger.di-tokens");
 let LoggerModule = LoggerModule_1 = class LoggerModule {
     static forRoot(options = {}) {
         const config = this.createConfiguration(options);
         const providers = this.createProviders(config);
+        const contextProviders = this.createDynamicContextProviders();
         return {
             module: LoggerModule_1,
-            providers,
-            exports: [logger_service_1.LoggerService, http_logger_interceptor_1.HttpLoggerInterceptor],
+            providers: [...providers, ...contextProviders],
+            exports: [
+                constants_1.LOGGER_SERVICE_TOKEN,
+                http_logger_interceptor_1.HttpLoggerInterceptor,
+                constants_1.DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN,
+                ...contextProviders.map((p) => p.provide),
+            ],
             global: true,
         };
     }
@@ -39,10 +47,16 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
             inject: options.inject || [],
         };
         const providers = [configProvider, ...this.createCoreProviders()];
+        const contextProviders = this.createDynamicContextProviders();
         return {
             module: LoggerModule_1,
-            providers,
-            exports: [logger_service_1.LoggerService, http_logger_interceptor_1.HttpLoggerInterceptor],
+            providers: [...providers, ...contextProviders],
+            exports: [
+                constants_1.LOGGER_SERVICE_TOKEN,
+                http_logger_interceptor_1.HttpLoggerInterceptor,
+                constants_1.DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN,
+                ...contextProviders.map((p) => p.provide),
+            ],
             global: true,
         };
     }
@@ -75,7 +89,11 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
                 inject: [constants_1.LOGGER_CONFIG_TOKEN],
             },
             {
-                provide: logger_service_1.LoggerService,
+                provide: constants_1.DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN,
+                useClass: dynamic_context_logger_factory_1.DynamicContextLoggerFactory,
+            },
+            {
+                provide: constants_1.LOGGER_SERVICE_TOKEN,
                 useFactory: (config, formatterFactory, writer, contextResolver) => {
                     const formatter = formatterFactory.create(config.format, {
                         colors: config.colors,
@@ -98,7 +116,7 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
                     return new http_logger_interceptor_1.HttpLoggerInterceptor(logger, dataSanitizer, requestIdGenerator, config, reflector);
                 },
                 inject: [
-                    logger_service_1.LoggerService,
+                    constants_1.LOGGER_SERVICE_TOKEN,
                     data_sanitizer_1.DataSanitizer,
                     request_id_generator_1.RequestIdGenerator,
                     constants_1.LOGGER_CONFIG_TOKEN,
@@ -106,6 +124,14 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
             },
         ];
     }
+    static createDynamicContextProviders() {
+        const contextNames = (0, logger_di_tokens_1.getAllContextTokens)();
+        return contextNames.map((context) => ({
+            provide: (0, logger_di_tokens_1.getContextLoggerToken)(context),
+            useFactory: (factory) => factory.createLogger(context),
+            inject: [constants_1.DYNAMIC_CONTEXT_LOGGER_FACTORY_TOKEN],
+        }));
+    }
 };
 exports.LoggerModule = LoggerModule;
 exports.LoggerModule = LoggerModule = LoggerModule_1 = __decorate([

package/dist/decorators/index.d.ts

@@ -1,12 +1,13 @@
+import { LOGGER_CONTEXT_METADATA, LOGGER_METADATA_METADATA, LOGGER_EXCLUDE_METADATA } from "../constants";
 /**
  * Decorator to set logging context for a class or method
  */
-export declare const LogContext: (context: string) => import("@nestjs/common").CustomDecorator<string>;
+export declare const LogContext: (context: string) => import("@nestjs/common").CustomDecorator<typeof LOGGER_CONTEXT_METADATA>;
 /**
  * Decorator to add metadata to logs
  */
-export declare const LogMetadata: (metadata: Record<string, unknown>) => import("@nestjs/common").CustomDecorator<string>;
+export declare const LogMetadata: (metadata: Record<string, unknown>) => import("@nestjs/common").CustomDecorator<typeof LOGGER_METADATA_METADATA>;
 /**
  * Decorator to exclude logging for a controller or method
  */
-export declare const ExcludeLogging: () => import("@nestjs/common").CustomDecorator<string>;
+export declare const ExcludeLogging: () => import("@nestjs/common").CustomDecorator<typeof LOGGER_EXCLUDE_METADATA>;

package/dist/factories/dynamic-context-logger.factory.d.ts

@@ -0,0 +1,14 @@
+import { LoggerService } from "../core/logger.service";
+import { FormatterFactory } from "./formatter.factory";
+import { ConsoleWriter } from "../writers/console-writer";
+import { ContextResolver } from "../utils/context-resolver";
+import { LoggerConfiguration } from "../types";
+export declare class DynamicContextLoggerFactory {
+    private readonly config;
+    private readonly formatterFactory;
+    private readonly writer;
+    private readonly contextResolver;
+    private readonly loggerCache;
+    constructor(config: LoggerConfiguration, formatterFactory: FormatterFactory, writer: ConsoleWriter, contextResolver: ContextResolver);
+    createLogger(context: string): LoggerService;
+}

package/dist/factories/dynamic-context-logger.factory.js

@@ -0,0 +1,52 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicContextLoggerFactory = void 0;
+const common_1 = require("@nestjs/common");
+const logger_service_1 = require("../core/logger.service");
+const formatter_factory_1 = require("./formatter.factory");
+const console_writer_1 = require("../writers/console-writer");
+const context_resolver_1 = require("../utils/context-resolver");
+const constants_1 = require("../constants");
+let DynamicContextLoggerFactory = class DynamicContextLoggerFactory {
+    constructor(config, formatterFactory, writer, contextResolver) {
+        this.config = config;
+        this.formatterFactory = formatterFactory;
+        this.writer = writer;
+        this.contextResolver = contextResolver;
+        this.loggerCache = new Map();
+    }
+    createLogger(context) {
+        if (this.loggerCache.has(context)) {
+            return this.loggerCache.get(context);
+        }
+        const formatter = this.formatterFactory.create(this.config.format, {
+            colors: this.config.colors,
+            timestamp: this.config.timestamp,
+            context: this.config.context,
+        });
+        const logger = new logger_service_1.LoggerService(this.config, formatter, this.writer, this.contextResolver);
+        logger.setContext(context);
+        this.loggerCache.set(context, logger);
+        return logger;
+    }
+};
+exports.DynamicContextLoggerFactory = DynamicContextLoggerFactory;
+exports.DynamicContextLoggerFactory = DynamicContextLoggerFactory = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_1.LOGGER_CONFIG_TOKEN)),
+    __metadata("design:paramtypes", [Object, formatter_factory_1.FormatterFactory,
+        console_writer_1.ConsoleWriter,
+        context_resolver_1.ContextResolver])
+], DynamicContextLoggerFactory);

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { LoggerModule, LoggerModuleOptions, LoggerModuleAsyncOptions, } from "./core/logger.module";
+export { InjectLogger } from "./core/logger.di-tokens";
 export { LoggerService } from "./core/logger.service";
 export { HttpLoggerInterceptor } from "./core/http-logger.interceptor";
+export { DynamicContextLoggerFactory } from "./factories/dynamic-context-logger.factory";
 export { LogContext, LogMetadata, ExcludeLogging } from "./decorators";
 export * from "./types";
 export * from "./contracts";

package/dist/index.js

@@ -14,19 +14,24 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExcludeLogging = exports.LogMetadata = exports.LogContext = exports.HttpLoggerInterceptor = exports.LoggerService = exports.LoggerModule = void 0;
+exports.ExcludeLogging = exports.LogMetadata = exports.LogContext = exports.DynamicContextLoggerFactory = exports.HttpLoggerInterceptor = exports.LoggerService = exports.InjectLogger = exports.LoggerModule = void 0;
 // Core
 var logger_module_1 = require("./core/logger.module");
 Object.defineProperty(exports, "LoggerModule", { enumerable: true, get: function () { return logger_module_1.LoggerModule; } });
+var logger_di_tokens_1 = require("./core/logger.di-tokens");
+Object.defineProperty(exports, "InjectLogger", { enumerable: true, get: function () { return logger_di_tokens_1.InjectLogger; } });
 var logger_service_1 = require("./core/logger.service");
 Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return logger_service_1.LoggerService; } });
 var http_logger_interceptor_1 = require("./core/http-logger.interceptor");
 Object.defineProperty(exports, "HttpLoggerInterceptor", { enumerable: true, get: function () { return http_logger_interceptor_1.HttpLoggerInterceptor; } });
+// Factories
+var dynamic_context_logger_factory_1 = require("./factories/dynamic-context-logger.factory");
+Object.defineProperty(exports, "DynamicContextLoggerFactory", { enumerable: true, get: function () { return dynamic_context_logger_factory_1.DynamicContextLoggerFactory; } });
+// Decorators
 var decorators_1 = require("./decorators");
 Object.defineProperty(exports, "LogContext", { enumerable: true, get: function () { return decorators_1.LogContext; } });
 Object.defineProperty(exports, "LogMetadata", { enumerable: true, get: function () { return decorators_1.LogMetadata; } });
 Object.defineProperty(exports, "ExcludeLogging", { enumerable: true, get: function () { return decorators_1.ExcludeLogging; } });
-// Types
+// Types and Contracts
 __exportStar(require("./types"), exports);
-// Contracts
 __exportStar(require("./contracts"), exports);

package/dist/types/index.d.ts

@@ -11,15 +11,11 @@ export interface LogEntry {
     readonly metadata?: Record<string, unknown>;
     readonly trace?: string;
 }
-export interface HttpRequestLogEntry {
-    readonly level: number;
-    readonly time: number;
-    readonly pid: number;
-    readonly hostname: string;
-    readonly req: HttpRequest;
-    readonly res: HttpResponse;
-    readonly responseTime: number;
-    readonly msg: string;
+export interface LogOptions {
+    message: string;
+    context?: string;
+    metadata?: Record<string, unknown>;
+    trace?: string;
 }
 export interface HttpRequest {
     readonly id: string;
@@ -36,6 +32,16 @@ export interface HttpResponse {
     readonly statusCode: number;
     readonly headers: Record<string, string>;
 }
+export interface HttpRequestLogEntry {
+    readonly level: number;
+    readonly time: number;
+    readonly pid: number;
+    readonly hostname: string;
+    readonly req: HttpRequest;
+    readonly res: HttpResponse;
+    readonly responseTime: number;
+    readonly msg: string;
+}
 export interface ExcludeOption {
     method: RequestMethod;
     path: string;
@@ -54,9 +60,31 @@ export interface FormatterOptions {
     readonly timestamp: boolean;
     readonly context?: string;
 }
-export interface LogOptions {
-    message: string;
+export interface LoggerOptions {
+    level?: LogLevel;
+    timestamp?: boolean;
+    colors?: boolean;
     context?: string;
-    metadata?: Record<string, unknown>;
-    trace?: string;
+    format?: LogFormat;
+    transports?: LoggerTransport[];
+    pino?: PinoOptions;
+}
+export interface PinoOptions {
+    level?: string;
+    timestamp?: boolean;
+    base?: boolean;
+    name?: string;
+    enabled?: boolean;
+}
+export interface LoggerTransport {
+    name: string;
+    level?: string;
+    format?: unknown;
+    filename?: string;
+    dirname?: string;
+    maxsize?: number;
+    maxFiles?: number;
+}
+export interface LoggerMetadata {
+    [key: string]: unknown;
 }

package/dist/types/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PINO_LEVELS = exports.LOG_LEVELS = void 0;
+// Log Level Constants
 exports.LOG_LEVELS = {
     error: 50,
     warn: 40,

package/dist/utils/context-resolver.js

@@ -40,7 +40,6 @@ let ContextResolver = class ContextResolver {
         return skipPatterns.some((pattern) => line.includes(pattern));
     }
     extractClassName(line) {
-        // Пытаемся найти имя класса в различных форматах
         const patterns = [
             /at\s+(\w+)\./, // at ClassName.method
             /at\s+.*\.(\w+)\s+\(/, // at path.ClassName (
@@ -55,7 +54,6 @@ let ContextResolver = class ContextResolver {
         return null;
     }
     isValidClassName(name) {
-        // Проверяем, что это валидное имя класса (начинается с заглавной буквы)
         return (/^[A-Z][a-zA-Z0-9]*$/.test(name) &&
             name !== "Object" &&
             name !== "Function" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@globalart/nestjs-logger",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A advanced logger for NestJS",
   "author": {
     "name": "GlobalArt, Inc"

package/dist/interceptors/index.d.ts

@@ -1 +0,0 @@
-export { HttpLoggerInterceptor } from "../core/http-logger.interceptor";

package/dist/interceptors/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpLoggerInterceptor = void 0;
-var http_logger_interceptor_1 = require("../core/http-logger.interceptor");
-Object.defineProperty(exports, "HttpLoggerInterceptor", { enumerable: true, get: function () { return http_logger_interceptor_1.HttpLoggerInterceptor; } });

package/dist/interfaces/index.d.ts

@@ -1,59 +0,0 @@
-export interface LoggerOptions {
-    level?: "error" | "warn" | "log" | "debug" | "verbose";
-    timestamp?: boolean;
-    colors?: boolean;
-    context?: string;
-    format?: "json" | "text" | "pino";
-    transports?: LoggerTransport[];
-    pino?: PinoOptions;
-}
-export interface PinoOptions {
-    level?: string;
-    timestamp?: boolean;
-    base?: boolean;
-    name?: string;
-    enabled?: boolean;
-}
-export interface LoggerTransport {
-    name: string;
-    level?: string;
-    format?: any;
-    filename?: string;
-    dirname?: string;
-    maxsize?: number;
-    maxFiles?: number;
-}
-export interface LogContext {
-    timestamp?: string;
-    level: string;
-    message: string;
-    context?: string;
-    trace?: string;
-    metadata?: Record<string, any>;
-}
-export interface LoggerMetadata {
-    [key: string]: any;
-}
-export interface RequestLogData {
-    req: {
-        id: number;
-        method: string;
-        url: string;
-        query: Record<string, any>;
-        params: Record<string, any>;
-        headers: Record<string, any>;
-        remoteAddress: string;
-        remotePort?: number;
-        body?: any;
-    };
-    res: {
-        statusCode: number;
-        headers: Record<string, any>;
-    };
-    responseTime: number;
-    msg: string;
-    level: number;
-    time: number;
-    pid: number;
-    hostname: string;
-}

package/dist/interfaces/index.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });