fix: refactoring

Author: zemd

.npmignore

@@ -3,3 +3,4 @@
 .node-version
 .editorconfig
 *.tsbuildinfo
+package-lock.json

README.md

@@ -41,7 +41,11 @@ import pinoHttpConfig from "./config/pino-http.config";
             load: [pinoConfig, pinoHttpConfig],
             // ... any other configuration options you want to use
         }),
-        LoggerModule
+        LoggerModule.forRootAsync({
+            imports: [ConfigModule],
+            useFactory: (configService: ConfigService) => configService.get<LoggerOptions>('pino'),
+            inject: [ConfigService],
+        }),
     ]
 })
 class AppModule {}
@@ -51,17 +55,17 @@ then you should inject `Logger` into your main app:
 
 ```typescript
 // main.ts
-import { Logger } from '@zemd/nestjs-pino-logger';
+import {Logger, PINO_LOGGER_INSTANCE} from '@zemd/nestjs-pino-logger';
 import pinoHttp from "pino-http";
-import type { Options } from 'pino-http';
+import type {Options} from 'pino-http';
 
-const app = await NestFactory.create(AppModule, { bufferLogs: true });
+const app = await NestFactory.create(AppModule, {bufferLogs: true});
 app.useLogger(app.get(Logger));
 
 // if you want to use pino-http ↓
 app.use(pinoHttp({
-    ...configService.get<Options>('pino-http'),
-    logger: app.get(Logger).getPinoInstance(),
+  ...configService.get<Options>('pino-http'),
+  logger: app.get(PINO_LOGGER_INSTANCE),
 }));
 ```
 
@@ -150,7 +154,11 @@ In case if you want extend pino log object by adding more fields, you can use `b
 It looks like:
 
 ```typescript
-const message = buildPinoMessage('Hello World %o', { foo: 'bar' }, { data: 'the data object will be used to format the message' });
+const message = buildPinoMessage({
+  message: 'Hello World %o',
+  mergingObject: { foo: 'bar' },
+  interpolationValues: [{ data: 'the data object will be used to format the message' }]
+});
 this.logger.log(message, 'here you can also pass something that will be added to the msg string');
 ```
 

src/Logger.ts

@@ -1,17 +1,14 @@
 import {Injectable, LoggerService} from "@nestjs/common";
 import * as util from "node:util";
-import pino from "pino";
-import {ConfigService} from "@nestjs/config";
+import type {Logger as PinoLogger} from "pino";
 import crypto from "node:crypto";
-import {PinoMessageSymbol} from "./PinoMessageSymbol";
+import {PinoMessageSymbol} from "./logger.constants";
 
 @Injectable()
 export class Logger implements LoggerService {
-  private readonly pinoInstance: any;
   private static cache = new Map<string, any>();
 
-  constructor(private readonly configService: ConfigService) {
-    this.pinoInstance = pino(this.configService.get('pino'));
+  constructor(private readonly pinoInstance: PinoLogger) {
   }
 
   debug(message: any, ...optionalParams: any[]): any {
@@ -83,8 +80,4 @@ export class Logger implements LoggerService {
     Logger.cache.set(ctx, {inst, timeout});
     return inst;
   }
-
-  public getPinoInstance() {
-    return this.pinoInstance;
-  }
 }

src/PinoMessageSymbol.ts

@@ -1,14 +1,16 @@
-import {PinoMessageSymbol} from "./PinoMessageSymbol";
+import {PinoMessageSymbol} from "./logger.constants";
 
-export const buildPinoMessage = (
-  message: string,
-  mergingObject?: Record<string, any>,
-  ...interpolationValues: any[]
-) => {
+export type PinoMessageType = {
+  message: string;
+  mergingObject?: Record<string, any>;
+  interpolationValues?: any[];
+};
+
+export const buildPinoMessage = (message: PinoMessageType) => {
   return {
     [PinoMessageSymbol]: true,
-    mergingObject,
-    message,
-    interpolationValues,
+    mergingObject: message.mergingObject,
+    message: message.message,
+    interpolationValues: message.interpolationValues
   };
 }

src/buildPinoMessage.ts

@@ -1,6 +1,5 @@
 export {LoggerModule} from "./logger.module";
 export {Logger} from "./Logger";
-export {PinoMessageSymbol} from "./PinoMessageSymbol";
 export {buildPinoMessage} from "./buildPinoMessage";
-export {customLevels} from "./config";
-export {default as PinoPrettyTransport} from "./pino-pretty-transport";
+export {default as PinoPrettyTransport} from "./pino-pretty-transport";
+export * from "./logger.constants";

src/config.ts

@@ -0,0 +1,10 @@
+export const PinoMessageSymbol = Symbol('__PinoMessageSymbol');
+export const PINO_LOGGER_OPTIONS = 'PinoLoggerOptions';
+export const PINO_LOGGER_INSTANCE = 'PinoLoggerInstance';
+export const customLevels = {
+  error: 50,
+  warn: 40,
+  log: 30,
+  debug: 20,
+  verbose: 10,
+} as const;

src/index.ts

@@ -1,12 +1,65 @@
-import {Global, Module, NestModule} from "@nestjs/common";
+import {DynamicModule, Global, Module, ModuleMetadata, Provider} from "@nestjs/common";
 import {Logger} from "./Logger";
+import {PINO_LOGGER_INSTANCE, PINO_LOGGER_OPTIONS} from "./logger.constants";
+import type {LoggerOptions} from "pino";
+import pino from "pino";
+
+export interface LoggerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  inject?: any[];
+  useFactory?: (...args: any[]) => Promise<LoggerOptions> | LoggerOptions;
+}
 
 @Global()
-@Module({
-  providers: [Logger],
-  exports: [Logger],
-})
-export class LoggerModule implements NestModule {
-  configure(): any {
+@Module({})
+export class LoggerModule {
+  constructor() {
+  }
+
+  static forRoot(options: LoggerOptions): DynamicModule {
+    const loggerModuleOptions = {
+      provide: PINO_LOGGER_OPTIONS,
+      useValue: options,
+    };
+
+    const pinoProvider: Provider = {
+      provide: PINO_LOGGER_INSTANCE,
+      useFactory: () => {
+        return pino(options);
+      },
+    };
+
+    return {
+      module: LoggerModule,
+      providers: [loggerModuleOptions, pinoProvider, Logger],
+      exports: [loggerModuleOptions, pinoProvider, Logger]
+    };
+  }
+
+  static forRootAsync(options: LoggerModuleAsyncOptions): DynamicModule {
+    const providers: Provider[] = [
+      Logger
+    ];
+
+    const pinoProvider: Provider = {
+      provide: PINO_LOGGER_INSTANCE,
+      useFactory: async (options: LoggerOptions) => pino(options),
+      inject: [PINO_LOGGER_OPTIONS],
+    }
+    providers.push(pinoProvider);
+
+    if (options.useFactory) {
+      providers.push({
+        provide: PINO_LOGGER_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      });
+    }
+
+    return {
+      module: LoggerModule,
+      imports: options.imports ?? [],
+      providers,
+      exports: [pinoProvider, Logger]
+    };
   }
 }