cqrs-boilerplate-code 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cqrs-boilerplate-code",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "AI Platform Service API Gateway",
   "private": false,
   "license": "UNLICENSED",

package/src/common-infra/common-infra.module.ts

@@ -1,9 +1,17 @@
-import { Module } from "@nestjs/common";
+import { DynamicModule, Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
 import { DBModule } from "./database/database.module";
 
-@Module({
-  imports: [DBModule],
-  providers: [],
-  exports: [],
-})
-export class CommonInfraModule {}
+@Module({})
+export class CommonInfraModule {
+  static forRoot(): DynamicModule {
+    return {
+      module: CommonInfraModule,
+      imports: [
+        ConfigModule, // assumes consumer app config
+        DBModule,
+      ],
+      exports: [DBModule],
+    };
+  }
+}

package/src/common-infra/database/database.module.ts

@@ -1,15 +1,23 @@
-import { Module } from "@nestjs/common";
-import { TypeOrmModule } from "@nestjs/typeorm";
+// src/database/database.module.ts
+import { DynamicModule, Module } from "@nestjs/common";
 import { ConfigModule, ConfigService } from "@nestjs/config";
+import { TypeOrmModule } from "@nestjs/typeorm";
 import { typeOrmConfig } from "./typeorm.config";
 
-@Module({
-  imports: [
-    TypeOrmModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: typeOrmConfig,
-    }),
-  ],
-})
-export class DBModule {}
+@Module({})
+export class DBModule {
+  static forRoot(): DynamicModule {
+    return {
+      module: DBModule,
+      imports: [
+        TypeOrmModule.forRootAsync({
+          imports: [ConfigModule],
+          inject: [ConfigService],
+          useFactory: (configService: ConfigService) =>
+            typeOrmConfig(configService),
+        }),
+      ],
+      exports: [TypeOrmModule],
+    };
+  }
+}

package/src/common-infra/index.ts

@@ -0,0 +1,2 @@
+export * from "./common-infra.module";
+export * from "./database/typeorm.config";

package/src/core-common/core-common.module.ts

@@ -1,9 +1,19 @@
-import { Module } from "@nestjs/common";
+// src/core-common.module.ts
+import { DynamicModule, Global, Module } from "@nestjs/common";
+import { LoggerModule } from "./logger/logger.module";
 
-@Module({
-  providers: [
-  ],
-  exports: [
-  ],
-})
-export class CoreCommonModule {}
+@Global()
+@Module({})
+export class CoreCommonModule {
+  static forRoot(): DynamicModule {
+    return {
+      module: CoreCommonModule,
+      imports: [
+        LoggerModule.forRoot(),
+      ],
+      exports: [
+        LoggerModule,
+      ],
+    };
+  }
+}

package/src/core-common/index.ts

@@ -0,0 +1,13 @@
+export * from './constant/app.constant'
+export * from './error/custom-error/already-exists.error'
+export * from './error/custom-error/not-found.error'
+export * from './error/custom-error/validation.error'
+export * from './error/custom-error/internal-server.error'
+export * from './error/custom-error/unauthorized.error'
+export * from './error/custom-error/service-unavailable.error'
+export * from './error/generic.error'
+export * from './result-model/result'
+export * from './response-model/generic-error-response.model'
+export * from './response-model/generic-success-response.model'
+
+export * from './core-common.module'

package/src/core-common/logger/logger.interface.ts

@@ -0,0 +1,8 @@
+// src/logger/logger.options.ts
+export interface LoggerModuleOptions {
+  level?: string;
+  deploymentEnv?: string;
+  serviceVersion?: string;
+  otelAgentHost?: string;
+  overrideConsole?: boolean;
+}

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

@@ -1,8 +1,23 @@
-import { Module } from "@nestjs/common";
-import { LoggerProvider } from "./logger.provider";
+// src/logger/logger.module.ts
+import { DynamicModule, Module } from "@nestjs/common";
+import { LoggerService } from "./logger.service";
+import { LoggerModuleOptions } from "./logger.interface";
 
