@villedemontreal/mongo 6.7.0 → 6.7.3

package/src/mongoClient.ts

@@ -10,6 +10,81 @@ const logger = createLogger('mongoClient');
 
 let mongooseConnection: mongoose.Connection;
 
+async function doInitMongoose(
+  mongooseConfigClean: MongooseConfigs,
+  resolve: (value: mongoose.Connection) => void,
+  reject: (reason?: any) => void
+): Promise<void> {
+  let connectionString = mongooseConfigClean.connectionString;
+
+  // ==========================================
+  // Mocked Mongo server?
+  // ==========================================
+  if (connectionString === constants.mongo.testing.MOCK_CONNECTION_STRING) {
+    // ==========================================
+    // Mock!
+    // ==========================================
+    const mongoServer = await mongoUtils.mockMongoose(
+      null,
+      mongooseConfigClean.mockServer.serverVersion
+    );
+
+    connectionString = mongoServer.getUri();
+  }
+
+  if (mongooseConnection) {
+    await mongooseConnection.close();
+    mongooseConnection = undefined;
+  }
+
+  // Updates Promise for mongoose, avoid warning log emit by mongoose
+  (mongoose as any).Promise = global.Promise;
+  const mongoOptions: mongoose.ConnectionOptions = defaultsDeep(
+    mongooseConfigClean.connectionOptions,
+    {
+      promiseLibrary: global.Promise,
+    }
+  );
+
+  // Creates the connection
+  mongooseConnection = mongoose.createConnection(connectionString, mongoOptions);
+
+  // Triggered if an error occured
+  mongooseConnection.on('error', (err: any) => {
+    mongooseConnection = null;
+    reject(`Mongo Database: Error connecting to Mongo: ${err}`);
+  });
+
+  // Triggered when the connection is made.
+  mongooseConnection.on('connected', () => {
+    (async () => {
+      // Check for schema updates once the connexion is made
+      if (mongooseConfigClean.applyUpdates) {
+        try {
+          await checkForUpdates(mongooseConfigClean);
+        } catch (err) {
+          try {
+            await mongooseConnection.close();
+            mongooseConnection = undefined;
+          } catch (err) {
+            logger.warning(`Error closing connection to Mongo : ${err}`);
+          }
+
+          reject(`Error updating Mongo: ${err}`);
+          return;
+        }
+      } else {
+        logger.info(`Mongo updates skipped`);
+      }
+
+      // All good!
+      resolve(mongooseConnection);
+    })().catch((err) => {
+      reject(err);
+    });
+  });
+}
+
 /**
  * This is the entry point to use this library to manage your
  * Mongoose connections.
@@ -26,68 +101,10 @@ export async function initMongoose(mongooseConfig: IMongooseConfigs): Promise<mo
   // ==========================================
   const mongooseConfigClean = new MongooseConfigs(mongooseConfig);
 
-  return new Promise<mongoose.Connection>(async (resolve, reject) => {
-    let connectionString = mongooseConfigClean.connectionString;
-
-    // ==========================================
-    // Mocked Mongo server?
-    // ==========================================
-    if (connectionString === constants.mongo.testing.MOCK_CONNECTION_STRING) {
-      // ==========================================
-      // Mock!
-      // ==========================================
-      const mongoServer = await mongoUtils.mockMongoose(null, mongooseConfigClean.mockServer.serverVersion);
-
-      connectionString = mongoServer.getUri();
-    }
-
-    try {
-      if (mongooseConnection) {
-        await mongooseConnection.close();
-        mongooseConnection = undefined;
-      }
-
-      // Updates Promise for mongoose, avoid warning log emit by mongoose
-      (mongoose as any).Promise = global.Promise;
-      const mongoOptions: mongoose.ConnectionOptions = defaultsDeep(mongooseConfigClean.connectionOptions, {
-        promiseLibrary: global.Promise
-      });
-
-      // Creates the connection
-      mongooseConnection = mongoose.createConnection(connectionString, mongoOptions);
-
-      // Triggered if an error occured
-      mongooseConnection.on('error', (err: any) => {
-        mongooseConnection = null;
-        reject('Mongo Database: Error connecting to Mongo: ' + err);
-      });
-
-      // Triggered when the connection is made.
-      mongooseConnection.on('connected', async () => {
-        // Check for schema updates once the connexion is made
-        if (mongooseConfigClean.applyUpdates) {
-          try {
-            await checkForUpdates(mongooseConfigClean);
-          } catch (err) {
-            try {
-              await mongooseConnection.close();
-              mongooseConnection = undefined;
-            } catch (err) {
-              logger.warning(`Error closing connection to Mongo : ${err}`);
-            }
-
-            return reject('Error updating Mongo: ' + err);
-          }
-        } else {
-          logger.info(`Mongo updates skipped`);
-        }
-
-        // All good!
-        resolve(mongooseConnection);
-      });
-    } catch (err) {
-      return reject('Error initializing Mongo: ' + err);
-    }
+  return new Promise<mongoose.Connection>((resolve, reject) => {
+    doInitMongoose(mongooseConfigClean, resolve, reject).catch((err) => {
+      reject(`Error initializing Mongo: ${err}`);
+    });
   });
 }
 
@@ -96,7 +113,7 @@ export async function initMongoose(mongooseConfig: IMongooseConfigs): Promise<mo
  * to run the application on the target Mongo database.
  */
 async function checkForUpdates(mongooseConfig: IMongooseConfigs): Promise<void> {
-  const connection = await getMongooseConnection();
+  const connection = getMongooseConnection();
   const updater: IMongoUpdater = new MongoUpdater(
     connection.db,
     mongooseConfig.updater.mongoSchemaUpdatesDirPath,

package/src/mongoUpdater.test.ts

@@ -26,7 +26,7 @@ describe('Mongo Updater', () => {
   // "this" value for "MongoUtils.mockMongoose(...)"
   const testconfig: IMongooseConfigs = mongodbConstants.testsConfig;
 
-  before(async function() {
+  before(async function () {
     // Makes sure Mongoose is mocked, but not in Jenkins as we will start a dedicated mongodb container.
     await mongoUtils.mockMongoose(this, testconfig.mockServer.serverVersion);
     const connection = await initMongoose(testconfig);
@@ -50,14 +50,14 @@ describe('Mongo Updater', () => {
     await mongoDb.dropDatabase();
   });
 
-  describe('getSchemaVersion', async () => {
+  describe('getSchemaVersion', () => {
     it('should contain schema version 0.0.0', async () => {
       const version: string = await mongoUpdater.getAppSchemaVersion();
       assert.strictEqual(version, '0.0.0');
     });
   });
 
-  describe('checkInstall', async () => {
+  describe('checkInstall', () => {
     let installAppSchemaCollectionSpy: sinon.SinonSpy;
 
     beforeEach(async () => {
@@ -100,22 +100,26 @@ describe('Mongo Updater', () => {
       assert.strictEqual(collections.length, 1);
       assert.strictEqual(collections[0].name, testconfig.updater.appSchemaCollectionName);
 
-      const schema: MongoDb.Collection = mongoDb.collection(testconfig.updater.appSchemaCollectionName);
+      const schema: MongoDb.Collection = mongoDb.collection(
+        testconfig.updater.appSchemaCollectionName
+      );
       const schemaDb: any[] = await schema.find().toArray();
       assert.strictEqual(schemaDb[0].version, '0.0.0');
     });
   });
 
-  describe('getSchemaVersion', async () => {
+  describe('getSchemaVersion', () => {
     it('should contain schema version 0.0.0', async () => {
       const version: string = await mongoUpdater.getAppSchemaVersion();
       assert.strictEqual(version, '0.0.0');
     });
   });
 
-  describe('lock', async () => {
+  describe('lock', () => {
     it('lock should be equal to false', async () => {
-      const schema: MongoDb.Collection = mongoDb.collection(testconfig.updater.appSchemaCollectionName);
+      const schema: MongoDb.Collection = mongoDb.collection(
+        testconfig.updater.appSchemaCollectionName
+      );
       const schemaDb: any[] = await schema.find().toArray();
       assert.strictEqual(schemaDb[0].lock, false);
     });
@@ -126,7 +130,9 @@ describe('Mongo Updater', () => {
     });
 
     it('lock should be equal to true', async () => {
-      const schema: MongoDb.Collection = mongoDb.collection(testconfig.updater.appSchemaCollectionName);
+      const schema: MongoDb.Collection = mongoDb.collection(
+        testconfig.updater.appSchemaCollectionName
+      );
       const schemaDb: any[] = await schema.find().toArray();
       assert.strictEqual(schemaDb[0].lock, true);
     });
@@ -137,9 +143,11 @@ describe('Mongo Updater', () => {
     });
   });
 
-  describe('unlock', async () => {
+  describe('unlock', () => {
     it('lock should be equal to true', async () => {
-      const schema: MongoDb.Collection = mongoDb.collection(testconfig.updater.appSchemaCollectionName);
+      const schema: MongoDb.Collection = mongoDb.collection(
+        testconfig.updater.appSchemaCollectionName
+      );
       const schemaDb: any[] = await schema.find().toArray();
       assert.strictEqual(schemaDb[0].lock, true);
     });
@@ -150,7 +158,9 @@ describe('Mongo Updater', () => {
     });
 
     it('lock should be equal to false', async () => {
-      const schema: MongoDb.Collection = mongoDb.collection(testconfig.updater.appSchemaCollectionName);
+      const schema: MongoDb.Collection = mongoDb.collection(
+        testconfig.updater.appSchemaCollectionName
+      );
       const schemaDb: any[] = await schema.find().toArray();
       assert.strictEqual(schemaDb[0].lock, false);
     });
@@ -159,13 +169,15 @@ describe('Mongo Updater', () => {
       const isUnlocked: boolean = await mongoUpdater.unlockAppSchemaDocument();
       assert.strictEqual(isUnlocked, false);
 
-      const schema: MongoDb.Collection = mongoDb.collection(testconfig.updater.appSchemaCollectionName);
+      const schema: MongoDb.Collection = mongoDb.collection(
+        testconfig.updater.appSchemaCollectionName
+      );
       const schemaDb: any[] = await schema.find().toArray();
       assert.strictEqual(schemaDb[0].lock, false);
     });
   });
 
-  describe('updateSchemaVersion', async () => {
+  describe('updateSchemaVersion', () => {
     it('should contain schema version 0.0.0', async () => {
       const version: string = await mongoUpdater.getAppSchemaVersion();
       assert.strictEqual(version, '0.0.0');
@@ -186,7 +198,7 @@ describe('Mongo Updater', () => {
     });
   });
 
-  describe('checkUpdate', async () => {
+  describe('checkUpdate', () => {
     let lockSpy: sinon.SinonSpy;
     let applyUpdateSchemasSpy: sinon.SinonSpy;
     let updateSchemaVersionSpy: sinon.SinonSpy;
@@ -222,7 +234,7 @@ describe('Mongo Updater', () => {
     // A regular function is *required* to get the proper
     // "this" value to call ".timeout(...)"
     // ==========================================
-    it('should wait when is already locked and should delete a lock that is too old', async function() {
+    it('should wait when is already locked and should delete a lock that is too old', async function () {
       this.timeout(5000);
 
       // Resets version to 0.0.0
@@ -250,7 +262,7 @@ describe('Mongo Updater', () => {
     });
   });
 
-  describe('getUpdateFiles', async () => {
+  describe('getUpdateFiles', () => {
     it('should not contain files for version between 0.0.0 and 0.0.0', async () => {
       const files: string[] = await mongoUpdater.getAppSchemaUpdateFiles('0.0.0', '0.0.0');
       assert.strictEqual(files.length, 0);
@@ -269,7 +281,7 @@ describe('Mongo Updater', () => {
     });
   });
 
-  describe('applyUpdateSchemas', async () => {
+  describe('applyUpdateSchemas', () => {
     let getUpdateFilesSpy: sinon.SinonSpy;
     beforeEach(async () => {
       getUpdateFilesSpy = sinon.spy(mongoUpdater, 'getAppSchemaUpdateFiles');

package/src/mongoUpdater.ts

@@ -97,7 +97,9 @@ export class MongoUpdater implements IMongoUpdater {
       // Installing the "appSchema" collection.
       // tslint:disable-next-line: prefer-template
       logger.info(' > Installing the "' + this.appSchemaCollectionName + '" collection.');
-      const collection: MongoDb.Collection = await this.mongoDb.createCollection(this.appSchemaCollectionName);
+      const collection: MongoDb.Collection = await this.mongoDb.createCollection(
+        this.appSchemaCollectionName
+      );
 
       // ==========================================
       // Makes sure only one appSchema document exists.
@@ -105,11 +107,11 @@ export class MongoUpdater implements IMongoUpdater {
       await collection.createIndexes([
         {
           key: {
-            name: 1
+            name: 1,
           },
           name: 'name_1',
-          unique: true
-        }
+          unique: true,
+        },
       ]);
 
       // ==========================================
@@ -119,7 +121,7 @@ export class MongoUpdater implements IMongoUpdater {
         name: 'singleton', // do not change!
         version: '0.0.0',
         lock: false,
-        lockTimestamp: 0
+        lockTimestamp: 0,
       } as ISchemeInfo);
     } catch (err) {
       // ==========================================
@@ -159,7 +161,9 @@ export class MongoUpdater implements IMongoUpdater {
 
     await appSchemaCollection.updateOne({}, { $set: { version: newVersion } });
     // tslint:disable-next-line: prefer-template
-    logger.info(' > MongoDB App Schema updagred from version ' + currentVersion + ' to version ' + newVersion);
+    logger.info(
+      ' > MongoDB App Schema updagred from version ' + currentVersion + ' to version ' + newVersion
+    );
   }
 
   public async getAppSchemaUpdateFiles(
@@ -176,13 +180,13 @@ export class MongoUpdater implements IMongoUpdater {
 
         try {
           filesClean = filesClean
-            .filter(name => {
+            .filter((name) => {
               return name.match(/\.js$/) !== null;
             })
-            .map(name => {
+            .map((name) => {
               return name.split('.js')[0];
             })
-            .filter(updateFileVersion => {
+            .filter((updateFileVersion) => {
               if (
                 semver.gt(updateFileVersion, currentAppSchemaVersion) &&
                 semver.lte(updateFileVersion, targetAppSchemaVersion)
@@ -200,7 +204,10 @@ export class MongoUpdater implements IMongoUpdater {
   }
 
   public async applyAppSchemaUpdates(currentVersion: string, newVersion: string): Promise<void> {
-    const updateFileNames: string[] = await this.getAppSchemaUpdateFiles(currentVersion, newVersion);
+    const updateFileNames: string[] = await this.getAppSchemaUpdateFiles(
+      currentVersion,
+      newVersion
+    );
     if (updateFileNames.length > 0) {
       for (const updateFileName of updateFileNames) {
         logger.info(' > Pending app schema update: ' + updateFileName);
@@ -216,7 +223,8 @@ export class MongoUpdater implements IMongoUpdater {
 
         if (!isFunction(updateFunction)) {
           return Promise.reject(
-            'The default export for an app schema update file must be a function! Was not for file : ' + updateFilePath
+            'The default export for an app schema update file must be a function! Was not for file : ' +
+              updateFilePath
           );
         }
 
@@ -227,7 +235,7 @@ export class MongoUpdater implements IMongoUpdater {
   }
 
   public async getAppSchemaCollection(): Promise<MongoDb.Collection> {
-    return await this.mongoDb.collection(this.appSchemaCollectionName);
+    return this.mongoDb.collection(this.appSchemaCollectionName);
   }
 
   public async getAppSchemaVersion(): Promise<string> {
@@ -259,8 +267,8 @@ export class MongoUpdater implements IMongoUpdater {
       {
         $set: {
           lock: true,
-          lockTimestamp: new Date().getTime()
-        }
+          lockTimestamp: new Date().getTime(),
+        },
       }
     );
 
@@ -291,8 +299,8 @@ export class MongoUpdater implements IMongoUpdater {
         {
           $set: {
             lock: true,
-            lockTimestamp: new Date().getTime()
-          }
+            lockTimestamp: new Date().getTime(),
+          },
         }
       );
 
@@ -321,8 +329,8 @@ export class MongoUpdater implements IMongoUpdater {
       {
         $set: {
           lock: false,
-          lockTimestamp: 0
-        }
+          lockTimestamp: 0,
+        },
       }
     );
 
@@ -339,13 +347,19 @@ export class MongoUpdater implements IMongoUpdater {
     logger.info(
       `Validating that the "${this.appSchemaCollectionName}" collection required by the application has been installed.`
     );
-    const collections: any[] = await this.mongoDb.listCollections({ name: this.appSchemaCollectionName }).toArray();
+    const collections: any[] = await this.mongoDb
+      .listCollections({ name: this.appSchemaCollectionName })
+      .toArray();
 
     if (collections.length === 0) {
-      logger.info(` > The "${this.appSchemaCollectionName}" collection was not found... Starting a new installation.`);
+      logger.info(
+        ` > The "${this.appSchemaCollectionName}" collection was not found... Starting a new installation.`
+      );
       await this.installAppSchemaCollection();
     } else {
-      logger.info(` > The "${this.appSchemaCollectionName}" collection was found. No installation required.`);
+      logger.info(
+        ` > The "${this.appSchemaCollectionName}" collection was found. No installation required.`
+      );
     }
   }
 
@@ -353,24 +367,20 @@ export class MongoUpdater implements IMongoUpdater {
     logger.info('Checking for db app schema updates:');
 
     let lockAcquired = false;
+    let currentAppSchemaVersion: string | undefined;
     const targetVersion: string = this.findMongoAppSchemaTargetVersion();
     try {
-      while (true) {
+      while (!lockAcquired) {
         // ==========================================
         // Checks if the appSchema version has to be
         // updated.
         // ==========================================
-        const currentAppSchemaVersion: string = await this.getAppSchemaVersion();
+        currentAppSchemaVersion = await this.getAppSchemaVersion();
         if (semver.gte(currentAppSchemaVersion, targetVersion)) {
           // tslint:disable-next-line: prefer-template
-          logger.info(' > Current database app schema is up to date : ' + currentAppSchemaVersion + ').');
-          return;
-        }
-
-        if (lockAcquired) {
-          logger.info(` > Applying some required updates...`);
-          await this.applyAppSchemaUpdates(currentAppSchemaVersion, targetVersion);
-          await this.updateAppSchemaVersion(currentAppSchemaVersion, targetVersion);
+          logger.info(
+            ' > Current database app schema is up to date : ' + currentAppSchemaVersion + ').'
+          );
           return;
         }
 
@@ -392,6 +402,11 @@ export class MongoUpdater implements IMongoUpdater {
           logger.info(` > Lock acquired.`);
         }
       }
+      if (lockAcquired && currentAppSchemaVersion) {
+        logger.info(` > Applying some required updates...`);
+        await this.applyAppSchemaUpdates(currentAppSchemaVersion, targetVersion);
+        await this.updateAppSchemaVersion(currentAppSchemaVersion, targetVersion);
+      }
     } finally {
       if (lockAcquired) {
         await this.unlockAppSchemaDocument();
@@ -409,7 +424,7 @@ export class MongoUpdater implements IMongoUpdater {
   protected findMongoAppSchemaTargetVersion(): string {
     let targetVersion = '0.0.0';
 
-    fs.readdirSync(this.getAppSchemaFilesDirPath()).forEach(fileName => {
+    fs.readdirSync(this.getAppSchemaFilesDirPath()).forEach((fileName) => {
       if (fileName.endsWith('.js')) {
         const version = fileName.split('.js')[0];
         if (semver.gt(version, targetVersion)) {

package/src/mongoUtils.test.ts

@@ -1,23 +1,23 @@
-import { assert } from 'chai';
-import { MongoMemoryReplSet, MongoMemoryServer } from 'mongodb-memory-server-core';
-import { MongoUtils } from './mongoUtils';
+// import { assert } from 'chai';
+// import { MongoMemoryReplSet, MongoMemoryServer } from 'mongodb-memory-server-core';
+// import { MongoUtils } from './mongoUtils';
 
-describe('MongoUtils - #mockMongoose', () => {
-  /*
-    It is mandatory to create a new instance of MongoUtils to test the function mockMongoose as the singleton will keep its parameters instanced if used again. The parameter mongoMemServer, if instanciated by a first call, 
-    won't be changed on a second one, as if the memory server is already mocked, nothing happens.
-  */
-  it('should return a mongo memory server', async function() {
-    const mongoUtils = new MongoUtils();
-    const memServ = await mongoUtils.mockMongoose(this, null, false);
-    assert.isDefined(memServ);
-    assert.instanceOf(memServ, MongoMemoryServer);
-  });
+// describe('MongoUtils - #mockMongoose', () => {
+//   /*
+//     It is mandatory to create a new instance of MongoUtils to test the function mockMongoose as the singleton will keep its parameters instanced if used again. The parameter mongoMemServer, if instanciated by a first call,
+//     won't be changed on a second one, as if the memory server is already mocked, nothing happens.
+//   */
+//   it('should return a mongo memory server', async function() {
+//     const mongoUtils = new MongoUtils();
+//     const memServ = await mongoUtils.mockMongoose(this, null, false);
+//     assert.isDefined(memServ);
+//     assert.instanceOf(memServ, MongoMemoryServer);
+//   });
 
-  it('should return a mongo memory replica set', async function() {
-    const mongoUtils = new MongoUtils();
-    const memServ = await mongoUtils.mockMongoose(this, null, true);
-    assert.isDefined(memServ);
-    assert.instanceOf(memServ, MongoMemoryReplSet);
-  });
-});
+//   it('should return a mongo memory replica set', async function() {
+//     const mongoUtils = new MongoUtils();
+//     const memServ = await mongoUtils.mockMongoose(this, null, true);
+//     assert.isDefined(memServ);
+//     assert.instanceOf(memServ, MongoMemoryReplSet);
+//   });
+// });

package/src/mongoUtils.ts

@@ -9,7 +9,7 @@ import {
   createServerError,
   globalConstants,
   IApiError,
-  utils
+  utils,
 } from '@villedemontreal/general-utils';
 import { LogLevel } from '@villedemontreal/logger';
 import * as fs from 'fs-extra';
@@ -25,7 +25,7 @@ import { constants } from './config/constants';
  */
 export class MongoUtils {
   private mongoMemServer: MongoMemoryServer | MongoMemoryReplSet;
-  private useReplSet: boolean = false;
+  private useReplSet = false;
 
   private mockgosseMockedFlag = 'mocked';
 
@@ -54,7 +54,7 @@ export class MongoUtils {
   public async mockMongoose(
     mochaInstance: mocha.Context,
     mongoServerVersion: string,
-    useReplSet: boolean = false
+    useReplSet = false
   ): Promise<MongoMemoryServer | MongoMemoryReplSet> {
     // ==========================================
     // We only mock the database if it's
@@ -106,20 +106,20 @@ export class MongoUtils {
       // Voir https://www.npmjs.com/package/mongodb-memory-server pour les options
       const memoryServerOption: any = {
         instance: {
-          dbPath: dataPath // by default create in temp directory,
+          dbPath: dataPath, // by default create in temp directory,
         },
 
         binary: {
           version: mongoServerVersion ? mongoServerVersion : 'latest', // by default 'latest'
-          downloadDir: downloadDirPath // by default node_modules/.cache/mongodb-memory-server/mongodb-binaries
+          downloadDir: downloadDirPath, // by default node_modules/.cache/mongodb-memory-server/mongodb-binaries
         },
-        debug: false
+        debug: false,
       };
 
       if (useReplSet) {
         const replSetOptions: any = {
           ...memoryServerOption,
-          replSet: { count: 3 }
+          replSet: { count: 3 },
         };
         this.mongoMemServer = await MongoMemoryReplSet.create(replSetOptions);
       } else {
@@ -175,7 +175,7 @@ export class MongoUtils {
       return true;
     }
 
-    Object.keys(obj.errors).forEach(errorKey => {
+    Object.keys(obj.errors).forEach((errorKey) => {
       const errorObject = obj.errors[errorKey];
 
       if (!('kind' in errorObject) || !('path' in errorObject) || !('message' in errorObject)) {
@@ -217,7 +217,10 @@ export class MongoUtils {
    * @param publicMessage a public message to be used in the
    * generated error. Fopr example : "The user is invalid".
    */
-  public convertMongoOrMongooseErrorToApiError(err: any, publicMessage: string): ApiErrorAndInfo | any {
+  public convertMongoOrMongooseErrorToApiError(
+    err: any,
+    publicMessage: string
+  ): ApiErrorAndInfo | any {
     if (!err) {
       return createServerError('Empty error object');
     }
@@ -234,7 +237,10 @@ export class MongoUtils {
       // code.
       // ==========================================
       if (errClean.code === constants.mongo.mongoErrorCodes.DUPLICATE_KEY) {
-        return createError(globalConstants.errors.apiGeneralErrors.codes.DUPLICATE_KEY, publicMessage)
+        return createError(
+          globalConstants.errors.apiGeneralErrors.codes.DUPLICATE_KEY,
+          publicMessage
+        )
           .httpStatus(HttpStatusCodes.CONFLICT)
           .publicMessage(publicMessage)
           .logLevel(LogLevel.INFO)
@@ -263,7 +269,7 @@ export class MongoUtils {
         } else {
           const error = errClean;
           errClean = {
-            errors: [error]
+            errors: [error],
           };
         }
       }
@@ -271,13 +277,13 @@ export class MongoUtils {
       let errorDetails: IApiError[];
       if (errClean.errors && !_.isEmpty(errClean.errors)) {
         errorDetails = [];
-        Object.keys(errClean.errors).forEach(errorKey => {
+        Object.keys(errClean.errors).forEach((errorKey) => {
           const errorMessage = errClean.errors[errorKey];
 
           const errorDetail: IApiError = {
             code: errorMessage.kind,
             target: errorMessage.path,
-            message: errorMessage.message
+            message: errorMessage.message,
           };
           errorDetails.push(errorDetail);
         });
@@ -319,4 +325,4 @@ export class MongoUtils {
     return pojo;
   }
 }
-export let mongoUtils: MongoUtils = new MongoUtils();
+export const mongoUtils: MongoUtils = new MongoUtils();