feat: decouples from ConfigModule and ConfigService; No more environment variables;

Author: gm50x

src/common.builder.ts

@@ -0,0 +1,7 @@
+import { ConfigurableModuleBuilder } from '@nestjs/common';
+import { CommonModuleOptions } from './common.options';
+
+export const { MODULE_OPTIONS_TOKEN, ConfigurableModuleClass } =
+  new ConfigurableModuleBuilder<CommonModuleOptions>()
+    .setClassMethodName('forRoot')
+    .build();

src/common.factory.ts

@@ -0,0 +1,35 @@
+import { configureContextWrappers } from '@gedai/nestjs-core';
+import { NestApplicationOptions } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { configureExceptionHandler } from './logger/exception.handler';
+import { configureHttpInspectorInbound } from './logger/http-inspector-inbound.middleware';
+import { configureHttpInspectorOutbound } from './logger/http-inspector-outbound.interceptor';
+import { configureLogger } from './logger/logger.config';
+import { configureCompression } from './utils/compression.config';
+import { configureCORS } from './utils/cors.config';
+import { configureHelmet } from './utils/helmet.config';
+import { configureRoutePrefix } from './utils/route-prefix.config';
+import { configureValidation } from './utils/validation.config';
+import { configureVersioning } from './utils/versioning.config';
+
+export const createNestApp = async (
+  appModule: any,
+  opts?: NestApplicationOptions,
+) => {
+  const { bufferLogs = true } = opts ?? {};
+  const app = await NestFactory.create(appModule, { ...opts, bufferLogs })
+    // :: keep layout
+    .then(configureContextWrappers)
+    .then(configureLogger)
+    .then(configureExceptionHandler)
+    .then(configureHttpInspectorInbound)
+    .then(configureHttpInspectorOutbound)
+    .then(configureCORS)
+    .then(configureHelmet)
+    .then(configureCompression)
+    .then(configureValidation)
+    .then(configureVersioning)
+    .then(configureRoutePrefix);
+
+  return app;
+};

src/common.module.ts

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import {
+  ConfigurableModuleClass,
+  MODULE_OPTIONS_TOKEN,
+} from './common.builder';
+
+@Global()
+@Module({ exports: [MODULE_OPTIONS_TOKEN] })
+export class CommonModule extends ConfigurableModuleClass {}

src/common.options.ts

@@ -0,0 +1,44 @@
+import { ValidationPipeOptions, VersioningOptions } from '@nestjs/common';
+import {
+  CorsOptions,
+  CorsOptionsDelegate,
+} from '@nestjs/common/interfaces/external/cors-options.interface';
+import * as compression from 'compression';
+import { HelmetOptions } from 'helmet';
+import { Obfuscator } from './logger/obfuscator';
+
+export type ObfuscationOptions = {
+  obfuscator?: Obfuscator;
+  sensitiveKeys?: (string | RegExp)[];
+};
+
+export type LoggerOptions = {
+  silent?: boolean;
+  level?: 'debug' | 'verbose' | 'info' | 'warn' | 'error';
+  format?: 'json' | 'pretty';
+  obfuscation?: ObfuscationOptions;
+};
+
+export type HttpTrafficInspectionOptions = {
+  mode?: 'none' | 'all' | 'inbound' | 'outbound';
+  ignoreRoutes: string[];
+};
+
+export type CORSOption = CorsOptions | CorsOptionsDelegate<any>;
+
+export type CommonModuleOptions = {
+  appName?: string;
+  environment?: string;
+  httpTrafficInspection?: HttpTrafficInspectionOptions;
+  logger?: LoggerOptions;
+  cors?: CORSOption;
+  helmet?: Readonly<HelmetOptions>;
+  compression?: compression.CompressionOptions;
+  validationPipe?: ValidationPipeOptions;
+  versioning?: VersioningOptions;
+  routePrefix?: string;
+};
+
+export interface CommonOptionsFactory {
+  createOptions(): CommonModuleOptions | Promise<CommonModuleOptions>;
+}

src/index.ts

@@ -1,8 +1,12 @@
-export * from './logger/anonymizer';
+export * from './common.factory';
+export * from './common.module';
+export * from './common.options';
+
 export * from './logger/exception.handler';
 export * from './logger/http-inspector-inbound.middleware';
 export * from './logger/http-inspector-outbound.interceptor';
 export * from './logger/logger.config';
+export * from './logger/obfuscator';
 
 export * from './utils/compression.config';
 export * from './utils/cors.config';

src/logger/exception.handler.ts

@@ -67,7 +67,7 @@ class CustomExceptionHandler implements NestInterceptor {
   }
 }
 
