@unito/integration-sdk 1.0.26 → 1.0.28

package/dist/test/resources/logger.test.js

@@ -32,86 +32,112 @@ describe('Logger', () => {
         assert.strictEqual(logSpy.mock.calls.length, 0);
         logger.log('test');
         assert.strictEqual(logSpy.mock.calls.length, 1);
-        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ correlation_id: '123456789', message: 'test', status: 'log' }),
-        ]);
+        let actual = JSON.parse(logSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'log');
         const errorSpy = testContext.mock.method(global.console, 'error', () => { });
         assert.strictEqual(errorSpy.mock.calls.length, 0);
         logger.error('test');
         assert.strictEqual(errorSpy.mock.calls.length, 1);
-        assert.deepEqual(errorSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ correlation_id: '123456789', message: 'test', status: 'error' }),
-        ]);
+        actual = JSON.parse(errorSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'error');
         const warnSpy = testContext.mock.method(global.console, 'warn', () => { });
         assert.strictEqual(warnSpy.mock.calls.length, 0);
         logger.warn('test');
         assert.strictEqual(warnSpy.mock.calls.length, 1);
-        assert.deepEqual(warnSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ correlation_id: '123456789', message: 'test', status: 'warn' }),
-        ]);
+        actual = JSON.parse(warnSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'warn');
         const infoSpy = testContext.mock.method(global.console, 'info', () => { });
         assert.strictEqual(infoSpy.mock.calls.length, 0);
         logger.info('test');
         assert.strictEqual(infoSpy.mock.calls.length, 1);
-        assert.deepEqual(infoSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ correlation_id: '123456789', message: 'test', status: 'info' }),
-        ]);
+        actual = JSON.parse(infoSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'info');
         const debugSpy = testContext.mock.method(global.console, 'debug', () => { });
         assert.strictEqual(debugSpy.mock.calls.length, 0);
         logger.debug('test');
         assert.strictEqual(debugSpy.mock.calls.length, 1);
-        assert.deepEqual(debugSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ correlation_id: '123456789', message: 'test', status: 'debug' }),
-        ]);
+        actual = JSON.parse(debugSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'debug');
     });
     it('merges message payload with metadata', testContext => {
-        const metadata = { correlation_id: '123456789', http: { method: 'GET' } };
-        const logger = new Logger(metadata);
         const logSpy = testContext.mock.method(global.console, 'log', () => { });
         assert.strictEqual(logSpy.mock.calls.length, 0);
+        const metadata = { correlation_id: '123456789', http: { method: 'GET' } };
+        const logger = new Logger(metadata);
         logger.log('test', { error: { code: '200', message: 'Page Not Found' } });
         assert.strictEqual(logSpy.mock.calls.length, 1);
-        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({
-                correlation_id: '123456789',
-                http: { method: 'GET' },
-                error: { code: '200', message: 'Page Not Found' },
-                message: 'test',
-                status: 'log',
-            }),
-        ]);
+        const actual = JSON.parse(logSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'log');
+        assert.deepEqual(actual['http'], { method: 'GET' });
+        assert.deepEqual(actual['error'], { code: '200', message: 'Page Not Found' });
     });
     it('overwrites conflicting metadata keys (1st level) with message payload', testContext => {
-        const metadata = { correlation_id: '123456789', http: { method: 'GET' } };
-        const logger = new Logger(metadata);
         const logSpy = testContext.mock.method(global.console, 'log', () => { });
         assert.strictEqual(logSpy.mock.calls.length, 0);
+        const metadata = { correlation_id: '123456789', http: { method: 'GET' } };
+        const logger = new Logger(metadata);
         logger.log('test', { http: { status_code: 200 } });
         assert.strictEqual(logSpy.mock.calls.length, 1);
-        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({
-                correlation_id: '123456789',
-                http: { status_code: 200 },
-                message: 'test',
-                status: 'log',
-            }),
-        ]);
+        const actual = JSON.parse(logSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'log');
+        assert.deepEqual(actual['http'], { status_code: 200 });
     });
     it('snakify keys of Message and Metadata', testContext => {
+        const logSpy = testContext.mock.method(global.console, 'log', () => { });
+        assert.strictEqual(logSpy.mock.calls.length, 0);
         const metadata = { correlationId: '123456789', http: { method: 'GET', statusCode: 200 } };
         const logger = new Logger(metadata);
+        logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
+        assert.strictEqual(logSpy.mock.calls.length, 1);
+        const actual = JSON.parse(logSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'log');
+        assert.deepEqual(actual['http'], { method: 'GET', status_code: 200 });
+        assert.deepEqual(actual['error_context'], { error_code: 200, error_message: 'Page Not Found' });
+    });
+    it('prunes sensitive Metadata', testContext => {
         const logSpy = testContext.mock.method(global.console, 'log', () => { });
         assert.strictEqual(logSpy.mock.calls.length, 0);
+        const metadata = {
+            correlationId: '123456789',
+            http: { method: 'GET', statusCode: 200, jwt: 'deepSecret' },
+            user: { contact: { email: 'deep_deep_deep@email.address', firstName: 'should be snakify then hidden' } },
+            access_token: 'secret',
+        };
+        const logger = new Logger(metadata);
         logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
         assert.strictEqual(logSpy.mock.calls.length, 1);
-        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({
-                correlation_id: '123456789',
-                http: { method: 'GET', status_code: 200 },
-                error_context: { error_code: 200, error_message: 'Page Not Found' },
-                message: 'test',
-                status: 'log',
-            }),
-        ]);
+        const actual = JSON.parse(logSpy.mock.calls[0]?.arguments[0]);
+        assert.ok(actual['date']);
+        assert.equal(actual['correlation_id'], '123456789');
+        assert.equal(actual['message'], 'test');
+        assert.equal(actual['status'], 'log');
+        assert.equal(actual['has_sensitive_attribute'], true);
+        assert.equal(actual['access_token'], '[REDACTED]');
+        assert.deepEqual(actual['http'], { method: 'GET', status_code: 200, jwt: '[REDACTED]' });
+        assert.deepEqual(actual['user']['contact'], { email: '[REDACTED]', first_name: '[REDACTED]' });
     });
 });

