nestjs-fox-logger 0.0.1

package/src/fox-logger-core.module.ts

@@ -0,0 +1,93 @@
+import {
+  DynamicModule,
+  Global,
+  Module,
+  Provider,
+  ValueProvider,
+} from '@nestjs/common';
+
+import { FOXLOGGER_SERVICE_OPTIONS } from './fox-logger.const';
+import {
+  FoxLoggerServiceAsyncOptions,
+  FoxLoggerServiceOptions,
+  FoxLoggerServiceOptionsFactory,
+} from './fox-logger.interfaces';
+import { FoxLoggerService } from './fox-logger.service';
+
+@Global()
+@Module({})
+export class FoxLoggerCoreModule {
+  /** */
+  public static forRoot(options: FoxLoggerServiceOptions): DynamicModule {
+    const LoopModuleOptionsProvider: ValueProvider<FoxLoggerServiceOptions> = {
+      provide: FOXLOGGER_SERVICE_OPTIONS,
+      useValue: options,
+    };
+
+    return {
+      module: FoxLoggerCoreModule,
+      providers: [LoopModuleOptionsProvider, FoxLoggerService],
+      exports: [FoxLoggerService],
+    };
+  }
+
+  public static forRootAsync(
+    options: FoxLoggerServiceAsyncOptions,
+  ): DynamicModule {
+    const providers: Provider[] = this.createAsyncProviders(options);
+
+    return {
+      module: FoxLoggerCoreModule,
+      providers: [
+        /** Providers **/
+        ...providers,
+        /** Services **/
+        FoxLoggerService,
+        /** Extra providers **/
+        ...(options.extraProviders || []),
+      ],
+      imports: options.imports,
+      exports: [
+        /** Services **/
+        FoxLoggerService,
+      ],
+    };
+  }
+
+  public static createAsyncProviders(
+    options: FoxLoggerServiceAsyncOptions,
+  ): Provider[] {
+    const providers: Provider[] = [this.createAsyncOptionsProvider(options)];
+
+    if (options.useClass) {
+      providers.push({
+        provide: options.useClass,
+        useClass: options.useClass,
+      });
+    }
+
+    return providers;
+  }
+
+  private static createAsyncOptionsProvider(
+    options: FoxLoggerServiceAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        name: FOXLOGGER_SERVICE_OPTIONS,
+        provide: FOXLOGGER_SERVICE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+
+    return {
+      name: FOXLOGGER_SERVICE_OPTIONS,
+      provide: FOXLOGGER_SERVICE_OPTIONS,
+      useFactory: async (optionsFactory: FoxLoggerServiceOptionsFactory) => {
+        return optionsFactory.createLoopOptions();
+      },
+      inject: [options.useExisting! || options.useClass!],
+    };
+  }
+}

package/src/fox-logger.const.ts

@@ -0,0 +1 @@
+export const FOXLOGGER_SERVICE_OPTIONS = 'FOXLOGGER_SERVICE_OPTIONS';

package/src/fox-logger.interfaces.ts

@@ -0,0 +1,28 @@
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
+
+export interface FoxLoggerServiceOptions {
+  name?: string;
+  timestamp?: boolean;
+}
+
+export interface FoxLoggerServiceFeatureOptions
+  extends FoxLoggerServiceOptions {
+  name: Required<string>;
+}
+
+export interface FoxLoggerServiceOptionsFactory {
+  createLoopOptions():
+    | Promise<FoxLoggerServiceOptions>
+    | FoxLoggerServiceOptions;
+}
+
+export interface FoxLoggerServiceAsyncOptions
+  extends Pick<ModuleMetadata, 'imports'> {
+  inject?: any[];
+  useClass?: Type<FoxLoggerServiceOptionsFactory>;
+  useExisting?: Type<FoxLoggerServiceOptionsFactory>;
+  useFactory?: (
+    ...args: any[]
+  ) => Promise<FoxLoggerServiceOptions> | FoxLoggerServiceOptions;
+  extraProviders?: Provider[];
+}

package/src/fox-logger.module.ts

