@adatechnology/logger 0.0.8 → 0.0.10

package/src/logger.interface.ts

@@ -5,21 +5,37 @@ export enum LoggerLevel {
   ERROR = "error",
 }
 
-export interface LogPayload {
+export type LogParams = {
   message: string;
   context?: string;
   meta?: Record<string, unknown>;
-}
+};
+
+export type LogResult = void;
+
+export type DebugParams = LogParams;
+export type DebugResult = LogResult;
+
+export type InfoParams = LogParams;
+export type InfoResult = LogResult;
+
+export type WarnParams = LogParams;
+export type WarnResult = LogResult;
+
+export type ErrorParams = LogParams;
+export type ErrorResult = LogResult;
 
 export interface LoggerProviderInterface {
-  debug(payload: LogPayload): void;
-  info(payload: LogPayload): void;
-  warn(payload: LogPayload): void;
-  error(payload: LogPayload): void;
+  debug(params: DebugParams): DebugResult;
+  info(params: InfoParams): InfoResult;
+  warn(params: WarnParams): WarnResult;
+  error(params: ErrorParams): ErrorResult;
   setContext?(context: string): void;
 }
 
-export type LogParams = {
+export type WriteLogParams = {
   level: LoggerLevel;
-  payload: LogPayload;
+  payload: LogParams;
 };
+
+export type WriteLogResult = LogResult;

package/src/logger.module.ts

@@ -1,6 +1,6 @@
 import { DynamicModule, Module, Scope, Provider, Global } from "@nestjs/common";
 import { LoggerProvider } from "./logger.provider";
-import { LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
+import { LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
 import { WinstonImplementationModule } from "./implementations/winston/winston.logger.module";
 import { HttpLoggingInterceptor } from "./interceptors/http-logging.interceptor";
 import type { LoggerConfig } from "./logger.config";
@@ -26,8 +26,12 @@ export class LoggerModule {
     return {
       module: LoggerModule,
       imports: [implModule],
-      providers: [loggerProvider, httpLoggingInterceptorProvider],
-      exports: [LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR],
+      providers: [
+        { provide: LOGGER_CONFIG, useValue: config ?? {} },
+        loggerProvider,
+        httpLoggingInterceptorProvider,
+      ],
+      exports: [LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 
@@ -43,13 +47,18 @@ export class LoggerModule {
         WinstonImplementationModule.forRootAsync(options),
       ],
       providers: [
+        {
+          provide: LOGGER_CONFIG,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        },
         {
           provide: LOGGER_PROVIDER,
           useClass: LoggerProvider,
         },
         httpLoggingInterceptorProvider,
       ],
-      exports: [LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR],
+      exports: [LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 }

package/src/logger.provider.ts

@@ -1,5 +1,15 @@
 import { Injectable, Inject } from "@nestjs/common";
-import type { LoggerProviderInterface, LogPayload } from "./logger.interface";
+import type {
+  DebugParams,
+  DebugResult,
+  ErrorParams,
+  ErrorResult,
+  InfoParams,
+  InfoResult,
+  LoggerProviderInterface,
+  WarnParams,
+  WarnResult,
+} from "./logger.interface";
 import { WINSTON_LOGGER } from "./implementations/winston/winston.logger.token";
 
 @Injectable()
@@ -9,45 +19,24 @@ export class LoggerProvider implements LoggerProviderInterface {
     private readonly implementation: LoggerProviderInterface,
   ) {}
 
-  debug(payload: LogPayload): void;
-  debug(
-    message: string,
-    meta?: Record<string, unknown>,
-    context?: string,
-  ): void;
-  debug(...args: unknown[]): void {
-    // @ts-ignore - delegate to implementation which supports overloads
-    return this.implementation.debug(...(args as any));
+  debug(params: DebugParams): DebugResult {
+    return this.implementation.debug(params);
   }
 
-  info(payload: LogPayload): void;
-  info(message: string, meta?: Record<string, unknown>, context?: string): void;
-  info(...args: unknown[]): void {
-    // @ts-ignore
-    return this.implementation.info(...(args as any));
+  info(params: InfoParams): InfoResult {
+    return this.implementation.info(params);
   }
 
-  warn(payload: LogPayload): void;
-  warn(message: string, meta?: Record<string, unknown>, context?: string): void;
-  warn(...args: unknown[]): void {
-    // @ts-ignore
-    return this.implementation.warn(...(args as any));
+  warn(params: WarnParams): WarnResult {
+    return this.implementation.warn(params);
   }
 
-  error(payload: LogPayload): void;
-  error(
-    message: string,
-    meta?: Record<string, unknown>,
-    context?: string,
-  ): void;
-  error(...args: unknown[]): void {
-    // @ts-ignore
-    return this.implementation.error(...(args as any));
+  error(params: ErrorParams): ErrorResult {
+    return this.implementation.error(params);
   }
   setContext?(context: string): void {
     if (typeof this.implementation.setContext === "function") {
       return this.implementation.setContext(context);
     }
-    return;
   }
 }

package/src/logger.token.ts

@@ -1,2 +1,3 @@
 export const LOGGER_PROVIDER = "LOGGER_PROVIDER";
+export const LOGGER_CONFIG = "LOGGER_CONFIG";
 export const HTTP_LOGGING_INTERCEPTOR = "HTTP_LOGGING_INTERCEPTOR";