package/package.json

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

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/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;

package/src/middlewares/credentials.ts

@@ -14,7 +14,7 @@ export type Credentials = { accessToken?: string; [keys: string]: unknown };
 
 const CREDENTIALS_HEADER = 'X-Unito-Credentials';
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function extractCredentials(req: Request, res: Response, next: NextFunction) {
   const credentialsHeader = req.header(CREDENTIALS_HEADER);
 
   if (credentialsHeader) {
@@ -30,6 +30,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default extractCredentials;

package/src/middlewares/errors.ts

@@ -12,7 +12,7 @@ declare global {
   }
 }
 
-const middleware = (err: Error, _req: Request, res: Response, next: NextFunction) => {
+function onError(err: Error, _req: Request, res: Response, next: NextFunction) {
   if (res.headersSent) {
     return next(err);
   }
@@ -50,6 +50,6 @@ const middleware = (err: Error, _req: Request, res: Response, next: NextFunction
   }
 
   res.status(Number(error.code)).json(error);
-};
+}
 
-export default middleware;
+export default onError;

package/src/middlewares/filters.ts

@@ -32,9 +32,9 @@ export type Filter = {
 // 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 ORDERED_OPERATORS = Object.values(OperatorType).sort((o1, o2) => o2.length - o1.length);
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function extractFilters(req: Request, res: Response, next: NextFunction) {
   const rawFilters = req.query.filter;
 
   res.locals.filters = [];
@@ -55,6 +55,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default extractFilters;

package/src/middlewares/finish.ts

@@ -13,7 +13,7 @@ declare global {
   }
 }
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function onFinish(req: Request, res: Response, next: NextFunction) {
   if (req.originalUrl !== '/health') {
     res.on('finish', function () {
       const error = res.locals.error;
@@ -49,6 +49,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default onFinish;

package/src/middlewares/logger.ts

@@ -13,7 +13,7 @@ declare global {
 
 const ADDITIONAL_CONTEXT_HEADER = 'X-Unito-Additional-Logging-Context';
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function injectLogger(req: Request, res: Response, next: NextFunction) {
   const logger = new Logger({ correlation_id: res.locals.correlationId });
 
   res.locals.logger = logger;
@@ -31,6 +31,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default injectLogger;

package/src/middlewares/notFound.ts

@@ -1,13 +1,13 @@
 import { Request, Response, NextFunction } from 'express';
 import { Error as APIError } from '@unito/integration-api';
 
-const middleware = (req: Request, res: Response, _next: NextFunction) => {
+function notFound(req: Request, res: Response, _next: NextFunction) {
   const error: APIError = {
     code: '404',
     message: `Path ${req.path} not found.`,
   };
 
   res.status(404).json(error);
-};
+}
 
-export default middleware;
+export default notFound;

package/src/middlewares/secrets.ts

@@ -19,7 +19,7 @@ export type Secrets = { [keys: string]: unknown };
 
 const SECRETS_HEADER = 'X-Unito-Secrets';
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function extractSecrets(req: Request, res: Response, next: NextFunction) {
   const secretsHeader = req.header(SECRETS_HEADER);
 
   if (secretsHeader) {
@@ -35,6 +35,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default extractSecrets;

package/src/middlewares/selects.ts

@@ -16,7 +16,7 @@ declare global {
   }
 }
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function extractSelects(req: Request, res: Response, next: NextFunction) {
   const rawSelect = req.query.select;
 
   if (typeof rawSelect === 'string') {
@@ -26,6 +26,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default extractSelects;

package/src/middlewares/signal.ts

@@ -17,7 +17,7 @@ declare global {
 
 const OPERATION_DEADLINE_HEADER = 'X-Unito-Operation-Deadline';
 
-const middleware = (req: Request, res: Response, next: NextFunction) => {
+function extractOperationDeadline(req: Request, res: Response, next: NextFunction) {
   const operationDeadlineHeader = Number(req.header(OPERATION_DEADLINE_HEADER));
 
   if (operationDeadlineHeader) {
@@ -36,6 +36,6 @@ const middleware = (req: Request, res: Response, next: NextFunction) => {
   }
 
   next();
-};
+}
 
-export default middleware;
+export default extractOperationDeadline;

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

@@ -9,10 +9,10 @@ declare global {
   }
 }
 
-const middleware = (_: Request, res: Response, next: NextFunction) => {
+function start(_: Request, res: Response, next: NextFunction) {
   res.locals.requestStartTime = process.hrtime.bigint();
 
   next();
-};
+}
 
-export default middleware;
+export default start;

package/src/resources/logger.ts

@@ -14,6 +14,37 @@ type Value = {
 export type Metadata = Value & { message?: never };
 type ForbidenMetadataKey = 'message';
 
+/**
+ * See https://docs.datadoghq.com/logs/log_collection/?tab=host#custom-log-forwarding
+ * - Datadog Agent splits at 256kB (256000 bytes)...
+ * - ... but the same docs say that "for optimal performance, it is
+ *   recommended that an individual log be no greater than 25kB"
+ * -> Truncating at 25kB - a bit of wiggle room for metadata = 20kB.
+ */
+const MAX_LOG_MESSAGE_SIZE = parseInt(process.env.MAX_LOG_MESSAGE_SIZE ?? '20000', 10);
+const LOG_LINE_TRUNCATED_SUFFIX = ' - LOG LINE TRUNCATED';
+
+/**
+ * For *LogMeta* sanitization, we let in anything that was passed, except for clearly-problematic keys
+ */
+const LOGMETA_BLACKLIST = [
+  // Security
+  'access_token',
+  'bot_auth_code',
+  'client_secret',
+  'jwt',
+  'oauth_token',
+  'password',
+  'refresh_token',
+  'shared_secret',
+  'token',
+  // Privacy
+  'billing_email',
+  'email',
+  'first_name',
+  'last_name',
+];
+
 /**
  * Logger class that can be configured with metadata add creation and when logging to add additional context to your logs.
  */
@@ -107,21 +138,31 @@ export default class Logger {
   }
 
   private send(logLevel: LogLevel, message: string, metadata?: Metadata): void {
-    const processedMessage = this.snakifyKeys({
-      ...this.metadata,
-      ...metadata,
+    // We need to provide the date to Datadog. Otherwise, the date is set to when they receive the log.
+    const date = Date.now();
+
+    if (message.length > MAX_LOG_MESSAGE_SIZE) {
+      message = `${message.substring(0, MAX_LOG_MESSAGE_SIZE)}${LOG_LINE_TRUNCATED_SUFFIX}`;
+    }
+
+    let processedMetadata = Logger.snakifyKeys({ ...this.metadata, ...metadata, logMessageSize: message.length });
+    processedMetadata = Logger.pruneSensitiveMetadata(processedMetadata);
+
+    const processedLogs = {
+      ...processedMetadata,
       message,
+      date,
       status: logLevel,
-    });
+    };
 
     if (process.env.NODE_ENV === 'development') {
-      console[logLevel](JSON.stringify(processedMessage, null, 2));
+      console[logLevel](JSON.stringify(processedLogs, null, 2));
     } else {
-      console[logLevel](JSON.stringify(processedMessage));
+      console[logLevel](JSON.stringify(processedLogs));
     }
   }
 
-  private snakifyKeys<T extends Value>(value: T): T {
+  private static snakifyKeys(value: Value): Value {
     const result: Value = {};
 
     for (const key in value) {
@@ -130,6 +171,23 @@ export default class Logger {
       result[snakifiedKey] = deepValue;
     }
 
-    return result as T;
+    return result;
+  }
+
+  private static pruneSensitiveMetadata(metadata: Value, topLevelMeta?: Value): Value {
+    const prunedMetadata: Value = {};
+
+    for (const key in metadata) {
+      if (LOGMETA_BLACKLIST.includes(key)) {
+        prunedMetadata[key] = '[REDACTED]';
+        (topLevelMeta ?? prunedMetadata).has_sensitive_attribute = true;
+      } else if (typeof metadata[key] === 'object') {
+        prunedMetadata[key] = Logger.pruneSensitiveMetadata(metadata[key] as Value, topLevelMeta ?? prunedMetadata);
+      } else {
+        prunedMetadata[key] = metadata[key];
+      }
+    }
+
+    return prunedMetadata;
   }
 }

package/test/middlewares/correlationId.test.ts

@@ -1,14 +1,14 @@
 import express from 'express';
 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: string) => '123' } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractCorrelationId(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       correlationId: '123',
@@ -19,7 +19,7 @@ describe('correlationId middleware', () => {
     const request = { header: (_key: string) => undefined } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractCorrelationId(request, response, () => {});
 
     assert(response.locals.correlationId);
   });

package/test/middlewares/credentials.test.ts

@@ -1,7 +1,7 @@
 import express from 'express';
 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', () => {
@@ -15,7 +15,7 @@ describe('credentials middleware', () => {
     const request = { header: (_key: string) => credentials } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractCredentials(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       credentials: {
@@ -28,7 +28,7 @@ describe('credentials middleware', () => {
     const request = { header: (_key: string) => 'nope' } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    assert.throws(() => middleware(request, response, () => {}), BadRequestError);
+    assert.throws(() => extractCredentials(request, response, () => {}), BadRequestError);
   });
 
   it('variables', async () => {
@@ -41,7 +41,7 @@ describe('credentials middleware', () => {
     const request = { header: (_key: string) => credentials } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractCredentials(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       credentials: {

package/test/middlewares/errors.test.ts

@@ -1,7 +1,7 @@
 import express from 'express';
 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', () => {
@@ -23,7 +23,7 @@ describe('errors middleware', () => {
       locals: { logger: { error: () => undefined } },
     } as unknown as express.Response;
 
-    middleware(new Error(), {} as express.Request, response, () => {});
+    onError(new Error(), {} as express.Request, response, () => {});
 
     assert.strictEqual(actualStatus, undefined);
     assert.strictEqual(actualJson, undefined);
@@ -46,7 +46,7 @@ describe('errors middleware', () => {
       },
       locals: { logger: { error: () => undefined } },
     } as unknown as express.Response;
-    middleware(new HttpError('httpError', 429), {} as express.Request, response, () => {});
+    onError(new HttpError('httpError', 429), {} as express.Request, response, () => {});
 
     assert.strictEqual(actualStatus, 429);
     assert.deepEqual(actualJson, { code: '429', message: 'httpError' });
@@ -69,7 +69,7 @@ describe('errors middleware', () => {
       },
       locals: { logger: { error: () => undefined } },
     } as unknown as express.Response;
-    middleware(new Error('error'), {} as express.Request, response, () => {});
+    onError(new Error('error'), {} as express.Request, response, () => {});
 
     assert.strictEqual(actualStatus, 500);
     assert.strictEqual(actualJson?.code, '500');