refactor the code and sanitize the code by code seperation.

Author: BinaryStudio8

README.md

@@ -6,3 +6,5 @@ export * from './interfaces';
 export * from './secrets';
 export * from './exception';
 export * from './cqrs';
+export * from './utils';
+export * from './logger';

libs/shared/src/index.ts

@@ -0,0 +1,76 @@
+import { Global, Module } from '@nestjs/common';
+import { LoggerModule as PinoLoggerModule } from 'nestjs-pino';
+import { configVariables } from '@shared';
+import type { IncomingMessage, ServerResponse } from 'http';
+
+@Global()
+@Module({
+  imports: [
+    PinoLoggerModule.forRootAsync({
+      useFactory: () => ({
+        pinoHttp: {
+          level: configVariables.logger.level,
+
+          transport:
+            configVariables.nodeEnv !== 'production'
+              ? {
+                  target: 'pino-pretty',
+                  options: {
+                    colorize: true,
+                    translateTime: 'yyyy-mm-dd HH:MM:ss.l o',
+                    ignore: 'pid,hostname',
+                  },
+                }
+              : undefined,
+
+          genReqId: (req: IncomingMessage & { id?: string }) =>
+            (req.headers['x-request-id'] as string) ?? Date.now().toString(),
+
+          serializers: {
+            req(req: IncomingMessage & { id?: string }) {
+              return {
+                method: req.method,
+                url: req.url,
+                id: req.id,
+              };
+            },
+            res(res: ServerResponse) {
+              return {
+                statusCode: res.statusCode,
+              };
+            },
+            err(err: Error) {
+              return {
+                type: err.name,
+                message: err.message,
+                stack: err.stack,
+              };
+            },
+          },
+
+          redact: {
+            paths: [
+              'req.headers.authorization',
+              'req.body.password',
+              'req.body.token',
+              '*.password',
+              '*.token',
+            ],
+            censor: '**REDACTED**',
+          },
+
+          autoLogging:
+            configVariables.nodeEnv === 'development'
+              ? {
+                  ignore: (req: IncomingMessage) => req.url === '/health',
+                }
+              : false,
+        },
+
+        forRoutes: [],
+      }),
+    }),
+  ],
+  exports: [PinoLoggerModule],
+})
+export class LoggerModule {}

src/modules/logger/index.ts libs/shared/src/logger/index.tssrc/modules/logger/index.ts renamed to libs/shared/src/logger/index.ts

@@ -1,70 +1,38 @@
-import * as dotenv from 'dotenv';
-import { join } from 'path';
+import { getEnvVariable, loadEnvironment } from '@shared/utils';
 
-dotenv.config({ path: join(process.cwd(), 'src/environment/.env') });
-
-if (process.env.NODE_ENV === 'production') {
-  dotenv.config({
-    path: join(process.cwd(), 'src/environment/.env.prod'),
-    override: true,
-  });
-}
-
-function getEnvVariable(key: string): string {
-  const value = process.env[key];
-  if (!value) {
-    throw new Error(`Environment variable ${key} is not defined`);
-  }
-  return value;
-}
-
-const PORT = parseInt(getEnvVariable('PORT'), 10);
-const DB_NAME = getEnvVariable('DB_NAME');
-const DB_TYPE = getEnvVariable('DB_TYPE') as 'postgres' | 'mysql' | 'mongodb';
-const DB_HOST = getEnvVariable('DB_HOST');
-const DB_PORT = parseInt(getEnvVariable('DB_PORT'), 10);
-const DB_USERNAME = getEnvVariable('DB_USERNAME');
-const DB_PASSWORD = getEnvVariable('DB_PASSWORD');
-const SWAGGER_DOCS = getEnvVariable('SWAGGER_DOCS');
-const JWT_SECRET = getEnvVariable('JWT_SECRET');
-const NODE_ENV = getEnvVariable('NODE_ENV') as
-  | 'development'
-  | 'production'
-  | 'test';
-const SESSION_SECRET = getEnvVariable('SESSION_SECRET');
-const API_VERSION = getEnvVariable('API_VERSION');
-const PUBLIC_KEY = getEnvVariable('PUBLIC_KEY');
-const LOG_LEVEL = getEnvVariable('LOG_LEVEL');
-const SENTRY_DSN = getEnvVariable('SENTRY_DSN');
+loadEnvironment();
 
 export const configVariables = {
-  port: PORT,
+  port: Number(getEnvVariable('PORT')),
   database: {
-    name: DB_NAME,
-    type: DB_TYPE,
-    host: DB_HOST,
-    port: DB_PORT,
-    username: DB_USERNAME,
-    password: DB_PASSWORD,
+    name: getEnvVariable('DB_NAME'),
+    type: getEnvVariable('DB_TYPE') as 'postgres',
+    host: getEnvVariable('DB_HOST'),
+    port: Number(getEnvVariable('DB_PORT')),
+    username: getEnvVariable('DB_USERNAME'),
+    password: getEnvVariable('DB_PASSWORD'),
   },
   swagger: {
-    docs: SWAGGER_DOCS,
+    url: getEnvVariable('SWAGGER_URL'),
+    title: getEnvVariable('SWAGGER_TITLE'),
+    description: getEnvVariable('SWAGGER_DESCRIPTION'),
+    version: getEnvVariable('SWAGGER_VERSION'),
   },
   jwt: {
-    secret: JWT_SECRET,
+    secret: getEnvVariable('JWT_SECRET'),
   },
   session: {
-    secret: SESSION_SECRET,
+    secret: getEnvVariable('SESSION_SECRET'),
   },
   api: {
-    version: API_VERSION,
+    version: getEnvVariable('API_VERSION'),
   },
-  nodeEnv: NODE_ENV,
-  publicKey: PUBLIC_KEY,
+  nodeEnv: getEnvVariable('NODE_ENV'),
+  publicKey: getEnvVariable('PUBLIC_KEY'),
   sentry: {
-    dsn: SENTRY_DSN,
+    dsn: getEnvVariable('SENTRY_DSN', false),
   },
   logger: {
-    level: LOG_LEVEL,
+    level: getEnvVariable('LOG_LEVEL'),
   },
-} as const;
+};

