@villedemontreal/correlation-id 5.3.6 → 5.3.7

package/src/middleware/correlationIdMiddleware.test.ts

@@ -7,10 +7,10 @@ import { setTestingConfigurations } from '../utils/testingConfigurations';
 import { createCorrelationIdMiddleware } from './correlationIdMiddleware';
 
 function delay(millis: number): Promise<void> {
-  return new Promise<void>(resolve =>
+  return new Promise<void>((resolve) =>
     setTimeout(() => {
       resolve();
-    }, millis)
+    }, millis),
   );
 }
 
@@ -19,7 +19,7 @@ function delay(millis: number): Promise<void> {
 // ==========================================
 setTestingConfigurations();
 
-const uuidMatcher: RegExp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const uuidMatcher = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
 // ==========================================
 // Correlation ID service
@@ -35,30 +35,29 @@ describe('Correlation ID Middleware', () => {
       res.end();
     });
 
-    await request(app)
-      .get('/')
-      .send();
+    await request(app).get('/').send();
   });
 
   it('should get correlation id from incoming request', async () => {
-    const testId: string = 'correlation-id-123';
+    const testId = 'correlation-id-123';
 
     const app: express.Application = express();
     app.use(createCorrelationIdMiddleware());
     app.get('/', (req, res) => {
       const actual = correlationIdService.getId();
-      assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
+      assert.strictEqual(
+        actual,
+        testId,
+        'getId() should return id from x-correlation-id header of inbound request',
+      );
       res.end();
     });
 
-    await request(app)
-      .get('/')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
   });
 
   it('should maintain correlation id with async callbacks', async () => {
-    const testId: string = 'correlation-id-123';
+    const testId = 'correlation-id-123';
 
     let actual = '';
     let actual2 = '';
@@ -73,18 +72,23 @@ describe('Correlation ID Middleware', () => {
     });
 
     assert.isUndefined(correlationIdService.getId());
-    await request(app)
-      .get('/')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
 
     assert.isUndefined(correlationIdService.getId());
-    assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual2, testId, 'getId() should return id from x-correlation-id header of inbound request');
+    assert.strictEqual(
+      actual,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual2,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
   });
 
   it('should maintain correlation id with async/await operations', async () => {
-    const testId: string = 'correlation-id-123';
+    const testId = 'correlation-id-123';
 
     let actual = '';
     let actual2 = '';
@@ -103,19 +107,24 @@ describe('Correlation ID Middleware', () => {
     });
 
     assert.isUndefined(correlationIdService.getId());
-    await request(app)
-      .get('/')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
 
     assert.isUndefined(correlationIdService.getId());
-    assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual2, testId, 'getId() should return id from x-correlation-id header of inbound request');
+    assert.strictEqual(
+      actual,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual2,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
   });
 
   it('should keep correlation ids in nested requests', async () => {
-    const testId: string = 'correlation-id-123';
-    const testId2: string = 'correlation-id-456';
+    const testId = 'correlation-id-123';
+    const testId2 = 'correlation-id-456';
 
     let actual = '';
     let actual2 = '';
@@ -129,10 +138,7 @@ describe('Correlation ID Middleware', () => {
         actual = correlationIdService.getId();
         await delay(250);
         actual2 = correlationIdService.getId();
-        await request(app)
-          .get('/foo')
-          .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId2)
-          .send();
+        await request(app).get('/foo').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId2).send();
         actual3 = correlationIdService.getId();
       } catch (e) {
         next(e);
@@ -153,24 +159,41 @@ describe('Correlation ID Middleware', () => {
     });
 
     assert.isUndefined(correlationIdService.getId());
-    await request(app)
-      .get('/')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
 
     assert.isUndefined(correlationIdService.getId());
-    assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual2, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual3, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual4, testId2, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual5, testId2, 'getId() should return id from x-correlation-id header of inbound request');
+    assert.strictEqual(
+      actual,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual2,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual3,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual4,
+      testId2,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual5,
+      testId2,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
   });
 
   // tslint:disable: no-console
