@nest-yalc-2/logger 1.0.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@nest-yalc-2/logger",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.js",
+  "exports": {
+    "./": "./src/"
+  },
+  "author": "",
+  "license": "AGPL-3.0-or-later",
+  "types": "./src/index.d.ts",
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nek97/nestjs-yalc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Nek97/nestjs-yalc/issues"
+  },
+  "homepage": "https://github.com/Nek97/nestjs-yalc#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "tslib": "^2.8.1"
+  }
+}

package/src/__tests__/logger-console.service.spec.ts

@@ -0,0 +1,136 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { type ConsoleLogger as TConsoleLogger } from '../logger-console.service.js';
+
+/**
+ * Not sure why this is needed, but it is. Jest has reference errors when try to import the logger-console.service.js file
+ * probably still caused by the ESM
+ */
+jest.unstable_mockModule('@nest-yalc-2/logger/logger.factory.js', async () => {
+  return {
+    AppLoggerFactory: jest.fn(),
+  };
+});
+
+import { ConsoleLogger } from '../logger-console.service.js';
+import { LOG_LEVEL_ALL } from '../logger.enum.js';
+
+const logOptions = {
+  context: 'test',
+  data: { pass: 'data' },
+  masks: ['pass'],
+};
+
+describe('Console logger service test', () => {
+  let logger: TConsoleLogger;
+
+  beforeEach(async () => {
+    logger = new ConsoleLogger('test', LOG_LEVEL_ALL);
+  });
+
+  it('Test undefined levels', async () => {
+    const methodLog = jest.spyOn(console, 'log');
+    const methodError = jest.spyOn(console, 'error');
+    const methodWarn = jest.spyOn(console, 'warn');
+    logger = new ConsoleLogger('test', undefined);
+    logger.log('test');
+    logger.error('test');
+    logger.warn('test');
+
+    expect(methodLog).not.toHaveBeenCalled();
+    expect(methodError).not.toHaveBeenCalled();
+    expect(methodWarn).not.toHaveBeenCalled();
+  });
+
+  it('Test log', async () => {
+    const method = jest.spyOn(console, 'log');
+    logger.log('test');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test log with options', async () => {
+    const method = jest.spyOn(console, 'log');
+    logger.log('test', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test error', async () => {
+    const method = jest.spyOn(console, 'error');
+    logger.error('error', 'trace', { data: 'test' });
+
+    expect(method).toHaveBeenCalled();
+    expect(method).toHaveBeenCalledWith('[test]', 'error', 'trace', {
+      message: 'test',
+    });
+  });
+
+  it('Test error with options', async () => {
+    const method = jest.spyOn(console, 'error');
+    logger.error('test', undefined, logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test warn', async () => {
+    const method = jest.spyOn(console, 'warn');
+    logger.warn('warn');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test warn with options', async () => {
+    const method = jest.spyOn(console, 'warn');
+    logger.warn('test', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test debug', async () => {
+    const method = jest.spyOn(console, 'debug');
+    logger.debug?.('debug');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test debug with options', async () => {
+    const method = jest.spyOn(console, 'debug');
+    logger.debug?.('test', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test verbose', async () => {
+    const method = jest.spyOn(console, 'info');
+    logger.verbose?.('verbose');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test verbose with options', async () => {
+    const method = jest.spyOn(console, 'info');
+    logger.verbose?.('test', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('setLogLevels should validate levels and emit events', async () => {
+    const emitter = { emit: jest.fn() } as any;
+    logger.setLogLevels(LOG_LEVEL_ALL);
+    logger.error('boom', 'trace', { eventEmitter: emitter, useFallbackEvent: true });
+    expect(emitter.emit).toHaveBeenCalled();
+    emitter.emit.mockClear();
+    logger.error('skip', 'trace', { eventEmitter: emitter, event: false as any });
+    expect(emitter.emit).not.toHaveBeenCalled();
+    expect(() => logger.setLogLevels(['invalid' as any])).toThrow();
+  });
+});

package/src/__tests__/logger-nest.service.spec.ts

@@ -0,0 +1,39 @@
+import { expect, describe, it } from '@jest/globals';
+import { ImprovedNestLogger } from '../index.js';
+
+describe('Nest logger service test', () => {
+  it('Test log', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.log('test');
+  });
+
+  it('Test log with string options', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.log('test', 'string options');
+  });
+
+  it('Test log with masked data', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.log('test', { masks: ['pass'], data: { pass: 'data' } });
+  });
+
+  it('Test error', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.error('error', 'trace');
+  });
+
+  it('Test warn', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.warn('warn');
+  });
+
+  it('Test debug', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.debug?.('debug');
+  });
+
+  it('Test verbose', async () => {
+    const logger = new ImprovedNestLogger('test', {});
+    logger.verbose?.('verbose');
+  });
+});

package/src/__tests__/logger-pino.service.spec.ts

@@ -0,0 +1,149 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  afterEach,
+} from '@jest/globals';
+
+import { Logger } from 'pino';
+import { PinoLogger, FLUSH_INTERVAL, flush } from '../index.js';
+import { LOG_LEVEL_ALL } from '../logger.enum.js';
+
+const logOptions = {
+  context: 'test',
+  data: { pass: 'data' },
+  masks: ['pass'],
+};
+
+describe('Pino logger service test', () => {
+  let pino: Logger;
+  const container: { logger?: PinoLogger } = {
+    logger: new PinoLogger('test', LOG_LEVEL_ALL),
+  };
+
+  beforeEach(async () => {
+    container.logger = new PinoLogger('test', LOG_LEVEL_ALL);
+    pino = container.logger?.getLogger();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('Test log', async () => {
+    const method = jest.spyOn(pino, 'info');
+    container.logger?.log('test');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test log with options', async () => {
+    const method = jest.spyOn(pino, 'info');
+    container.logger?.log('info', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test error', async () => {
+    const method = jest.spyOn(pino, 'error');
+    container.logger?.error('error', 'trace');
+
+    expect(method).toHaveBeenCalled();
+    // expect(method).toHaveBeenCalledWith({ context: 'test' }, 'error trace');
+  });
+
+  it('Test error with options', async () => {
+    const method = jest.spyOn(pino, 'error');
+    container.logger?.error('error', undefined, logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test warn', async () => {
+    const method = jest.spyOn(pino, 'warn');
+    container.logger?.warn('warn');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test warn with options', async () => {
+    const method = jest.spyOn(pino, 'warn');
+    container.logger?.warn('warn', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test debug', async () => {
+    const method = jest.spyOn(pino, 'debug');
+    container.logger?.debug?.('debug');
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test debug with options', async () => {
+    const method = jest.spyOn(pino, 'debug');
+    container.logger?.debug?.('debug', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test verbose with options', async () => {
+    const method = jest.spyOn(pino, 'trace');
+    container.logger?.verbose?.('verbose', logOptions);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test verbose & flush', async () => {
+    jest.useFakeTimers();
+
+    jest.mock('process', () => ({
+      on: jest.fn((fn) => {
+        fn();
+      }),
+    }));
+
+    const _logger = new PinoLogger('test', LOG_LEVEL_ALL);
+
+    const method = jest.spyOn(pino, 'trace');
+    _logger.verbose?.('verbose');
+
+    // Fast-forward until all timers have been executed
+    jest.advanceTimersByTime(FLUSH_INTERVAL + 1000);
+
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test on application shutdown', async () => {
+    const method = jest.spyOn(pino, 'info');
+    container.logger?.log('test');
+    await container.logger?.onApplicationShutdown();
+    expect(method).toHaveBeenCalledWith({ context: 'test' }, 'test');
+  });
+
+  it('Test flush when logger has been destroyed', async () => {
+    const method = jest.spyOn(pino, 'flush');
+    method.mockImplementation((callback: any) => {
+      callback();
+    });
+
+    delete container.logger;
+    await flush();
+    expect(container.logger).toBeUndefined();
+    expect(method).toHaveBeenCalled();
+  });
+
+  it('Test flush with error', async () => {
+    const method = jest.spyOn(pino, 'flush');
+    method.mockImplementation((callback: any) => {
+      callback(new Error('test'));
+    });
+
+    expect(
+      async () => await container.logger?.onApplicationShutdown(),
+    ).rejects.toThrow();
+    expect(method).toHaveBeenCalled();
+  });
+});

package/src/__tests__/logger.factory.spec.ts

@@ -0,0 +1,69 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+
+class NestLogger {
+  setLogLevels: jest.Mock<any>;
+  static overrideLogger = jest.fn();
+}
+
+jest.mock('@nestjs/common', () => ({
+  ...(jest.requireActual('@nestjs/common') as any),
+  Logger: NestLogger,
+}));
+
+import { LogLevelEnum, LoggerTypeEnum } from '../logger.enum.js';
+import { AppLoggerFactory } from '../logger.factory.js';
+import { PinoLogger } from '../logger-pino.service.js';
+
+describe('AppLoggerFactory', () => {
+  // let mockConfigService;
+  let logger;
+
+  it('No configuration test', async () => {
+    logger = AppLoggerFactory(
+      'test',
+      [LogLevelEnum.DEBUG],
+      LoggerTypeEnum.CONSOLE,
+    );
+    expect(logger).toBeDefined();
+
+    logger = AppLoggerFactory(
+      'test',
+      [LogLevelEnum.DEBUG],
+      LoggerTypeEnum.PINO,
+    );
+    expect(logger).toBeDefined();
+    expect(logger instanceof PinoLogger).toBeTruthy();
+
+    logger = AppLoggerFactory(
+      'test',
+      [LogLevelEnum.DEBUG],
+      LoggerTypeEnum.NEST,
+    );
+    expect(logger).toBeDefined();
+
+    logger = AppLoggerFactory('test', [LogLevelEnum.DEBUG]);
+    expect(logger).toBeDefined();
+
+    logger = AppLoggerFactory('test', []);
+    expect(logger).toBeDefined();
+  });
+
+  it('No configuration test', async () => {
+    logger = AppLoggerFactory('test');
+    expect(logger).toBeDefined();
+
+    NestLogger.prototype.setLogLevels = jest.fn();
+
+    logger = AppLoggerFactory('test', [LogLevelEnum.DEBUG]);
+    expect(logger).toBeDefined();
+  });
+});

package/src/__tests__/logger.helper.spec.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from '@jest/globals';
+
+import * as loggerHelper from '../logger.helper.js';
+
+const testObject = {
+  password: '123',
+  foo: 'bar',
+  bar: 'foo',
+};
+
+describe('test logger helper', () => {
+  it('should test the maskDataInObject', () => {
+    const subject = loggerHelper.maskDataInObject(testObject);
+    expect(subject).toEqual({
+      ...testObject,
+    });
+  });
+
+  it('should attach trace when data is empty', () => {
+    const subject = loggerHelper.maskDataInObject(undefined, undefined, 'trace');
+    expect(subject).toEqual({ trace: 'trace' });
+  });
+
+  it('should test the maskDataInObject with password masking', () => {
+    const subject = loggerHelper.maskDataInObject(testObject, ['password']);
+    expect(subject).toEqual({
+      ...testObject,
+      password: '[REDACTED]',
+    });
+  });
+
+  it('should read logger levels from env', () => {
+    process.env.NEST_LOGGER_LEVELS_API = 'error,log';
+    process.env.NEST_LOGGER_LEVELS = 'debug';
+
+    expect(loggerHelper.getEnvLoggerLevelsByContext('api')).toEqual([
+      'error',
+      'log',
+    ]);
+    expect(loggerHelper.getEnvLoggerLevels('api', ['warn'])).toEqual([
+      'error',
+      'log',
+    ]);
+
+    delete process.env.NEST_LOGGER_LEVELS_API;
+    expect(loggerHelper.getEnvLoggerLevels('missing', ['warn'])).toEqual([
+      'debug',
+    ]);
+  });
+
+  it('should wrap string data into object', () => {
+    expect(loggerHelper.maskDataInObject('message')).toEqual({ message: 'message' });
+  });
+});

package/src/__tests__/logger.service.spec.ts

@@ -0,0 +1,78 @@
+import { jest, describe, beforeEach, it, expect } from '@jest/globals';
+import { Test } from '@nestjs/testing';
+import { LoggerServiceFactory } from '../logger.service.js';
+import {
+  AppConfigService,
+  getAppConfigToken,
+} from '@nest-yalc-2/app/app-config.service.js';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+describe('LoggerServiceFactory', () => {
+  let configService: AppConfigService;
+
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        {
+          provide: AppConfigService,
+          useValue: {
+            values: jest.fn().mockReturnValue({
+              loggerType: 'console',
+              logContextLevels: {
+                TestContext: ['debug', 'error'],
+              },
+              logLevels: ['warn', 'log'],
+            }),
+          },
+        },
+      ],
+    }).compile();
+
+    configService = moduleRef.get<AppConfigService>(AppConfigService);
+  });
+
+  it('should create logger service', () => {
+    const loggerService = LoggerServiceFactory(
+      'TestContext',
+      'TestProvide',
+      'TestContext',
+    );
+    expect(loggerService).toBeDefined();
+    expect(loggerService.provide).toBe('TestProvide');
+    expect(loggerService.inject).toEqual([
+      getAppConfigToken('TestContext'),
+      EventEmitter2,
+    ]);
+
+    const logger = loggerService.useFactory(configService);
+    expect(logger).toBeDefined();
+  });
+
+  it('should create logger service with default log levels', () => {
+    jest.spyOn(configService, 'values').mockReturnValue({
+      loggerType: 'console',
+      logLevels: ['warn', 'log'],
+    });
+
+    const loggerService = LoggerServiceFactory(
+      'TestContext',
+      'TestProvide',
+      'TestContext',
+    );
+    const logger = loggerService.useFactory(configService);
+    expect(logger).toBeDefined();
+  });
+
+  it('should create logger service with event disabled', () => {
+    jest.spyOn(configService, 'values').mockReturnValue({
+      loggerType: 'console',
+      logLevels: ['warn', 'log'],
+    });
+
+    const loggerService = LoggerServiceFactory('TestProvide', 'TestContext', {
+      event: false,
+    });
+    const logger = loggerService.useFactory(configService);
+    expect(logger).toBeDefined();
+  });
+});

package/src/__tests__/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../tsconfig.test.json"
+}