libs/shared/src/logger/logger.module.ts

@@ -2,6 +2,8 @@ import { DynamicModule, Global, Module } from '@nestjs/common';
 import { CqrsModule } from '@nestjs/cqrs';
 import { JwtModule } from '@nestjs/jwt';
 import { CqrsMediator } from './cqrs/cqrs.mediator';
+import { configVariables } from './secrets';
+import { LoggerModule } from 'nestjs-pino';
 // Import other shared services, guards, helpers, interceptors as needed
 
 @Global()
@@ -11,7 +13,14 @@ export class SharedBaseModule {
     return {
       module: SharedBaseModule,
       global: true,
-      imports: [CqrsModule, JwtModule],
+      imports: [
+        CqrsModule,
+        JwtModule.register({
+          secret: configVariables.jwt.secret,
+          signOptions: { expiresIn: '1d' },
+        }),
+        LoggerModule,
+      ],
       providers: [
         CqrsMediator,
         // add other shared providers here

libs/shared/src/secrets/secrets.keys.ts

@@ -0,0 +1,9 @@
+export function getEnvVariable(key: string, required = true): string {
+  const value = process.env[key];
+
+  if (required && (!value || value.trim() === '')) {
+    throw new Error(`Environment variable ${key} is not defined`);
+  }
+
+  return value || '';
+}

libs/shared/src/shared.module.ts

@@ -0,0 +1,2 @@
+export * from './env.utils';
+export * from './load-env.utils';

libs/shared/src/utils/env.utils.ts

@@ -0,0 +1,25 @@
+import * as dotenv from 'dotenv';
+import { join } from 'path';
+
+export function loadEnvironment() {
+  const basePath = join(process.cwd(), 'src/environment/.env');
+
+  dotenv.config({ path: basePath });
+
+  const envFileMap: Record<string, string> = {
+    production: '.env.prod',
+    development: '.env',
+    test: '.env.test',
+    docker: '.env.docker',
+  };
+
+  const nodeEnv = process.env.NODE_ENV || 'development';
+  const envFile = envFileMap[nodeEnv];
+
+  if (envFile && envFile !== '.env') {
+    dotenv.config({
+      path: join(process.cwd(), `src/environment/${envFile}`),
+      override: true,
+    });
+  }
+}

libs/shared/src/utils/index.ts

@@ -7,12 +7,10 @@ import { AppService } from './app.service';
 import { DatabaseService } from '@config/database-connect.msg';
 import { AppDataSource } from '@config/typeorm.config';
 import { HealthModule } from '@modules/health/health.module';
-import { LoggerModule } from '@modules/logger';
 import { SharedBaseModule } from '@shared';
 
 @Module({
   imports: [
-    LoggerModule,
     HealthModule,
     TypeOrmModule.forRoot(AppDataSource.options),
     AutomapperModule.forRoot({