-  it('should keep correlation ids separated in parallel requests', async function() {
+  it('should keep correlation ids separated in parallel requests', async function () {
     this.timeout(5000);
-    const testId: string = 'correlation-id-123';
-    const testId2: string = 'correlation-id-456';
+    const testId = 'correlation-id-123';
+    const testId2 = 'correlation-id-456';
 
     let actual = '';
     let actual2 = '';
@@ -212,10 +235,7 @@ describe('Correlation ID Middleware', () => {
 
     console.log('send req1');
     assert.isUndefined(correlationIdService.getId());
-    const req1 = request(app)
-      .get('/')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    const req1 = request(app).get('/').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
     console.log('send req2');
     assert.isUndefined(correlationIdService.getId());
     const req2 = request(app)
@@ -224,14 +244,30 @@ describe('Correlation ID Middleware', () => {
       .send();
     await Promise.all([req1, req2]);
     assert.isUndefined(correlationIdService.getId());
-    assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual2, testId, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual4, testId2, 'getId() should return id from x-correlation-id header of inbound request');
-    assert.strictEqual(actual5, testId2, 'getId() should return id from x-correlation-id header of inbound request');
+    assert.strictEqual(
+      actual,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual2,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual4,
+      testId2,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
+    assert.strictEqual(
+      actual5,
+      testId2,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
   });
 
   it('should work with operations causing errors', async () => {
-    const testId: string = 'correlation-id-123';
+    const testId = 'correlation-id-123';
 
     let actual = '';
     const app: express.Application = express();
@@ -248,11 +284,15 @@ describe('Correlation ID Middleware', () => {
       .send();
     assert.strictEqual(result.status, 500);
     assert.isUndefined(correlationIdService.getId());
-    assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
+    assert.strictEqual(
+      actual,
+      testId,
+      'getId() should return id from x-correlation-id header of inbound request',
+    );
   });
 
   it('a filter can be specified', async () => {
-    const testId: string = 'correlation-id-123';
+    const testId = 'correlation-id-123';
 
     const filter = (req: express.Request): boolean => {
       if (req.path.startsWith('/ok/')) {
@@ -266,12 +306,20 @@ describe('Correlation ID Middleware', () => {
 
     app.get('/ok/1', (req, res) => {
       const actual = correlationIdService.getId();
-      assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
+      assert.strictEqual(
+        actual,
+        testId,
+        'getId() should return id from x-correlation-id header of inbound request',
+      );
       res.end();
     });
     app.get('/ok/2', (req, res) => {
       const actual = correlationIdService.getId();
-      assert.strictEqual(actual, testId, 'getId() should return id from x-correlation-id header of inbound request');
+      assert.strictEqual(
+        actual,
+        testId,
+        'getId() should return id from x-correlation-id header of inbound request',
+      );
       res.end();
     });
     app.get('/notok/1', (req, res) => {
@@ -280,24 +328,15 @@ describe('Correlation ID Middleware', () => {
       res.end();
     });
 
-    await request(app)
-      .get('/ok/1')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/ok/1').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
 
-    await request(app)
-      .get('/ok/2')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/ok/2').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
 
-    await request(app)
-      .get('/notok/1')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/notok/1').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
   });
 
   it('getCidInfo() cid received', async () => {
-    const testId: string = 'correlation-id-123';
+    const testId = 'correlation-id-123';
 
     const app: express.Application = express();
     app.use(createCorrelationIdMiddleware());
@@ -310,10 +349,7 @@ describe('Correlation ID Middleware', () => {
       res.end();
     });
 
-    await request(app)
-      .get('/')
-      .set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId)
-      .send();
+    await request(app).get('/').set(httpHeaderFieldsTyped.X_CORRELATION_ID, testId).send();
   });
 
   it('getCidInfo() cid generated', async () => {
@@ -328,8 +364,6 @@ describe('Correlation ID Middleware', () => {
       res.end();
     });
 
-    await request(app)
-      .get('/')
-      .send();
+    await request(app).get('/').send();
   });
 });

package/src/middleware/correlationIdMiddleware.ts

@@ -9,13 +9,13 @@ import { correlationIdService } from '../services/correlationIdService';
  * @param filter a filter which is going to be called with the request to see if a
  * colleration id scope must be managed or not.
  */
-export let createCorrelationIdMiddleware = (
-  filter?: (req: express.Request) => boolean
+export const createCorrelationIdMiddleware = (
+  filter?: (req: express.Request) => boolean,
 ): ((req: express.Request, res: express.Response, next: express.NextFunction) => void) => {
   const correlationIdMiddleware = (
     req: express.Request,
     res: express.Response,
-    next: express.NextFunction
+    next: express.NextFunction,
   ): void => {
     if (filter && !filter(req)) {
       next();

package/src/services/correlationIdService.test.ts

@@ -7,14 +7,14 @@ import { correlationIdService } from './correlationIdService';
 
 setTestingConfigurations();
 
-const uuidMatcher: RegExp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const uuidMatcher = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
-async function timeout(work: (params?: any) => any, ms: number = 50) {
-  return new Promise<void>(resolve =>
+async function timeout(work: (params?: any) => any, ms = 50) {
+  return new Promise<void>((resolve) =>
     setTimeout(() => {
       work();
       resolve();
-    }, ms)
+    }, ms),
   );
 }
 
@@ -29,7 +29,7 @@ describe('Correlation Id Service', () => {
   describe('withId correlator', () => {
     it('with sync function', () => {
       // GIVEN
-      const expectedResult: string = '⭐';
+      const expectedResult = '⭐';
 
       // WHEN
       const result = correlationIdService.withId(() => {
@@ -43,7 +43,7 @@ describe('Correlation Id Service', () => {
     });
 
     it('with async function', async () => {
-      let done: boolean = false;
+      let done = false;
 
       const promise = correlationIdService.withId(async () => {
         await timeout(() => {
@@ -71,7 +71,7 @@ describe('Correlation Id Service', () => {
       const emitter = new EventEmitter();
       let receivedValue = 0;
       let receivedCid = '';
-      emitter.on('test', value => {
+      emitter.on('test', (value) => {
         receivedValue = value;
         receivedCid = correlationIdService.getId();
       });
@@ -110,7 +110,7 @@ describe('Correlation Id Service', () => {
         title: 'Hello-',
         say(msg: string): string {
           return this.title + msg + correlationIdService.getId();
-        }
+        },
       };
 
       // WHEN
@@ -124,13 +124,13 @@ describe('Correlation Id Service', () => {
     });
 
     it('with resolved promise', async () => {
-      let done: boolean = false;
+      let done = false;
 
       const promise = correlationIdService.withId(() =>
-        Promise.resolve(correlationIdService.getId()).then(id => {
+        Promise.resolve(correlationIdService.getId()).then((id) => {
           assert.match(id, uuidMatcher, 'Promise should resolve correlation id');
           done = true;
-        })
+        }),
       );
 
       // "withId" doesn't care about a promise to be floating or not
@@ -145,22 +145,30 @@ describe('Correlation Id Service', () => {
 
         correlationIdService.withId(() => {
           const cid2 = correlationIdService.getId();
-          assert.notEqual(cid2, cid1, 'correlationIdService.getId() should return a different id for every scope');
+          assert.notEqual(
+            cid2,
+            cid1,
+            'correlationIdService.getId() should return a different id for every scope',
+          );
           assert.match(cid2, uuidMatcher, 'correlationIdService.getId() should return a UUID');
         });
 
         const cid3 = correlationIdService.getId();
-        assert.strictEqual(cid3, cid1, 'correlationIdService.getId() should return the same id for the same scope');
+        assert.strictEqual(
+          cid3,
+          cid1,
+          'correlationIdService.getId() should return the same id for the same scope',
+        );
         assert.match(cid3, uuidMatcher, 'correlationIdService.getId() should return a UUID');
       });
     });
 
-    it('with async function', async function() {
+    it('with async function', async function () {
       const duration = 25;
       setSlowThreshold(this, duration);
 
       // GIVEN
-      const expectedResult: string = '⭐';
+      const expectedResult = '⭐';
 
       // WHEN
       const result = await correlationIdService.withId(async () => {
@@ -178,12 +186,12 @@ describe('Correlation Id Service', () => {
   });
 
   describe('withIdAsync correlator', () => {
-    it('with async function', async function() {
+    it('with async function', async function () {
       const duration = 25;
       setSlowThreshold(this, duration);
 
       // GIVEN
-      const expectedResult: string = '⭐';
+      const expectedResult = '⭐';
 
       // WHEN
       const result = await correlationIdService.withIdAsync(async () => {
@@ -211,7 +219,7 @@ describe('Correlation Id Service', () => {
       }
     });
 
-    it('with error after await', async function() {
+    it('with error after await', async function () {
       const duration = 25;
       setSlowThreshold(this, duration);
 
@@ -228,7 +236,7 @@ describe('Correlation Id Service', () => {
       }
     });
 
-    it('with nested async functions', async function() {
+    it('with nested async functions', async function () {
       const duration = 25;
       setSlowThreshold(this, 2 * duration);
 

package/src/services/correlationIdService.ts

@@ -111,9 +111,7 @@ class CorrelationIdServiceWithClsHooked implements ICorrelationIdService {
     return new Promise<T>((resolve, reject) => {
       this.withId(() => {
         try {
-          work()
-            .then(resolve)
-            .catch(reject);
+          work().then(resolve).catch(reject);
         } catch (err) {
           reject(err);
         }
@@ -139,7 +137,7 @@ class CorrelationIdServiceWithClsHooked implements ICorrelationIdService {
     return {
       current: this.getId(),
       receivedInRequest: req[constants.requestExtraVariables.cidReceivedInRequest],
-      generated: req[constants.requestExtraVariables.cidNew]
+      generated: req[constants.requestExtraVariables.cidNew],
     };
   }
 
@@ -212,7 +210,7 @@ class CorrelationIdServiceWithAsyncLocalStorage implements ICorrelationIdService
     return {
       current: this.getId(),
       receivedInRequest: req[constants.requestExtraVariables.cidReceivedInRequest],
-      generated: req[constants.requestExtraVariables.cidNew]
+      generated: req[constants.requestExtraVariables.cidNew],
     };
   }
 
@@ -239,7 +237,7 @@ class CorrelationIdServiceWithAsyncLocalStorage implements ICorrelationIdService
   private bindFunction<T extends Function>(target: T): T {
     const storage = this.storage;
     const store = this.storage.getStore();
-    return function(...args: any[]) {
+    return function (...args: any[]) {
       storage.enterWith(store);
       return target.call(this, ...args);
     } as any;
@@ -250,6 +248,6 @@ function canUseAsyncLocalStorage() {
   return semver.satisfies(process.versions.node, '>=13.10.0') && !!AsyncLocalStorage;
 }
 
-export let correlationIdService: ICorrelationIdService = canUseAsyncLocalStorage()
+export const correlationIdService: ICorrelationIdService = canUseAsyncLocalStorage()
   ? new CorrelationIdServiceWithAsyncLocalStorage()
   : new CorrelationIdServiceWithClsHooked();

package/src/utils/logger.ts

@@ -1,4 +1,11 @@
-import { ILogger, initLogger, LazyLogger, Logger, LoggerConfigs, LogLevel } from '@villedemontreal/logger';
+import {
+  ILogger,
+  initLogger,
+  LazyLogger,
+  Logger,
+  LoggerConfigs,
+  LogLevel,
+} from '@villedemontreal/logger';
 import { configs } from '../config/configs';
 
 let testingLoggerLibInitialised = false;