@@ -0,0 +1,71 @@
+import { DynamicModule, Module, Provider, ValueProvider } from '@nestjs/common';
+
+import { FOXLOGGER_SERVICE_OPTIONS } from './fox-logger.const';
+import {
+  FoxLoggerServiceAsyncOptions,
+  FoxLoggerServiceOptions,
+} from './fox-logger.interfaces';
+import { FoxLoggerService } from './fox-logger.service';
+import { FoxLoggerCoreModule } from './fox-logger-core.module';
+
+@Module({})
+export class FoxLoggerModule {
+  public static forRoot(options: FoxLoggerServiceOptions): DynamicModule {
+    return {
+      module: FoxLoggerModule,
+      imports: [
+        /** Modules **/
+        FoxLoggerCoreModule.forRoot(options!),
+      ],
+    };
+  }
+
+  public static forRootAsync(
+    options: FoxLoggerServiceAsyncOptions,
+  ): DynamicModule {
+    return {
+      module: FoxLoggerModule,
+      imports: [
+        /** Modules **/
+        FoxLoggerCoreModule.forRootAsync(options),
+      ],
+    };
+  }
+
+  static forFeature(options: FoxLoggerServiceOptions): DynamicModule {
+    const FoxLoggerOptionsProvider: ValueProvider<FoxLoggerServiceOptions> = {
+      provide: FOXLOGGER_SERVICE_OPTIONS,
+      useValue: options,
+    };
+
+    return {
+      module: FoxLoggerModule,
+      imports: [],
+      providers: [FoxLoggerOptionsProvider, FoxLoggerService],
+      exports: [FoxLoggerOptionsProvider, FoxLoggerService],
+    };
+  }
+
+  static forFeatureAsync(options: FoxLoggerServiceAsyncOptions): DynamicModule {
+    const providers: Provider[] =
+      FoxLoggerCoreModule.createAsyncProviders(options);
+
+    return {
+      module: FoxLoggerModule,
+      providers: [
+        /** Providers **/
+        ...providers,
+        /** Services **/
+        FoxLoggerService,
+        /** Extra providers **/
+        ...(options.extraProviders || []),
+      ],
+      imports: options.imports,
+      exports: [
+        ...providers,
+        /** Services **/
+        FoxLoggerService,
+      ],
+    };
+  }
+}

package/src/fox-logger.service.spec.ts

@@ -0,0 +1,163 @@
+import { Logger } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { DeepMockProxy, mockDeep } from 'jest-mock-extended';
+import { ClsModule, ClsService } from 'nestjs-cls';
+
+import { FoxLoggerModule } from './fox-logger.module';
+import { FoxLoggerService } from './fox-logger.service';
+
+describe('FoxLoggerService', () => {
+  let cls: DeepMockProxy<ClsService>;
+  let service: FoxLoggerService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [
+        ClsModule.forRoot({
+          global: true,
+        }),
+        FoxLoggerModule.forFeature({
+          name: 'TEST',
+        }),
+      ],
+      providers: [FoxLoggerService, ClsService],
+    })
+      .overrideProvider(ClsService)
+      .useValue(mockDeep(ClsService))
+      .compile();
+
+    service = module.get(FoxLoggerService);
+    cls = module.get(ClsService);
+  });
+
+  it('should be defined', async () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('.log', () => {
+    beforeEach(async () => {
+      jest.spyOn(Logger, 'log');
+      cls.getId.mockReturnValue('testLogId');
+    });
+
+    it('should call Logger.log', async () => {
+      service.log('test');
+      expect(Logger.log).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call cls.getId()', async () => {
+      expect(cls.getId).toHaveBeenCalledTimes(2);
+    });
+
+    it('should call Logger.log with correct message', () => {
+      expect(Logger.log).toHaveBeenCalledWith(`[TEST][testLogId]: test`);
+    });
+  });
+
+  describe('.warn', () => {
+    beforeEach(() => {
+      jest.spyOn(Logger, 'warn');
+      cls.getId.mockReturnValue('testWarnId');
+    });
+
+    it('should call Logger.warn', async () => {
+      service.warn('test');
+      expect(Logger.warn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call cls.getId()', async () => {
+      expect(cls.getId).toHaveBeenCalledTimes(4);
+    });
+
+    it('should call Logger.warn with correct message', () => {
+      expect(Logger.warn).toHaveBeenCalledWith(`[TEST][testWarnId]: test`);
+    });
+  });
+
+  describe('.error', () => {
+    beforeEach(async () => {
+      jest.spyOn(Logger, 'error');
+      cls.getId.mockReturnValue('testErrId');
+    });
+
+    it('should call Logger.error', async () => {
+      service.error('error');
+      expect(Logger.error).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call cls.getId()', async () => {
+      expect(cls.getId).toHaveBeenCalledWith();
+    });
+
+    it('should call Logger.warn with correct message', () => {
+      expect(Logger.error).toHaveBeenCalledWith(`[TEST][testErrId]: error`);
+    });
+  });
+
+  describe('.error (object)', () => {
+    beforeEach(async () => {
+      jest.spyOn(Logger, 'error');
+    });
+
+    it('should call Logger.error', async () => {
+      cls.getId.mockReturnValue('testErrId');
+
+      service.error({ message: `error!`, statusCode: 500 });
+      expect(Logger.error).toHaveBeenCalledTimes(2);
+    });
+
+    it('should call cls.getId()', async () => {
+      expect(cls.getId).toHaveBeenCalledTimes(8);
+    });
+
+    it('should call Logger.warn with correct message', () => {
+      expect(Logger.error).toHaveBeenCalledWith(
+        `[TEST][testErrId]: [500]: error!`,
+      );
+    });
+  });
+
+  describe('.verbose', () => {
+    beforeEach(() => {
+      jest.spyOn(Logger, 'verbose');
+    });
+
+    it('should call Logger.verbose', async () => {
+      cls.getId.mockReturnValue('testVerboseId');
+
+      service.verbose('verbose');
+      expect(Logger.verbose).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call cls.getId()', async () => {
+      expect(cls.getId).toHaveBeenCalledTimes(10);
+    });
+
+    it('should call Logger.verbose with correct message', () => {
+      expect(Logger.verbose).toHaveBeenCalledWith(
+        `[TEST][testVerboseId]: verbose`,
+      );
+    });
+  });
+
+  describe('.fatal', () => {
+    beforeEach(() => {
+      jest.spyOn(Logger, 'fatal');
+    });
+
+    it('should call Logger.fatal', async () => {
+      cls.getId.mockReturnValue('testFatalId');
+
+      service.fatal('fatal');
+      expect(Logger.fatal).toHaveBeenCalledTimes(1);
+    });
+
+    it('should call cls.getId()', async () => {
+      expect(cls.getId).toHaveBeenCalledTimes(12);
+    });
+
+    it('should call Logger.verbose with correct message', () => {
+      expect(Logger.fatal).toHaveBeenCalledWith(`[TEST][testFatalId]: fatal`);
+    });
+  });
+});

