@unito/integration-sdk 1.0.27 → 1.1.0

package/dist/src/middlewares/filters.js

@@ -4,8 +4,8 @@ import { OperatorType } from '@unito/integration-api';
 // a subset of the symbol of another operator.
 //
 // For example, the symbol "=" (EQUAL) is a subset of the symbol "!=" (NOT_EQUAL).
-const ORDERED_OPERATORS = Object.values(OperatorType).sort((o1, o2) => o1.length - o2.length);
-const middleware = (req, res, next) => {
+const ORDERED_OPERATORS = Object.values(OperatorType).sort((o1, o2) => o2.length - o1.length);
+function extractFilters(req, res, next) {
     const rawFilters = req.query.filter;
     res.locals.filters = [];
     if (typeof rawFilters === 'string') {
@@ -21,5 +21,5 @@ const middleware = (req, res, next) => {
         }
     }
     next();
-};
-export default middleware;
+}
+export default extractFilters;

package/dist/src/middlewares/finish.d.ts

@@ -10,5 +10,5 @@ declare global {
         }
     }
 }
-declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
-export default middleware;
+declare function onFinish(req: Request, res: Response, next: NextFunction): void;
+export default onFinish;

package/dist/src/middlewares/finish.js

@@ -1,4 +1,4 @@
-const middleware = (req, res, next) => {
+function onFinish(req, res, next) {
     if (req.originalUrl !== '/health') {
         res.on('finish', function () {
             const error = res.locals.error;
@@ -32,5 +32,5 @@ const middleware = (req, res, next) => {
         });
     }
     next();
-};
-export default middleware;
+}
+export default onFinish;

package/dist/src/middlewares/logger.d.ts

@@ -8,5 +8,5 @@ declare global {
         }
     }
 }
-declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
-export default middleware;
+declare function injectLogger(req: Request, res: Response, next: NextFunction): void;
+export default injectLogger;

package/dist/src/middlewares/logger.js

@@ -1,6 +1,6 @@
 import Logger from '../resources/logger.js';
 const ADDITIONAL_CONTEXT_HEADER = 'X-Unito-Additional-Logging-Context';
-const middleware = (req, res, next) => {
+function injectLogger(req, res, next) {
     const logger = new Logger({ correlation_id: res.locals.correlationId });
     res.locals.logger = logger;
     const rawAdditionalContext = req.header(ADDITIONAL_CONTEXT_HEADER);
@@ -14,5 +14,5 @@ const middleware = (req, res, next) => {
         }
     }
     next();
-};
-export default middleware;
+}
+export default injectLogger;

package/dist/src/middlewares/notFound.d.ts

@@ -1,3 +1,3 @@
 import { Request, Response, NextFunction } from 'express';
-declare const middleware: (req: Request, res: Response, _next: NextFunction) => void;
-export default middleware;
+declare function notFound(req: Request, res: Response, _next: NextFunction): void;
+export default notFound;

package/dist/src/middlewares/notFound.js

@@ -1,8 +1,8 @@
-const middleware = (req, res, _next) => {
+function notFound(req, res, _next) {
     const error = {
         code: '404',
         message: `Path ${req.path} not found.`,
     };
     res.status(404).json(error);
-};
-export default middleware;
+}
+export default notFound;

package/dist/src/middlewares/secrets.d.ts

@@ -14,5 +14,5 @@ declare global {
 export type Secrets = {
     [keys: string]: unknown;
 };
-declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
-export default middleware;
+declare function extractSecrets(req: Request, res: Response, next: NextFunction): void;
+export default extractSecrets;

package/dist/src/middlewares/secrets.js

@@ -1,6 +1,6 @@
 import { BadRequestError } from '../httpErrors.js';
 const SECRETS_HEADER = 'X-Unito-Secrets';
-const middleware = (req, res, next) => {
+function extractSecrets(req, res, next) {
     const secretsHeader = req.header(SECRETS_HEADER);
     if (secretsHeader) {
         let secrets;
@@ -13,5 +13,5 @@ const middleware = (req, res, next) => {
         res.locals.secrets = secrets;
     }
     next();
-};
-export default middleware;
+}
+export default extractSecrets;

package/dist/src/middlewares/selects.d.ts

@@ -6,5 +6,5 @@ declare global {
         }
     }
 }
-declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
-export default middleware;
+declare function extractSelects(req: Request, res: Response, next: NextFunction): void;
+export default extractSelects;

package/dist/src/middlewares/selects.js