-@Module({
-  providers: [LoggerProvider],
-  exports: [LoggerProvider],
-})
-export class LoggerModule {}
+export const LOGGER_OPTIONS = Symbol("LOGGER_OPTIONS");
+
+@Module({})
+export class LoggerModule {
+  static forRoot(options: LoggerModuleOptions = {}): DynamicModule {
+    return {
+      module: LoggerModule,
+      providers: [
+        LoggerService,
+        {
+          provide: LOGGER_OPTIONS,
+          useValue: options,
+        },
+      ],
+      exports: [LoggerService],
+    };
+  }
+}

package/nest-cli.json

@@ -1,8 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/nest-cli",
-  "collection": "@nestjs/schematics",
-  "sourceRoot": "src",
-  "compilerOptions": {
-    "deleteOutDir": true
-  }
-}

package/src/core-common/logger/logger.provider.ts

@@ -1,7 +0,0 @@
-import { Provider } from "@nestjs/common";
-import { LoggerService } from ".";
-
-export const LoggerProvider: Provider = {
-  provide: LoggerService,
-  useClass: LoggerService,
-};

package/src/middleware/async-storage.middleware.ts

@@ -1,29 +0,0 @@
-// async-storage.middleware.ts
-import { Injectable, NestMiddleware } from "@nestjs/common";
-import { AsyncLocalStorage } from "async_hooks";
-import { Request, Response, NextFunction } from "express";
-
-@Injectable()
-export class AsyncStorageMiddleware implements NestMiddleware {
-  private static storage = new AsyncLocalStorage<Map<string, any>>();
-
-  static get(key: string): any {
-    const store = AsyncStorageMiddleware.storage.getStore();
-    return store?.get(key);
-  }
-
-  static set(key: string, value: any): void {
-    const store = AsyncStorageMiddleware.storage.getStore();
-    if (store) {
-      store.set(key, value);
-    }
-  }
-
-  use(req: Request, _res: Response, next: NextFunction) {
-    const store = new Map<string, any>();
-    store.set("request", req);
-    AsyncStorageMiddleware.storage.run(store, () => {
-      next();
-    });
-  }
-}

package/src/middleware/filter/global-exeception.filter.ts

@@ -1,117 +0,0 @@
-import {
-  ArgumentsHost,
-  Catch,
-  ExceptionFilter,
-  HttpException,
-  HttpStatus,
-} from "@nestjs/common";
-import { Response } from "express";
-import { GenericError } from "../../core-common/error";
-import { CustomValidationError } from "../../core-common/error/custom-error/custom-validation-error";
-import { Result } from "../../core-common/result-model/result";
-
-/**
- * Handles and processes  exceptions, providing standardized error responses.
- * This global exception handler can be used to catch and respond to exceptions thrown
- * during HTTP requests and format responses accordingly.
- */
-
-@Catch()
-export class GlobalExceptionHandler implements ExceptionFilter {
-  catch(exception: unknown, host: ArgumentsHost) {
-    const response = host.switchToHttp().getResponse<Response>();
-
-    /* 1️⃣ Domain Result (highest priority) */
-    if (exception instanceof Result) {
-      const statusCode =
-        exception.error?.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR;
-
-      const payload: any = {
-        statusCode,
-        success: false,
-        error: {
-          code: exception.error?.code ?? "ERROR",
-          message: exception.error?.message ?? "An error occurred",
-        },
-        timestamp: exception.timestamp ?? new Date().toISOString(),
-      };
-
-      if (exception.data !== undefined && exception.data !== null) {
-        payload.data = exception.data;
-      }
-
-      return response.status(statusCode).json(payload);
-    }
-
-    /* 2️⃣ Custom domain errors */
-    if (exception instanceof GenericError) {
-      return response.status(exception.statusCode).json({
-        statusCode: exception.statusCode,
-        success: false,
-        error: {
-          code: exception.code,
-          message: exception.message,
-        },
-        timestamp: new Date().toISOString(),
-      });
-    }
-
-    /* 3️⃣ NestJS HTTP exceptions */
-    if (exception instanceof HttpException) {
-      const status = exception.getStatus();
-      const res = exception.getResponse();
-
-      const isValidationPipeError = exception.stack?.includes("ValidationPipe");
-
-      if (isValidationPipeError) {
-        const validationErrors = new CustomValidationError(res);
-        return response.status(validationErrors.statusCode).json({
-          success: false,
-          error: {
-            code: validationErrors.code,
-            message: validationErrors.message,
-            validationError: validationErrors.validationErrors,
-          },
-          timestamp: new Date().toISOString(),
-        });
-      }
-
-      return response.status(status).json({
-        statusCode: status,
-        success: false,
-        error: {
-          code: "HTTP_EXCEPTION",
-          message:
-            typeof res === "string"
-              ? res
-              : ((res as any).message ?? exception.message),
-        },
-        timestamp: new Date().toISOString(),
-      });
-    }
-
-    /* 4️⃣ Native JS errors (TypeError, Error, etc.) */
-    if (exception instanceof Error) {
-      return response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
-        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
-        success: false,
-        error: {
-          code: exception.name,
-          message: exception.message,
-        },
-        timestamp: new Date().toISOString(),
-      });
-    }
-
-    /* 5️⃣ Truly unknown (non-Error throwables) */
-    return response.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
-      statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
-      success: false,
-      error: {
-        code: "UNKNOWN_ERROR",
-        message: "Internal server error",
-      },
-      timestamp: new Date().toISOString(),
-    });
-  }
-}