-export const configureExceptionLogger = () => (app: INestApplication) => {
+export const configureExceptionHandler = (app: INestApplication) => {
   const contextService = app.get(ContextService);
   app.useGlobalInterceptors(new CustomExceptionHandler(contextService));
   Logger.log('Exceptions handler initialized', '@gedai/common/config');

src/logger/http-inspector-inbound.middleware.ts

@@ -4,8 +4,9 @@ import {
   Logger,
   NestMiddleware,
 } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
 import { NextFunction, Request, Response } from 'express';
+import { MODULE_OPTIONS_TOKEN } from '../common.builder';
+import { CommonModuleOptions } from '../common.options';
 
 @Injectable()
 class HttpInspectorInboundMiddleware implements NestMiddleware {
@@ -82,57 +83,33 @@ class HttpInspectorInboundMiddleware implements NestMiddleware {
   }
 }
 
-type InspectionOptions = {
-  ignoreRoutes?: string[];
-};
+export const configureHttpInspectorInbound = (app: INestApplication) => {
+  const options = app.get<CommonModuleOptions>(MODULE_OPTIONS_TOKEN);
+  const { ignoreRoutes = [], mode = 'inbound' } =
+    options.httpTrafficInspection ?? {};
+  if (!['all', 'inbound'].includes(mode)) {
+    return app;
+  }
 
-/**
- * Configures a globally bound middleware to inspect inbound http traffic.
- * @param {InspectionOptions} opts - configuration object specifying:
- *
- * - `ignoreRoutes` - a list of `request.path` routes to ignore
- *
- * ### Ignored Routes
- * #### Wildcards:
- * - \* matches N tokens in the `request.path`
- * #### Examples:
- * - '/v1/accounts/\*\/holder'
- * - - hides '/v1/accounts/:id/holder' from inspection
- * - '/v1/accounts/*'
- * - - Hides nested route inside '/v1/accounts' from inspection
- *
- */
-export const configureHttpInspectorInbound =
-  (opts?: InspectionOptions) => (app: INestApplication) => {
-    const { ignoreRoutes = [] } = opts || {};
-    const configService = app.get(ConfigService);
-    const httpInspection = configService.get(
-      'TRAFFIC_INSPECTION_HTTP',
-      'inbound',
+  if (ignoreRoutes) {
+    Logger.log(
+      {
+        message: 'HTTP Inspection is set to ignore routes',
+        routes: ignoreRoutes,
+      },
+      '@gedai/common/config',
     );
-    if (!['all', 'inbound'].includes(httpInspection)) {
-      return app;
-    }
-
-    if (ignoreRoutes) {
-      Logger.log(
-        {
-          message: 'HTTP Inspection is set to ignore routes',
-          routes: ignoreRoutes,
-        },
-        '@gedai/common/config',
-      );
-    }
+  }
 
-    const inspector = new HttpInspectorInboundMiddleware(
-      ignoreRoutes.map((x) => new RegExp(`^${x.replace('*', '.+')}$`, 'i')),
-    );
-    const middleware = inspector.use.bind(inspector);
+  const inspector = new HttpInspectorInboundMiddleware(
+    ignoreRoutes.map((x) => new RegExp(`^${x.replace('*', '.+')}$`, 'i')),
+  );
+  const middleware = inspector.use.bind(inspector);
 
-    Object.defineProperty(middleware, 'name', {
-      value: HttpInspectorInboundMiddleware.name,
-    });
-    app.use(middleware);
-    Logger.log('Inbound http inspection initialized', '@gedai/common/config');
-    return app;
-  };
+  Object.defineProperty(middleware, 'name', {
+    value: HttpInspectorInboundMiddleware.name,
+  });
+  app.use(middleware);
+  Logger.log('Inbound http inspection initialized', '@gedai/common/config');
+  return app;
+};

src/logger/http-inspector-outbound.interceptor.ts

@@ -1,7 +1,8 @@
 import { INestApplication, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
 import * as http from 'http';
 import * as https from 'https';
+import { MODULE_OPTIONS_TOKEN } from '../common.builder';
+import { CommonModuleOptions } from '../common.options';
 import { logRequestError, logResponse } from './http-inspector.utils';
 
 const handleResponse =
@@ -73,13 +74,13 @@ function mountInterceptor(logger: Logger, module: typeof http | typeof https) {
   }
 }
 
-export const configureHttpInspectorOutbound = () => (app: INestApplication) => {
-  const configService = app.get(ConfigService);
-  const httpInspection = configService.get('TRAFFIC_INSPECTION_HTTP', 'none');
-  if (!['all', 'outbound'].includes(httpInspection)) {
+export const configureHttpInspectorOutbound = (app: INestApplication) => {
+  const options = app.get<CommonModuleOptions>(MODULE_OPTIONS_TOKEN);
+  // TODO: add ignore routes
+  const { mode } = options.httpTrafficInspection ?? {};
+  if (!['all', 'outbound'].includes(mode)) {
     return app;
   }
-
   const logger = new Logger('OutboundHTTPInspection');
   for (const module of [http, https]) {
     mountInterceptor(logger, module);

src/logger/logger.config.ts

@@ -1,16 +1,17 @@
 import { Context, ContextService } from '@gedai/nestjs-core';
 import { INestApplication, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
 import {
   WinstonModule,
   WinstonModuleOptions,
   utilities as nestWinstonUtils,
 } from 'nest-winston';
 import { config, format, transports } from 'winston';
-import { Anonymizer, RegExpAnonymizer } from './anonymizer';
+import { MODULE_OPTIONS_TOKEN } from '../common.builder';
+import { CommonModuleOptions } from '../common.options';
+import { Obfuscator, RegExpObfuscator } from './obfuscator';
 
 let contextService: ContextService;
-let anonymizer: Anonymizer;
+let anonymizer: Obfuscator;
 let env: string;
 let serviceName: string;
 
@@ -37,11 +38,11 @@ let extraSensitiveKeys: (string | RegExp)[];
 
 const sensitive = () =>
   format((info) => {
-    const anonymized = anonymizer.maskFields(info, [
+    const obfuscated = anonymizer.obfuscate(info, [
       ...(extraSensitiveKeys ?? []),
       ...commonSensitiveKeys,
     ]);
-    return anonymized;
+    return obfuscated;
   })();
 
 const environment = () =>
@@ -94,41 +95,42 @@ const prettyFormat = () =>
     nestLike(serviceName),
   );
 
-export type LoggerOptions = {
-  silent?: boolean;
-  anonymizer?: Anonymizer;
-  anonymizeKeys?: (string | RegExp)[];
-};
-
-export const configureLogger =
-  (options?: LoggerOptions) => (app: INestApplication) => {
-    const {
-      anonymizer: _anonymizer = new RegExpAnonymizer(),
-      silent = false,
-      anonymizeKeys,
-    } = options || {};
-    const configService = app.get(ConfigService);
-    contextService = app.get(ContextService);
-    extraSensitiveKeys = anonymizeKeys;
-    anonymizer = _anonymizer;
-
-    const _env = configService.get('NODE_ENV', 'production');
-    const appName = configService.get('SERVICE_NAME', 'nest-app');
-    const logLevel = configService.get('LOG_LEVEL', 'info');
-    const logFormat = configService.get('LOG_FORMAT', 'json');
-    const usePrettyFormat = logFormat === 'pretty';
-
-    env = _env;
-    serviceName = appName;
-    const loggerConfig: WinstonModuleOptions = {
-      silent,
-      levels: config.npm.levels,
-      level: logLevel,
-      format: usePrettyFormat ? prettyFormat() : jsonFormat(),
-      transports: [new Console()],
-    };
-    const logger = WinstonModule.createLogger(loggerConfig);
-    app.useLogger(logger);
-    Logger.log('Logger initialized', '@gedai/common/config');
-    return app;
+export const configureLogger = (app: INestApplication) => {
+  const options = app.get<CommonModuleOptions>(MODULE_OPTIONS_TOKEN);
+  const {
+    appName = 'unknown-app',
+    environment = 'production',
+    logger: loggerConfig = {},
+  } = options;
+
+  const {
+    format = 'json',
+    level = 'info',
+    silent = false,
+    obfuscation = {},
+  } = loggerConfig;
+
+  const {
+    sensitiveKeys: anonymizeKeys = [],
+    obfuscator: _anonymizer = new RegExpObfuscator(),
+  } = obfuscation;
+
+  contextService = app.get(ContextService);
+  extraSensitiveKeys = anonymizeKeys;
+  anonymizer = _anonymizer;
+  const usePrettyFormat = format === 'pretty';
+
+  env = environment;
+  serviceName = appName;
+  const winstonConfig: WinstonModuleOptions = {
+    silent,
+    levels: config.npm.levels,
+    level,
+    format: usePrettyFormat ? prettyFormat() : jsonFormat(),
+    transports: [new Console()],
   };
+  const logger = WinstonModule.createLogger(winstonConfig);
+  app.useLogger(logger);
+  Logger.log('Logger initialized', '@gedai/common/config');
+  return app;
+};