@@ -1,4 +1,4 @@
-const middleware = (req, res, next) => {
+function extractSelects(req, res, next) {
     const rawSelect = req.query.select;
     if (typeof rawSelect === 'string') {
         res.locals.selects = rawSelect.split(',');
@@ -7,5 +7,5 @@ const middleware = (req, res, next) => {
         res.locals.selects = [];
     }
     next();
-};
-export default middleware;
+}
+export default extractSelects;

package/dist/src/middlewares/signal.d.ts

@@ -11,5 +11,5 @@ declare global {
         }
     }
 }
-declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
-export default middleware;
+declare function extractOperationDeadline(req: Request, res: Response, next: NextFunction): void;
+export default extractOperationDeadline;

package/dist/src/middlewares/signal.js

@@ -1,6 +1,6 @@
 import { TimeoutError } from '../httpErrors.js';
 const OPERATION_DEADLINE_HEADER = 'X-Unito-Operation-Deadline';
-const middleware = (req, res, next) => {
+function extractOperationDeadline(req, res, next) {
     const operationDeadlineHeader = Number(req.header(OPERATION_DEADLINE_HEADER));
     if (operationDeadlineHeader) {
         // `operationDeadlineHeader` represents a timestamp in the future, in seconds.
@@ -18,5 +18,5 @@ const middleware = (req, res, next) => {
         res.locals.signal = AbortSignal.timeout(20000);
     }
     next();
-};
-export default middleware;
+}
+export default extractOperationDeadline;

package/dist/src/middlewares/{requestStartTime.d.ts → start.d.ts}

@@ -6,5 +6,5 @@ declare global {
         }
     }
 }
-declare const middleware: (_: Request, res: Response, next: NextFunction) => void;
-export default middleware;
+declare function start(_: Request, res: Response, next: NextFunction): void;
+export default start;

package/dist/src/middlewares/{requestStartTime.js → start.js}

@@ -1,5 +1,5 @@
-const middleware = (_, res, next) => {
+function start(_, res, next) {
     res.locals.requestStartTime = process.hrtime.bigint();
     next();
-};
-export default middleware;
+}
+export default start;

package/dist/test/errors.test.js