package/src/middleware/index.ts

@@ -1,2 +0,0 @@
-export * from './async-storage.middleware'
-export * from './platform-auth.middleware'

package/src/middleware/interceptor/response-handler.ts

@@ -1,69 +0,0 @@
-import {
-    CallHandler,
-    ExecutionContext,
-    Injectable,
-    NestInterceptor,
-} from "@nestjs/common";
-import { ServerResponse } from "http";
-import { Observable } from "rxjs";
-import { GenericErrorResponse } from "../../core-common/response-model/generic-error-response.model";
-import { GenericSuccessResponse } from "../../core-common/response-model/generic-success-response.model";
-import { Result } from "../../core-common/result-model/result";
-import { HttpResponseFormatter } from "../utils/http-response.formatter";
-import { LoggerService } from "@core-common/logger";
-/**
- * Intercepts the response and returns a standard ApiReponse object
- */
-@Injectable()
-export class ResponseHandler implements NestInterceptor {
-  constructor(
-    private readonly logger: LoggerService
-  ) {}
-
-  intercept(exContext: ExecutionContext, next: CallHandler): Observable<any> {
-    return new Observable((subscriber) => {
-      next.handle().subscribe({
-        next: (data) => {
-          const mapped = this.handleResponse(exContext, data);
-          subscriber.next(mapped);
-        },
-        error: (err) => {
-          this.logger.error('Error in ResponseHandler Interceptor', err);
-          subscriber.error(err);
-        },
-        complete: () => {
-          subscriber.complete();
-        },
-      });
-    });
-  }
-
-  /**
-   * Checks the response content and appropriately sets the status code and wraps the return value in a ApiErroReponse or a
-   * ApiSuccessReponse
-   * @param excecutionContext  - Instance of the executionContext object
-   * @param result  Data returned by the controller method
-   * @returns - Instance of ApiSuccessReponse or ApiErrorReponse
-   */
-  private handleResponse(
-    excecutionContext: ExecutionContext,
-    result: Result<any>,
-  ): GenericSuccessResponse<any> | GenericErrorResponse {
-    let serverResponse = excecutionContext
-      .switchToHttp()
-      .getResponse<ServerResponse>();
-
-    const apiReponse: any = new HttpResponseFormatter().getStandardApiResponse(
-      serverResponse.statusCode,
-      result,
-    );
-    serverResponse.statusCode = apiReponse.statusCode
-      ? apiReponse.statusCode
-      : apiReponse?.error?.statusCode;
-    serverResponse[`statusCode`] = serverResponse.statusCode;
-    if (apiReponse?.statusCode) {
-      delete apiReponse?.error?.statusCode;
-    }
-    return apiReponse;
-  }
-}

package/src/middleware/platform-auth.middleware.ts

@@ -1,13 +0,0 @@
-import { Injectable, NestMiddleware } from "@nestjs/common";
-import { Request, Response } from "express";
-
-@Injectable()
-export class AuthMiddleware implements NestMiddleware<Request, Response> {
-  use(req: Request, _res: Response, next: () => void): void {
-    const authHeader = req.headers["authorization"];
-    // Implement your authentication logic here
-    // For example, validate JWT token from authHeader      
-    console.log("Auth Middleware executed", authHeader);
-    next();
-  }
-}

package/src/middleware/utils/http-response.formatter.ts