package/src/fox-logger.service.ts

@@ -0,0 +1,88 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ClsService } from 'nestjs-cls';
+
+import { FOXLOGGER_SERVICE_OPTIONS } from './fox-logger.const';
+import { FoxLoggerServiceOptions } from './fox-logger.interfaces';
+
+@Injectable()
+export class FoxLoggerService extends Logger {
+  private readonly name?: string;
+
+  constructor(
+    @Inject(FOXLOGGER_SERVICE_OPTIONS)
+    readonly options: FoxLoggerServiceOptions,
+    private readonly cls?: ClsService,
+  ) {
+    super();
+    this.name = options.name;
+  }
+
+  /** Получение разных  */
+  private formatMsg(msg: unknown) {
+    /** делаем сообщение из разных типов данных */
+    switch (typeof msg) {
+      case 'string':
+        return msg;
+      case 'number':
+      case 'bigint':
+      case 'boolean':
+      case 'symbol':
+      case 'undefined':
+      case 'function':
+        return String(msg);
+      case 'object':
+        /**
+         * Вынимаем данные из разных объектов ошибок
+         * и не только, со статусом и пр.
+         */
+        const prefix = [
+          'statusCode' in msg && `[${msg.statusCode}]`,
+          'status' in msg && `[${msg.status}]`,
+          'error' in msg && `[${msg.error}]`,
+        ].filter(Boolean);
+        if (prefix.length > 0) prefix.push(': ');
+        const message = [
+          msg['response']?.['data']?.['message'] &&
+            `: ${msg['data']['message']}`,
+          msg['data']?.['message'] && `: ${msg['data']['message']}`,
+          msg['message'] && `${msg['message']}`,
+          msg['msg'] && `${msg['msg']}`,
+        ].filter(Boolean);
+        /** Если есть, что отдавать - пишем-с */
+        if (prefix.length + message.length > 0) {
+          return prefix.join(``) + message.join(' ');
+        }
+      /** В противном случае */
+      default:
+        JSON.stringify(msg);
+    }
+  }
+
+  /** Задаем префикс на базе имени, cls и возможного id */
+  private getPrefix(eventId?: string) {
+    return (
+      `${this.name ? `[${this.name}]` : ``}` +
+      `${this.cls.getId() ? `[${this.cls.getId()}]` : ''}` +
+      `${eventId ? `[${eventId}]` : ``}`
+    );
+  }
+
+  public log(msg: any, eventId?: string) {
+    return Logger.log(this.getPrefix(eventId) + `: ` + this.formatMsg(msg));
+  }
+  public warn(msg: any, eventId?: string) {
+    return Logger.warn(this.getPrefix(eventId) + `: ` + this.formatMsg(msg));
+  }
+  public debug(msg: any, eventId?: string) {
+    return Logger.debug(this.getPrefix(eventId) + `: ` + this.formatMsg(msg));
+  }
+  public error(msg: any, eventId?: string) {
+    return Logger.error(this.getPrefix(eventId) + `: ` + this.formatMsg(msg));
+  }
+  public verbose(msg: any, eventId?: string) {
+    return Logger.verbose(this.getPrefix(eventId) + `: ` + this.formatMsg(msg));
+  }
+  public fatal(msg: any, eventId?: string) {
+    return Logger.fatal(this.getPrefix(eventId) + `: ` + this.formatMsg(msg));
+  }
+}