package/src/__tests__/typeorm-logger.spec.ts

@@ -0,0 +1,111 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+
+// class NestLogger {}
+
+// jest.mock('@nestjs/common', () => ({
+//   ...(jest.requireActual('@nestjs/common') as any),
+//   Logger: NestLogger,
+// }));
+
+// import { LogLevelEnum, LoggerTypeEnum } from '../logger.enum.js';
+// import { AppLoggerFactory } from '../logger.factory.js';
+// import { DeepMocked } from '@golevelup/ts-jest';
+import { createMock } from '@golevelup/ts-jest';
+import { LoggerService } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { TypeORMLogger } from '../typeorm-logger.js';
+
+describe('TypeORMLogger with a valid logger', () => {
+  const mockedLoggerService = createMock<LoggerService>();
+  const mockedEventEmitter2 = createMock<EventEmitter2>();
+  let testLogger: TypeORMLogger;
+
+  beforeAll(() => {
+    process.env.TYPEORM_LOGGING = 'true';
+    testLogger = new TypeORMLogger(mockedLoggerService, mockedEventEmitter2);
+  });
+
+  afterAll(() => {
+    delete process.env.TYPEORM_LOGGING;
+  });
+
+  it('logQuery ', async () => {
+    const spiedLoggerServiceFn = jest.spyOn(mockedLoggerService, 'debug');
+    testLogger.logQuery('aQuery');
+    expect(spiedLoggerServiceFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('logQueryError ', async () => {
+    const spiedLoggerServiceFn = jest.spyOn(mockedLoggerService, 'error');
+    testLogger.logQueryError('error', 'aQuery');
+    expect(spiedLoggerServiceFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('logQuerySlow ', async () => {
+    const spiedLoggerServiceFn = jest.spyOn(mockedLoggerService, 'warn');
+    testLogger.logQuerySlow(10000, 'aQuery');
+    expect(spiedLoggerServiceFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('logSchemaBuild ', async () => {
+    const spiedLoggerServiceFn = jest.spyOn(mockedLoggerService, 'debug');
+    testLogger.logSchemaBuild('aQuery');
+    expect(spiedLoggerServiceFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('logMigration ', async () => {
+    const spiedLoggerServiceFn = jest.spyOn(mockedLoggerService, 'debug');
+    testLogger.logMigration('aQuery');
+    expect(spiedLoggerServiceFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('log ', async () => {
+    const spiedLoggerServiceLog = jest.spyOn(mockedLoggerService, 'log');
+    testLogger.log('log', 'aQuery');
+    expect(spiedLoggerServiceLog).toHaveBeenCalledTimes(1);
+
+    const spiedLoggerServiceInfo = jest.spyOn(mockedLoggerService, 'verbose');
+    testLogger.log('info', 'aQuery');
+    expect(spiedLoggerServiceInfo).toHaveBeenCalledTimes(1);
+
+    const spiedLoggerServiceWarn = jest.spyOn(mockedLoggerService, 'warn');
+    testLogger.log('warn', 'aQuery');
+    expect(spiedLoggerServiceWarn).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('TypeORMLogger with a invalid logger', () => {
+  const mockedLoggerService = createMock<LoggerService>();
+  const mockedEventEmitter2 = createMock<EventEmitter2>();
+  mockedLoggerService.debug = undefined;
+  mockedLoggerService.error = undefined;
+  mockedLoggerService.warn = undefined;
+  mockedLoggerService.log = undefined;
+  mockedLoggerService.verbose = undefined;
+  const testLogger = new TypeORMLogger(
+    mockedLoggerService,
+    mockedEventEmitter2,
+  );
+
+  it('All che level should ignore a missing logger function ', async () => {
+    expect(() => testLogger.logQuery('aQuery')).not.toThrow();
+    expect(() =>
+      testLogger.logQueryError('error', 'aQuery'),
+    ).not.toThrow();
+    expect(() => testLogger.logQuerySlow(10000, 'aQuery')).not.toThrow();
+    expect(() => testLogger.logSchemaBuild('aQuery')).not.toThrow();
+    expect(() => testLogger.logMigration('aQuery')).not.toThrow();
+    expect(() => testLogger.log('log', 'aQuery')).not.toThrow();
+    expect(() => testLogger.log('info', 'aQuery')).not.toThrow();
+    expect(() => testLogger.log('warn', 'aQuery')).not.toThrow();
+  });
+});

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './logger.enum.js';
+export * from './logger.event.js';
+export * from './logger.factory.js';
+export * from './typeorm-logger.js';
+export * from './logger.helper.js';
+export * from './logger-abstract.service.js';
+export * from './logger-nest.service.js';
+export * from './logger-console.service.js';
+export * from './logger.service.js';
+export * from './logger-pino.service.js';