@@ -1,126 +0,0 @@
-import { HttpStatus } from "@nestjs/common";
-import { AlreadyExistsError } from "../../core-common/error/custom-error/already-exists.error";
-import { GenericError } from "../../core-common/error/generic.error";
-import { GenericErrorResponse } from "../../core-common/response-model/generic-error-response.model";
-import { GenericSuccessResponse } from "../../core-common/response-model/generic-success-response.model";
-import { Result } from "../../core-common/result-model/result";
-import { BadRequestError, ConflictError, ForbiddenError, NotFoundError, ServiceUnavailableError, UnauthorizedError, UnprocessableEntityError, ValidationError } from "../../core-common/error";
-import { InternalServerError } from "../../core-common/error/custom-error/internal-server.error";
-
-/**
- * Helps in returning a appropriate and standard Response format  based on success or error scenario
- */
-export class HttpResponseFormatter {
-  constructor() {}
-  /**
-   * Returns a standard formatted  ApiSuccesReponse or ApiErrorResponse depending on the response data
-   * @param statusCode - Http Status code
-   * @param responseData - Response value from the api controller method
-   */
-  public getStandardApiResponse(
-    statusCode: number,
-    responseData: any,
-  ): GenericSuccessResponse<any> | GenericErrorResponse {
-    if (this.isSuccessfulResult(responseData)) {
-      return this.getSuccessResponse(responseData, statusCode);
-    }
-
-    if (this.isFailedResult(responseData)) {
-      return this.getFailureResponse(responseData);
-    }
-
-    return responseData;
-  }
-
-  /**
-   *
-   * @param responseData Initializes and returns  the success api response
-   * @param statusCode - Http Status code
-   * @returns - instance of ApiSuccessResponse object
-   */
-  private getSuccessResponse(
-    responseData: any,
-    statusCode: number,
-  ): GenericSuccessResponse<any> {
-    const apiSuccessResponse = new GenericSuccessResponse();
-    apiSuccessResponse.initialize(responseData, statusCode);
-    return apiSuccessResponse;
-  }
-
-  /**
-   * Checks if the the data is of type Result and is successful
-   * @param responseData - response data
-   * @returns - boolean
-   */
-  private isSuccessfulResult(responseData: any): boolean {
-    return responseData instanceof Result && responseData.success;
-  }
-
-  /**
-   * Checks if the the data is of type Result and is successful
-   * @param responseData - response data
-   * @returns - boolean
-   */
-  private isFailedResult(responseData: any): boolean {
-    return responseData instanceof Result && !responseData.success;
-  }
-
-  /**
-   * Gets the failure response based on the result contents
-   * @param result - Result object returned from the controller method
-   */
-  private getFailureResponse(result: Result<any>) {
-    const statusCode = this.getStatusCode(result.error);
-    const apiErrorResponse = new GenericErrorResponse();
-    apiErrorResponse.initialize(result, statusCode);
-    return apiErrorResponse;
-  }
-
-  private getStatusCode(error: GenericError): number {
-    if (error instanceof BadRequestError) {
-      return HttpStatus.BAD_REQUEST;
-    }
-
-    if (error instanceof UnauthorizedError) {
-      return HttpStatus.UNAUTHORIZED;
-    }
-
-    if (error instanceof ForbiddenError) {
-      return HttpStatus.FORBIDDEN;
-    }
-
-    if (error instanceof NotFoundError) {
-      return HttpStatus.NOT_FOUND;
-    }
-
-    if (error instanceof AlreadyExistsError) {
-      return HttpStatus.CONFLICT;
-    }
-
-    if (error instanceof ConflictError) {
-      return HttpStatus.CONFLICT;
-    }
-
-    if (error instanceof ValidationError) {
-      return HttpStatus.UNPROCESSABLE_ENTITY;
-    }
-
-    if (error instanceof UnprocessableEntityError) {
-      return HttpStatus.UNPROCESSABLE_ENTITY;
-    }
-
-    if (error instanceof ServiceUnavailableError) {
-      return HttpStatus.SERVICE_UNAVAILABLE;
-    }
-
-    if (error instanceof InternalServerError) {
-      return HttpStatus.INTERNAL_SERVER_ERROR;
-    }
-
-    if (error instanceof GenericError) {
-      return error.statusCode;
-    }
-
-    return HttpStatus.INTERNAL_SERVER_ERROR;
-  }
-}