@unito/integration-sdk 1.0.26 → 1.0.28

package/test/middlewares/filters.test.ts

@@ -2,32 +2,51 @@ import { OperatorType } from '@unito/integration-api';
 import express from 'express';
 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!!' } } as express.Request<
+  it('properly parse operators', () => {
+    Object.values(OperatorType).forEach(operator => {
+      const request = {
+        query: { filter: `aKey${operator}value` },
+      } as express.Request<
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        any,
+        object,
+        object,
+        { filter: string }
+      >;
+
+      const response = { locals: {} } as express.Response;
+
+      extractFilters(request, response, () => {});
+
+      assert.deepEqual(response.locals, {
+        filters: [{ field: 'aKey', operator, values: ['value'] }],
+      });
+    });
+
+    const request = {
+      query: { filter: `aKey!!` },
+    } as express.Request<
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       any,
       object,
       object,
       { filter: string }
     >;
+
     const response = { locals: {} } as express.Response;
 
-    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' } } as express.Request<
+    const request = { query: { filter: 'status=foo%2Cbar%21%21%2C%3Fbaz%3D!%3Equx' } } as express.Request<
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       any,
       object,
@@ -36,7 +55,7 @@ describe('filters middleware', () => {
     >;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractFilters(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       filters: [{ field: 'status', operator: OperatorType.EQUAL, values: ['foo,bar!!,?baz=!>qux'] }],
@@ -47,7 +66,7 @@ describe('filters middleware', () => {
     const request = { query: {} } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractFilters(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       filters: [],

package/test/middlewares/finish.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/finish.js';
+import onFinish from '../../src/middlewares/finish.js';
 
 describe('finish middleware', () => {
   it('logs info', () => {
@@ -24,7 +24,7 @@ describe('finish middleware', () => {
       statusCode: 200,
     } as express.Response;
 
-    middleware(request, response, () => {});
+    onFinish(request, response, () => {});
     eventHandler();
 
     assert.equal(expected, 'works!');
@@ -50,7 +50,7 @@ describe('finish middleware', () => {
       statusCode: 500,
     } as express.Response;
 
-    middleware(request, response, () => {});
+    onFinish(request, response, () => {});
     eventHandler();
 
     assert.equal(expected, 'works!');
@@ -76,7 +76,7 @@ describe('finish middleware', () => {
       statusCode: 200,
     } as express.Response;
 
-    middleware(request, response, () => {});
+    onFinish(request, response, () => {});
     eventHandler();
 
     assert.equal(expected, '');

package/test/middlewares/logger.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/logger.js';
+import injectLogger from '../../src/middlewares/logger.js';
 
 describe('logger middleware', () => {
   it('initializes', () => {
     const request = { header: (_key: string) => undefined } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    injectLogger(request, response, () => {});
 
     assert.deepEqual(response.locals.logger.getMetadata(), {
       correlation_id: undefined,
@@ -19,7 +19,7 @@ describe('logger middleware', () => {
     const request = { header: (_key: string) => undefined } as express.Request;
     const response = { locals: { correlationId: '123' } } as express.Response;
 
-    middleware(request, response, () => {});
+    injectLogger(request, response, () => {});
 
     assert.deepEqual(response.locals.logger.getMetadata(), {
       correlation_id: '123',
@@ -34,7 +34,7 @@ describe('logger middleware', () => {
     const request = { header: (_key: string) => additional } as express.Request;
     const response = { locals: { correlationId: '123' } } as express.Response;
 
-    middleware(request, response, () => {});
+    injectLogger(request, response, () => {});
 
     assert.deepEqual(response.locals.logger.getMetadata(), {
       correlation_id: '123',
@@ -46,7 +46,7 @@ describe('logger middleware', () => {
     const request = { header: (_key: string) => 'nope' } as express.Request;
     const response = { locals: { correlationId: '123' } } as express.Response;
 
-    middleware(request, response, () => {});
+    injectLogger(request, response, () => {});
 
     assert.deepEqual(response.locals.logger.getMetadata(), {
       correlation_id: '123',

package/test/middlewares/notFound.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/notFound.js';
+import notFound from '../../src/middlewares/notFound.js';
 
 describe('notFound middleware', () => {
   it('respond with error without calling next', () => {
@@ -21,7 +21,7 @@ describe('notFound middleware', () => {
       },
       locals: { logger: { error: () => undefined } },
     } as unknown as express.Response;
-    middleware({ path: 'unknownPath' } as express.Request, response, () => {
+    notFound({ path: 'unknownPath' } as express.Request, response, () => {
       throw new Error('next should not be called');
     });
 

package/test/middlewares/secrets.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/secrets.js';
+import extractSecrets from '../../src/middlewares/secrets.js';
 import { BadRequestError } from '../../src/httpErrors.js';
 
 describe('secrets middleware', () => {
@@ -15,7 +15,7 @@ describe('secrets middleware', () => {
     const request = { header: (_key: string) => secrets } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractSecrets(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       secrets: {
@@ -28,7 +28,7 @@ describe('secrets middleware', () => {
     const request = { header: (_key: string) => 'nope' } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    assert.throws(() => middleware(request, response, () => {}), BadRequestError);
+    assert.throws(() => extractSecrets(request, response, () => {}), BadRequestError);
   });
 
   it('undefined', () => {

package/test/middlewares/selects.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/selects.js';
+import extractSelects from '../../src/middlewares/selects.js';
 
 describe('selects middleware', () => {
   it('data', () => {
@@ -14,7 +14,7 @@ describe('selects middleware', () => {
     >;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractSelects(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       selects: ['foo', 'bar.spam', 'baz'],
@@ -25,7 +25,7 @@ describe('selects middleware', () => {
     const request = { query: {} } as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractSelects(request, response, () => {});
 
     assert.deepEqual(response.locals, {
       selects: [],

package/test/middlewares/signal.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/signal.js';
+import extractOperationDeadline from '../../src/middlewares/signal.js';
 
 describe('signal middleware', () => {
   it('uses header', () => {
@@ -10,7 +10,7 @@ describe('signal middleware', () => {
     const request = { header: (_key: string) => deadline } as unknown as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractOperationDeadline(request, response, () => {});
 
     assert.ok(response.locals.signal instanceof AbortSignal);
     assert.equal(response.locals.signal.aborted, false);
@@ -20,7 +20,7 @@ describe('signal middleware', () => {
     const request = { header: (_key: string) => undefined } as unknown as express.Request;
     const response = { locals: {} } as express.Response;
 
-    middleware(request, response, () => {});
+    extractOperationDeadline(request, response, () => {});
 
     assert.ok(response.locals.signal instanceof AbortSignal);
     assert.equal(response.locals.signal.aborted, false);

package/test/middlewares/start.test.ts

@@ -0,0 +1,14 @@
+import express from 'express';
+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 = {} as express.Request;
+    const response = { locals: {} } as express.Response;
+
+    start(request, response, () => {});
+    assert.ok(response.locals.requestStartTime);
+  });
+});

package/test/resources/logger.test.ts

@@ -41,96 +41,131 @@ 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]' });
   });
 });