@@ -5,7 +5,7 @@ import * as httpErrors from '../src/httpErrors.js';
 describe('handleErrorResponse', () => {
     it('returns correct httpError given status code', () => {
         assert.ok(errors.buildHttpError(401, 'unauthorized') instanceof httpErrors.UnauthorizedError);
-        assert.ok(errors.buildHttpError(403, 'forbidden') instanceof httpErrors.UnauthorizedError);
+        assert.ok(errors.buildHttpError(403, 'forbidden') instanceof httpErrors.ForbiddenError);
         assert.ok(errors.buildHttpError(404, 'not found') instanceof httpErrors.NotFoundError);
         assert.ok(errors.buildHttpError(408, 'timeout') instanceof httpErrors.TimeoutError);
         assert.ok(errors.buildHttpError(410, 'resource gone') instanceof httpErrors.ResourceGoneError);

package/dist/test/middlewares/correlationId.test.js

@@ -1,11 +1,11 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/correlationId.js';
+import extractCorrelationId from '../../src/middlewares/correlationId.js';
 describe('correlationId middleware', () => {
     it('uses header', () => {
         const request = { header: (_key) => '123' };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractCorrelationId(request, response, () => { });
         assert.deepEqual(response.locals, {
             correlationId: '123',
         });
@@ -13,7 +13,7 @@ describe('correlationId middleware', () => {
     it('fallback', () => {
         const request = { header: (_key) => undefined };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractCorrelationId(request, response, () => { });
         assert(response.locals.correlationId);
     });
 });

package/dist/test/middlewares/credentials.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/credentials.js';
+import extractCredentials from '../../src/middlewares/credentials.js';
 import { BadRequestError } from '../../src/httpErrors.js';
 describe('credentials middleware', () => {
     it('generates', async () => {
@@ -9,7 +9,7 @@ describe('credentials middleware', () => {
         })).toString('base64');
         const request = { header: (_key) => credentials };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractCredentials(request, response, () => { });
         assert.deepEqual(response.locals, {
             credentials: {
                 accessToken: 'abc',
@@ -19,7 +19,7 @@ describe('credentials middleware', () => {
     it('malformed header', async () => {
         const request = { header: (_key) => 'nope' };
         const response = { locals: {} };
-        assert.throws(() => middleware(request, response, () => { }), BadRequestError);
+        assert.throws(() => extractCredentials(request, response, () => { }), BadRequestError);
     });
     it('variables', async () => {
         const credentials = Buffer.from(JSON.stringify({
@@ -27,7 +27,7 @@ describe('credentials middleware', () => {
         })).toString('base64');
         const request = { header: (_key) => credentials };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractCredentials(request, response, () => { });
         assert.deepEqual(response.locals, {
             credentials: {
                 apiKey: 'abc',

package/dist/test/middlewares/errors.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/errors.js';
+import onError from '../../src/middlewares/errors.js';
 import { HttpError } from '../../src/httpErrors.js';
 describe('errors middleware', () => {
     it('headers sent, do nothing', () => {
@@ -18,7 +18,7 @@ describe('errors middleware', () => {
             },
             locals: { logger: { error: () => undefined } },
         };
-        middleware(new Error(), {}, response, () => { });
+        onError(new Error(), {}, response, () => { });
         assert.strictEqual(actualStatus, undefined);
         assert.strictEqual(actualJson, undefined);
     });
@@ -37,7 +37,7 @@ describe('errors middleware', () => {
             },
             locals: { logger: { error: () => undefined } },
         };
-        middleware(new HttpError('httpError', 429), {}, response, () => { });
+        onError(new HttpError('httpError', 429), {}, response, () => { });
         assert.strictEqual(actualStatus, 429);
         assert.deepEqual(actualJson, { code: '429', message: 'httpError' });
     });
@@ -56,7 +56,7 @@ describe('errors middleware', () => {
             },
             locals: { logger: { error: () => undefined } },
         };
-        middleware(new Error('error'), {}, response, () => { });
+        onError(new Error('error'), {}, response, () => { });
         assert.strictEqual(actualStatus, 500);
         assert.strictEqual(actualJson?.code, '500');
         assert.deepEqual(actualJson?.originalError, { code: 'Error', message: 'error' });

package/dist/test/middlewares/filters.test.js

@@ -1,24 +1,32 @@
 import { OperatorType } from '@unito/integration-api';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/filters.js';
+import extractFilters from '../../src/middlewares/filters.js';
 describe('filters middleware', () => {
-    it('data', () => {
-        const request = { query: { filter: 'status=active|pending,createdAt>2022-01-01,email!!' } };
+    it('properly parse operators', () => {
+        Object.values(OperatorType).forEach(operator => {
+            const request = {
+                query: { filter: `aKey${operator}value` },
+            };
+            const response = { locals: {} };
+            extractFilters(request, response, () => { });
+            assert.deepEqual(response.locals, {
+                filters: [{ field: 'aKey', operator, values: ['value'] }],
+            });
+        });
+        const request = {
+            query: { filter: `aKey!!` },
+        };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractFilters(request, response, () => { });
         assert.deepEqual(response.locals, {
-            filters: [
-                { field: 'status', operator: OperatorType.EQUAL, values: ['active', 'pending'] },
-                { field: 'createdAt', operator: OperatorType.GREATER_THAN, values: ['2022-01-01'] },
-                { field: 'email', operator: OperatorType.IS_NOT_NULL, values: [] },
-            ],
+            filters: [{ field: 'aKey', operator: OperatorType.IS_NULL, values: [] }],
         });
     });
     it('decodes URI components', () => {
-        const request = { query: { filter: 'status=foo%2Cbar!!%2C%3Fbaz%3D!%3Equx' } };
+        const request = { query: { filter: 'status=foo%2Cbar%21%21%2C%3Fbaz%3D!%3Equx' } };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractFilters(request, response, () => { });
         assert.deepEqual(response.locals, {
             filters: [{ field: 'status', operator: OperatorType.EQUAL, values: ['foo,bar!!,?baz=!>qux'] }],
         });
@@ -26,7 +34,7 @@ describe('filters middleware', () => {
     it('no data', () => {
         const request = { query: {} };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractFilters(request, response, () => { });
         assert.deepEqual(response.locals, {
             filters: [],
         });

package/dist/test/middlewares/finish.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/finish.js';
+import onFinish from '../../src/middlewares/finish.js';
 describe('finish middleware', () => {
     it('logs info', () => {
         let expected = '';
@@ -20,7 +20,7 @@ describe('finish middleware', () => {
             },
             statusCode: 200,
         };
-        middleware(request, response, () => { });
+        onFinish(request, response, () => { });
         eventHandler();
         assert.equal(expected, 'works!');
     });
@@ -42,7 +42,7 @@ describe('finish middleware', () => {
             },
             statusCode: 500,
         };
-        middleware(request, response, () => { });
+        onFinish(request, response, () => { });
         eventHandler();
         assert.equal(expected, 'works!');
     });
@@ -64,7 +64,7 @@ describe('finish middleware', () => {
             },
             statusCode: 200,
         };
-        middleware(request, response, () => { });
+        onFinish(request, response, () => { });
         eventHandler();
         assert.equal(expected, '');
     });

package/dist/test/middlewares/logger.test.js

@@ -1,11 +1,11 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/logger.js';
+import injectLogger from '../../src/middlewares/logger.js';
 describe('logger middleware', () => {
     it('initializes', () => {
         const request = { header: (_key) => undefined };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        injectLogger(request, response, () => { });
         assert.deepEqual(response.locals.logger.getMetadata(), {
             correlation_id: undefined,
         });
@@ -13,7 +13,7 @@ describe('logger middleware', () => {
     it('correlation id', () => {
         const request = { header: (_key) => undefined };
         const response = { locals: { correlationId: '123' } };
-        middleware(request, response, () => { });
+        injectLogger(request, response, () => { });
         assert.deepEqual(response.locals.logger.getMetadata(), {
             correlation_id: '123',
         });
@@ -24,7 +24,7 @@ describe('logger middleware', () => {
         });
         const request = { header: (_key) => additional };
         const response = { locals: { correlationId: '123' } };
-        middleware(request, response, () => { });
+        injectLogger(request, response, () => { });
         assert.deepEqual(response.locals.logger.getMetadata(), {
             correlation_id: '123',
             foo: 'bar',
@@ -33,7 +33,7 @@ describe('logger middleware', () => {
     it('malformed additional context', () => {
         const request = { header: (_key) => 'nope' };
         const response = { locals: { correlationId: '123' } };
-        middleware(request, response, () => { });
+        injectLogger(request, response, () => { });
         assert.deepEqual(response.locals.logger.getMetadata(), {
             correlation_id: '123',
         });

package/dist/test/middlewares/notFound.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/notFound.js';
+import notFound from '../../src/middlewares/notFound.js';
 describe('notFound middleware', () => {
     it('respond with error without calling next', () => {
         let actualStatus;
@@ -17,7 +17,7 @@ describe('notFound middleware', () => {
             },
             locals: { logger: { error: () => undefined } },
         };
-        middleware({ path: 'unknownPath' }, response, () => {
+        notFound({ path: 'unknownPath' }, response, () => {
             throw new Error('next should not be called');
         });
         assert.strictEqual(actualStatus, 404);

package/dist/test/middlewares/secrets.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/secrets.js';
+import extractSecrets from '../../src/middlewares/secrets.js';
 import { BadRequestError } from '../../src/httpErrors.js';
 describe('secrets middleware', () => {
     it('uses header', () => {
@@ -9,7 +9,7 @@ describe('secrets middleware', () => {
         })).toString('base64');
         const request = { header: (_key) => secrets };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractSecrets(request, response, () => { });
         assert.deepEqual(response.locals, {
             secrets: {
                 chut: 'abc',
@@ -19,7 +19,7 @@ describe('secrets middleware', () => {
     it('malformed header', async () => {
         const request = { header: (_key) => 'nope' };
         const response = { locals: {} };
-        assert.throws(() => middleware(request, response, () => { }), BadRequestError);
+        assert.throws(() => extractSecrets(request, response, () => { }), BadRequestError);
     });
     it('undefined', () => {
         const response = { locals: {} };

package/dist/test/middlewares/selects.test.js

@@ -1,11 +1,11 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/selects.js';
+import extractSelects from '../../src/middlewares/selects.js';
 describe('selects middleware', () => {
     it('data', () => {
         const request = { query: { select: 'foo,bar.spam,baz' } };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractSelects(request, response, () => { });
         assert.deepEqual(response.locals, {
             selects: ['foo', 'bar.spam', 'baz'],
         });
@@ -13,7 +13,7 @@ describe('selects middleware', () => {
     it('no data', () => {
         const request = { query: {} };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractSelects(request, response, () => { });
         assert.deepEqual(response.locals, {
             selects: [],
         });

package/dist/test/middlewares/signal.test.js

@@ -1,19 +1,19 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import middleware from '../../src/middlewares/signal.js';
+import extractOperationDeadline from '../../src/middlewares/signal.js';
 describe('signal middleware', () => {
     it('uses header', () => {
         const deadline = Math.floor((Date.now() + 5000) / 1000);
         const request = { header: (_key) => deadline };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractOperationDeadline(request, response, () => { });
         assert.ok(response.locals.signal instanceof AbortSignal);
         assert.equal(response.locals.signal.aborted, false);
     });
     it('defaults', () => {
         const request = { header: (_key) => undefined };
         const response = { locals: {} };
-        middleware(request, response, () => { });
+        extractOperationDeadline(request, response, () => { });
         assert.ok(response.locals.signal instanceof AbortSignal);
         assert.equal(response.locals.signal.aborted, false);
     });

package/dist/test/middlewares/start.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/middlewares/start.test.js

@@ -0,0 +1,11 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import start from '../../src/middlewares/start.js';
+describe('start middleware', () => {
+    it('adds request start time to locals', () => {
+        const request = {};
+        const response = { locals: {} };
+        start(request, response, () => { });
+        assert.ok(response.locals.requestStartTime);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "1.0.27",
+  "version": "1.1.0",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/errors.ts

@@ -13,8 +13,10 @@ export function buildHttpError(responseStatus: number, message: string): HttpErr
   let httpError: HttpErrors.HttpError;
   if (responseStatus === 400) {
     httpError = new HttpErrors.BadRequestError(message);
-  } else if (responseStatus === 401 || responseStatus === 403) {
+  } else if (responseStatus === 401) {
     httpError = new HttpErrors.UnauthorizedError(message);
+  } else if (responseStatus === 403) {
+    httpError = new HttpErrors.ForbiddenError(message);
   } else if (responseStatus === 404) {
     httpError = new HttpErrors.NotFoundError(message);
   } else if (responseStatus === 408) {

package/src/helpers.ts

@@ -12,7 +12,7 @@ import { Filter } from './index.js';
  * @param fields The schema of the item against which the filters are applied
  * @returns The validated filters
  */
-export const getApplicableFilters = (context: { filters: Filter[] }, fields: FieldSchema[]): Filter[] => {
+export function getApplicableFilters(context: { filters: Filter[] }, fields: FieldSchema[]): Filter[] {
   const applicableFilters: Filter[] = [];
 
   for (const filter of context.filters) {
@@ -34,4 +34,4 @@ export const getApplicableFilters = (context: { filters: Filter[] }, fields: Fie
   }
 
   return applicableFilters;
-};
+}

package/src/httpErrors.ts

@@ -33,6 +33,15 @@ export class UnauthorizedError extends HttpError {
   }
 }
 
+/**
+ * Used to generate a 403 Forbidden. Usually used when user lacks sufficient permission to access a ressource.
+ */
+export class ForbiddenError extends HttpError {
+  constructor(message?: string) {
+    super(message || 'Forbidden', 403);
+  }
+}
+
 /**
  * Used to generate a 404 Not Found. Usually used when the requested `Item` is not found.
  */

package/src/integration.ts

@@ -2,18 +2,18 @@ import { Server, IncomingMessage, ServerResponse } from 'http';
 import express from 'express';
 
 import { InvalidHandler } from './errors.js';
+import { HandlersInput, Handler } from './handler.js';
 import correlationIdMiddleware from './middlewares/correlationId.js';
-import loggerMiddleware from './middlewares/logger.js';
 import credentialsMiddleware from './middlewares/credentials.js';
-import signalMiddleware from './middlewares/signal.js';
-import secretsMiddleware from './middlewares/secrets.js';
-import filtersMiddleware from './middlewares/filters.js';
-import selectsMiddleware from './middlewares/selects.js';
 import errorsMiddleware from './middlewares/errors.js';
+import filtersMiddleware from './middlewares/filters.js';
 import finishMiddleware from './middlewares/finish.js';
 import notFoundMiddleware from './middlewares/notFound.js';
-import requestStartTimeMiddleware from './middlewares/requestStartTime.js';
-import { HandlersInput, Handler } from './handler.js';
+import loggerMiddleware from './middlewares/logger.js';
+import startMiddleware from './middlewares/start.js';
+import secretsMiddleware from './middlewares/secrets.js';
+import selectsMiddleware from './middlewares/selects.js';
+import signalMiddleware from './middlewares/signal.js';
 
 function printErrorMessage(message: string) {
   console.error();
@@ -131,7 +131,7 @@ export default class Integration {
     app.use(finishMiddleware);
 
     // Instantiate internal middlewares.
-    app.use(requestStartTimeMiddleware);
+    app.use(startMiddleware);
     app.use(correlationIdMiddleware);
     app.use(loggerMiddleware);
 

package/src/middlewares/correlationId.ts

@@ -10,10 +10,10 @@ declare global {
   }
 }
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function extractCorrelationId(req: Request, res: Response, next: NextFunction) {
   res.locals.correlationId = req.header('X-Unito-Correlation-Id') ?? crypto.randomUUID();
 
   next();
-};
+}
 
-export default middleware;
+export default extractCorrelationId;