featnestjs logger by default, options for a default logger

src/pubsub-transport.module.spec.ts

@@ -2,6 +2,7 @@ import type { PubSub } from '@google-cloud/pubsub';
 import { Test } from '@nestjs/testing';
 
 import { PubSubTransport, PubSubTransportConfig, PubsubTransportModule } from '..';
+import { defaultLogger, PubSubTransportLogger } from './pubsub-transport.module';
 
 describe('PubsubTransportModule', () => {
   const subscriptionMock = {
@@ -42,16 +43,29 @@ describe('PubsubTransportModule', () => {
   });
 
   it('bootstraps module with a custom logger', async () => {
-    const loggerToken = Symbol('MockLogger');
-    const mockLogger = {
-      log: () => ({}),
+    const MockLogger = class MockLogger implements PubSubTransportLogger {
+      debug(): void {
+        return;
+      }
+
+      error(): void {
+        return;
+      }
+
+      info(): void {
+        return;
+      }
+
+      warn(): void {
+        return;
+      }
     };
 
     const app = await Test.createTestingModule({
       imports: [
         PubsubTransportModule.forRootAsync({
-          logger: loggerToken,
-          providers: [{ provide: loggerToken, useValue: mockLogger }],
+          logger: MockLogger,
+          providers: [{ provide: MockLogger, useClass: MockLogger }],
           useFactory: () => ({
             pubsub: config.pubsub,
             topic: 'topic',
@@ -63,7 +77,26 @@ describe('PubsubTransportModule', () => {
 
     const transport = app.get(PubSubTransport);
     expect(transport).toBeDefined();
-    expect((transport as never as Record<string, unknown>)['log']).toBe(mockLogger);
+    expect((transport as never as Record<string, unknown>)['log']).toBeInstanceOf(MockLogger);
+  });
+
+  it('bootstraps module with a default logger', async () => {
+    const app = await Test.createTestingModule({
+      imports: [
+        PubsubTransportModule.forRootAsync({
+          logger: true,
+          useFactory: () => ({
+            pubsub: config.pubsub,
+            topic: 'topic',
+            subscription: 'sub',
+          }),
+        }),
+      ],
+    }).compile();
+
+    const transport = app.get(PubSubTransport);
+    expect(transport).toBeDefined();
+    expect((transport as never as Record<string, unknown>)['log']).toBe(defaultLogger);
   });
 
   it('bootstraps two modules using symbol token (async)', async () => {

src/pubsub-transport.module.ts

@@ -1,15 +1,28 @@
-import { DynamicModule, Module, ModuleMetadata, Type } from '@nestjs/common';
-import { WinstonLogger } from 'nest-winston';
+import { DynamicModule, Logger, Module, ModuleMetadata, Provider, Type } from '@nestjs/common';
 
 import { LoggerToken, PubSubTransport, PubSubTransportConfig } from './pubsub-transport';
 
+export interface PubSubTransportLogger {
+  debug: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+}
+
+export const defaultLogger: PubSubTransportLogger = {
+  debug: Logger.debug,
+  info: Logger.log,
+  error: Logger.error,
+  warn: Logger.warn,
+};
+
 export interface PubSubTransportAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
   useExisting?: Type<PubSubTransportConfig>;
   useClass?: Type<PubSubTransportConfig>;
   useFactory?: (...args: any[]) => Promise<PubSubTransportConfig> | PubSubTransportConfig;
   inject?: any[];
   token?: symbol;
-  logger?: Type<WinstonLogger> | symbol;
+  logger?: boolean | Type<PubSubTransportLogger>;
 }
 
 @Module({})
@@ -74,6 +87,7 @@ export class PubsubTransportModule {
       providers,
       logger,
     } = options;
+
     return {
       module: PubsubTransportModule,
       global: true,
@@ -87,7 +101,7 @@ export class PubsubTransportModule {
           useExisting,
           provide: PubSubTransportConfig,
         },
-        { provide: LoggerToken, useExisting: logger || WinstonLogger },
+        ...getLoggerProviderDefinition(logger),
         token
           ? {
               useClass: PubSubTransport,
@@ -99,3 +113,17 @@ export class PubsubTransportModule {
     };
   }
 }
+
+function getLoggerProviderDefinition(
+  logger?: boolean | Type<PubSubTransportLogger>
+): [Provider] | [] {
+  if (logger === false || logger === undefined) {
+    return [];
+  }
+
+  if (logger === true) {
+    return [{ provide: LoggerToken, useValue: defaultLogger }];
+  }
+
+  return [{ provide: LoggerToken, useExisting: logger }];
+}

src/pubsub-transport.ts

@@ -3,7 +3,8 @@ import { Inject, Injectable, Optional } from '@nestjs/common';
 import { CustomTransportStrategy, Server } from '@nestjs/microservices';
 import errorToJSON from 'error-to-json';
 import { firstValueFrom } from 'rxjs';
-import { Logger } from 'winston';
+
+import { PubSubTransportLogger } from './pubsub-transport.module';
 
 export const LoggerToken = Symbol('Logger');
 export const PubSubTransportConfig = Symbol('PubSubTransportConfig');
@@ -63,7 +64,7 @@ export class PubSubTransport extends Server implements CustomTransportStrategy {
     }: PubSubTransportConfig,
     @Optional()
     @Inject(LoggerToken)
-    private log?: Logger
+    private log?: PubSubTransportLogger
   ) {
     super();
     // kind of ugly logic to no to force user pass pubsub and topic, if they
@@ -98,7 +99,6 @@ export class PubSubTransport extends Server implements CustomTransportStrategy {
     this.log?.debug('Listening for PubSub messages...');
     this.subscription.on('close', () => {
       this.log?.error('PubSub subscription closed unexpectedly');
-      this.log?.close();
       process.exit(3);
     });
     this.subscription.on('message', (msg: Message) => this.handleMessage(msg));