fix: possible duplicate injection, use common-errors and common-services lib. DRY :)

Author: lst97

index.ts

@@ -9,6 +9,5 @@ export {
   ErrorHandlerService,
   ErrorHandlerServiceInstance,
 } from "./src/services/ErrorHandlerService";
-export * from "./src/models/Errors";
 export { Config } from "./src/CommonResponse.config";
 export { ResponseSchemas } from "@lst97/common-response-structure";

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@lst97/common_response",
-  "version": "0.2.0-alpha.4",
+  "version": "0.2.0-alpha.5",
   "description": "This is a DEVELOPMENT package, not for production use. A common response structure for all the API's. Included basic error handling.",
   "main": "lib/cjs/index.js",
   "types": "lib/esm/index.d.ts",
@@ -9,7 +9,7 @@
     "lib"
   ],
   "scripts": {
-    "build": "rm -rf lib/ && npx prettier --write src/ && npm run build:cjs && npm run build:esm && cp src/models/MessageCodes.json lib/cjs/src/models/MessageCodes.json && cp src/models/MessageCodes.json lib/esm/src/models/MessageCodes.json",
+    "build": "rm -rf lib/ && npx prettier --write src/ && npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc --module commonjs --outDir lib/cjs",
     "build:esm": "tsc --module esnext --outDir lib/esm",
     "test": "jest",
@@ -19,7 +19,9 @@
   "author": "lst97",
   "license": "ISC",
   "devDependencies": {
-    "@lst97/common-response-structure": "0.2.0-alpha.6",
+    "@lst97/common-response-structure": "0.2.0-alpha.7",
+    "@lst97/common-services": "0.1.0-alpha.5",
+    "@lst97/common-errors": "0.1.0-alpha.5",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
     "@types/uuid": "^9.0.8",

package.json

@@ -1,25 +1,33 @@
+import { DefinedBaseError } from "@lst97/common-errors";
 import { Config as ResponseStructureConfig } from "@lst97/common-response-structure";
+import { Config as CommonErrorsConfig } from "@lst97/common-errors";
+import { Containers } from "./inversify.config";
 
+const SERVICE_NAME = "@lst97/common_response";
 export class Config {
   private static _instance: Config;
-  private _idIdentifier: string = "unknown";
+  private _idIdentifier: string = SERVICE_NAME;
   private _requestIdName: string = "requestId";
   private _traceIdName: string = "traceId";
+  private _errorCallback: (error: DefinedBaseError) => void = (
+    _error: DefinedBaseError,
+  ) => {};
 
   private constructor() {}
 
   public static get instance() {
     if (!Config._instance) {
       // Set for Schemas rules
-      ResponseStructureConfig.instance.requestIdName = "requestId";
-      ResponseStructureConfig.instance.traceIdName = "traceId";
+      ResponseStructureConfig.instance.idIdentifier = SERVICE_NAME;
+      CommonErrorsConfig.instance.idIdentifier = SERVICE_NAME;
       Config._instance = new Config();
     }
     return Config._instance;
   }
 
   public set idIdentifier(value: string) {
     ResponseStructureConfig.instance.idIdentifier = value;
+    CommonErrorsConfig.instance.idIdentifier = value;
     this._idIdentifier = value;
   }
 
@@ -29,6 +37,8 @@ export class Config {
 
   public set requestIdName(value: string) {
     ResponseStructureConfig.instance.requestIdName = value;
+
+    CommonErrorsConfig.instance.requestIdName = value;
     this._requestIdName = value;
   }
 
@@ -38,10 +48,26 @@ export class Config {
 
   public set traceIdName(value: string) {
     ResponseStructureConfig.instance.traceIdName = value;
+    CommonErrorsConfig.instance.traceIdName = value;
     this._traceIdName = value;
   }
 
   public get traceIdName() {
     return this._traceIdName;
   }
+
+  public set errorCallback(value: (error: DefinedBaseError) => void) {
+    this._errorCallback = value;
+
+    if (Containers.instance.inversifyContainer.isBound("ErrorCallback")) {
+      Containers.instance.inversifyContainer.unbind("ErrorCallback");
+    }
+    Containers.instance.inversifyContainer
+      .bind<(error: DefinedBaseError) => void>("ErrorCallback")
+      .toConstantValue(value);
+  }
+
+  public get errorCallback() {
+    return this._errorCallback;
+  }
 }

src/CommonResponse.config.ts

@@ -4,14 +4,12 @@ import {
   IErrorHandlerService,
 } from "./services/ErrorHandlerService";
 import { IResponseService, ResponseService } from "./services/ResponseService";
-import { ILogService, LogService } from "./services/LogService";
 import {
-  IMessageCodeService,
-  MessageCodeService,
-} from "./services/MessageCodeService";
-import { DefinedBaseError } from "./models/Errors";
-import pino, { Logger } from "pino";
-
+  DefinedBaseError,
+  useInversify as useCommonErrorsInversify,
+} from "@lst97/common-errors";
+import { useInversify as useCommonServicesInversify } from "@lst97/common-services";
+import { Config } from "./CommonResponse.config";
 /**
  * For the user to get the singleton instance of the services,
  * Support to use the provided container to build the services.
@@ -21,21 +19,11 @@ import pino, { Logger } from "pino";
  */
 export class Containers {
   private static _instance: Containers;
-  private _idIdentifier: string;
   private container: Container;
 
   private constructor() {
     this.container = new Container();
     this.buildContainers();
-    this._idIdentifier = "unknown";
-  }
-
-  public set idIdentifier(value: string) {
-    this._idIdentifier = value;
-  }
-
-  public get idIdentifier() {
-    return this._idIdentifier;
   }
 
   public static get instance() {
@@ -51,68 +39,34 @@ export class Containers {
 
   private buildContainers() {
     this.buildConstantsContainer();
+    this.buildLibContainers();
     this.buildServiceContainer();
   }
 
+  private buildLibContainers() {
+    useCommonServicesInversify(this.container);
+    useCommonErrorsInversify(this.container);
+  }
+
   // Arguments that required for the services
   private buildConstantsContainer() {
-    // using pino for logging with pretty print by default
-    const logger = pino({
-      level: process.env.LOG_LEVEL || "info",
-      formatters: {
-        level: (label) => {
-          return { level: label };
-        },
-      },
-      transport: {
-        target: "pino-pretty",
-        options: {
-          colorize: true,
-          translateTime: "SYS:dd-mm-yyyy HH:MM:ss o",
-        },
-      },
-    });
-    this.container.bind<Logger<never>>("Logger").toConstantValue(logger);
-
-    // TODO: user can provide the values
-    // path to the message codes json file
-    this.container
-      .bind<string>("MessageCodesJsonPath")
-      .toConstantValue("src/models/MessageCodes.json");
-
     // error callback for ErrorHandlerService
+    if (this.container.isBound("ErrorCallback")) {
+      this.container.unbind("ErrorCallback");
+    }
     this.container
       .bind<(error: DefinedBaseError) => void>("ErrorCallback")
-      .toConstantValue((_error: DefinedBaseError) => {});
+      .toConstantValue(Config.instance.errorCallback);
   }
   private buildServiceContainer() {
-    try {
-      this.container.get<ILogService>(LogService);
-    } catch (e) {
-      this.container.bind<ILogService>(LogService).toSelf().inSingletonScope();
-    }
-
-    try {
-      this.container.get<IMessageCodeService>(MessageCodeService);
-    } catch (e) {
-      this.container
-        .bind<IMessageCodeService>(MessageCodeService)
-        .toSelf()
-        .inSingletonScope();
-    }
-
-    try {
-      this.container.get<IErrorHandlerService>(ErrorHandlerService);
-    } catch (e) {
+    if (!this.container.isBound(ErrorHandlerService)) {
       this.container
         .bind<IErrorHandlerService>(ErrorHandlerService)
         .toSelf()
         .inSingletonScope();
     }
 
-    try {
-      this.container.get<IResponseService>(ResponseService);
-    } catch (e) {
+    if (!this.container.isBound(ResponseService)) {
       this.container
         .bind<IResponseService>(ResponseService)
         .toSelf()