@unito/integration-sdk 0.1.0

package/test/middlewares/correlationId.test.ts

@@ -0,0 +1,26 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import middleware 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, () => {});
+
+    assert.deepEqual(response.locals, {
+      correlationId: '123',
+    });
+  });
+
+  it('fallback', () => {
+    const request = { header: (_key: string) => undefined } as express.Request;
+    const response = { locals: {} } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert(response.locals.correlationId);
+  });
+});

package/test/middlewares/credentials.test.ts

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

package/test/middlewares/errors.test.ts

@@ -0,0 +1,78 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import middleware from '../../src/middlewares/errors.js';
+import { HttpError } from '../../src/httpErrors.js';
+
+describe('errors middleware', () => {
+  it('headers sent, do nothing', () => {
+    let actualStatus: number | undefined;
+    let actualJson: Record<string, unknown> | undefined;
+
+    const response = {
+      headersSent: true,
+      status: (code: number) => {
+        actualStatus = code;
+
+        return {
+          json: (json: Record<string, unknown>) => {
+            actualJson = json;
+          },
+        };
+      },
+      locals: { logger: { error: () => undefined } },
+    } as unknown as express.Response;
+
+    middleware(new Error(), {} as express.Request, response, () => {});
+
+    assert.strictEqual(actualStatus, undefined);
+    assert.strictEqual(actualJson, undefined);
+  });
+
+  it('handles httpError', () => {
+    let actualStatus: number | undefined;
+    let actualJson: Record<string, unknown> | undefined;
+
+    const response = {
+      headersSent: false,
+      status: (code: number) => {
+        actualStatus = code;
+
+        return {
+          json: (json: Record<string, unknown>) => {
+            actualJson = json;
+          },
+        };
+      },
+      locals: { logger: { error: () => undefined } },
+    } as unknown as express.Response;
+    middleware(new HttpError('httpError', 429), {} as express.Request, response, () => {});
+
+    assert.strictEqual(actualStatus, 429);
+    assert.strictEqual(actualJson, 'httpError');
+  });
+
+  it('handles other error', () => {
+    let actualStatus: number | undefined;
+    let actualJson: Record<string, unknown> | undefined;
+
+    const response = {
+      headersSent: false,
+      status: (code: number) => {
+        actualStatus = code;
+
+        return {
+          json: (json: Record<string, unknown>) => {
+            actualJson = json;
+          },
+        };
+      },
+      locals: { logger: { error: () => undefined } },
+    } as unknown as express.Response;
+    middleware(new Error('error'), {} as express.Request, response, () => {});
+
+    assert.strictEqual(actualStatus, 500);
+    assert.strictEqual(actualJson?.code, '500');
+    assert.deepEqual(actualJson?.originalError, { code: 'Error', message: 'error' });
+  });
+});

package/test/middlewares/filters.test.ts

@@ -0,0 +1,39 @@
+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';
+
+describe('filters middleware', () => {
+  it('data', () => {
+    const request = { query: { filter: 'status=active|pending,createdAt>2022-01-01,email!!' } } 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, () => {});
+
+    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: [] },
+      ],
+    });
+  });
+
+  it('no data', () => {
+    const request = { query: {} } as express.Request;
+    const response = { locals: {} } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert.deepEqual(response.locals, {
+      filters: [],
+    });
+  });
+});

package/test/middlewares/finish.test.ts

@@ -0,0 +1,81 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import middleware from '../../src/middlewares/finish.js';
+
+describe('finish middleware', () => {
+  it('logs info', () => {
+    let expected = '';
+    let eventHandler: () => void = () => {};
+
+    const request = { originalUrl: '/' } as express.Request;
+    const response = {
+      on: (_event, func: () => void) => {
+        eventHandler = func;
+      },
+      locals: {
+        logger: {
+          info: (_message: string) => {
+            expected = 'works!';
+          },
+        },
+      },
+      statusCode: 200,
+    } as express.Response;
+
+    middleware(request, response, () => {});
+    eventHandler();
+
+    assert.equal(expected, 'works!');
+  });
+
+  it('logs error', () => {
+    let expected = '';
+    let eventHandler: () => void = () => {};
+
+    const request = { originalUrl: '/' } as express.Request;
+    const response = {
+      on: (_event, func: () => void) => {
+        eventHandler = func;
+      },
+      locals: {
+        logger: {
+          error: (_message: string) => {
+            expected = 'works!';
+          },
+        },
+      },
+      statusCode: 500,
+    } as express.Response;
+
+    middleware(request, response, () => {});
+    eventHandler();
+
+    assert.equal(expected, 'works!');
+  });
+
+  it('health', () => {
+    let expected = '';
+    let eventHandler: () => void = () => {};
+
+    const request = { originalUrl: '/health' } as express.Request;
+    const response = {
+      on: (_event, func: () => void) => {
+        eventHandler = func;
+      },
+      locals: {
+        logger: {
+          info: (_message: string) => {
+            expected = 'ohoh!';
+          },
+        },
+      },
+      statusCode: 200,
+    } as express.Response;
+
+    middleware(request, response, () => {});
+    eventHandler();
+
+    assert.equal(expected, '');
+  });
+});

package/test/middlewares/logger.test.ts

@@ -0,0 +1,57 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import middleware 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, () => {});
+
+    assert.deepEqual(response.locals.logger.getMetadata(), {
+      correlation_id: undefined,
+    });
+  });
+
+  it('correlation id', () => {
+    const request = { header: (_key: string) => undefined } as express.Request;
+    const response = { locals: { correlationId: '123' } } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert.deepEqual(response.locals.logger.getMetadata(), {
+      correlation_id: '123',
+    });
+  });
+
+  it('additional context', () => {
+    const additional = Buffer.from(
+      JSON.stringify({
+        foo: 'bar',
+      }),
+    ).toString('base64');
+
+    const request = { header: (_key: string) => additional } as express.Request;
+    const response = { locals: { correlationId: '123' } } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert.deepEqual(response.locals.logger.getMetadata(), {
+      correlation_id: '123',
+      foo: 'bar',
+    });
+  });
+
+  it('malformed additional context', () => {
+    const request = { header: (_key: string) => 'nope' } as express.Request;
+    const response = { locals: { correlationId: '123' } } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert.deepEqual(response.locals.logger.getMetadata(), {
+      correlation_id: '123',
+    });
+  });
+});

package/test/middlewares/notFound.test.ts

@@ -0,0 +1,32 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import middleware from '../../src/middlewares/notFound.js';
+
+describe('notFound middleware', () => {
+  it('respond with error without calling next', () => {
+    let actualStatus: number | undefined;
+    let actualJson: Record<string, unknown> | undefined;
+
+    const response = {
+      headersSent: false,
+      status: (code: number) => {
+        actualStatus = code;
+
+        return {
+          json: (json: Record<string, unknown>) => {
+            actualJson = json;
+          },
+        };
+      },
+      locals: { logger: { error: () => undefined } },
+    } as unknown as express.Response;
+    middleware({ path: 'unknownPath' } as express.Request, response, () => {
+      throw new Error('next should not be called');
+    });
+
+    assert.strictEqual(actualStatus, 404);
+    assert.strictEqual(actualJson?.code, '404');
+    assert.deepEqual(actualJson?.message, 'Path unknownPath not found.');
+  });
+});

package/test/middlewares/selects.test.ts

@@ -0,0 +1,34 @@
+import express from 'express';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import middleware from '../../src/middlewares/selects.js';
+
+describe('selects middleware', () => {
+  it('data', () => {
+    const request = { query: { select: 'foo,bar.spam,baz' } } as express.Request<
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      any,
+      object,
+      object,
+      { select: string }
+    >;
+    const response = { locals: {} } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert.deepEqual(response.locals, {
+      selects: ['foo', 'bar.spam', 'baz'],
+    });
+  });
+
+  it('no data', () => {
+    const request = { query: {} } as express.Request;
+    const response = { locals: {} } as express.Response;
+
+    middleware(request, response, () => {});
+
+    assert.deepEqual(response.locals, {
+      selects: [],
+    });
+  });
+});

package/test/resources/cache.test.ts

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { LocalCache } from 'cachette';
+import { generateCacheKey, initializeCache } from '../../src/resources/cache.js';
+
+describe('Cache', () => {
+  describe('initializeCache', () => {
+    it('no redis url returns LocalCache', () => {
+      const cache = initializeCache();
+
+      assert.equal(cache instanceof LocalCache, true);
+
+      cache.quit();
+    });
+
+    it('redis url returns (tries) WriteThroughCache', () => {
+      process.env.REDIS_URL = 'fakeredis'; //'redis://localhost:6379';
+      assert.throws(() => initializeCache(), Error, 'Invalid redis url fakereis.');
+    });
+  });
+
+  describe('generateCacheKey', () => {
+    it('hashes string and returns hex value', () => {
+      const value = 'test';
+      const hash = generateCacheKey(value);
+
+      assert.equal(typeof hash, 'string');
+      assert.equal(hash.length, 64);
+    });
+  });
+});

package/test/resources/logger.test.ts

@@ -0,0 +1,80 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import Logger from '../../src/resources/logger.js';
+
+describe('Logger', () => {
+  it('metadata', () => {
+    let metadata: Record<string, unknown> = { correlation_id: 'test' };
+    const logger = new Logger(metadata);
+
+    // Changing initial object should not affect the logger
+    metadata.correlation_id = 'changed';
+    assert.deepEqual(logger.getMetadata(), { correlation_id: 'test' });
+
+    // Changing returned metadata object should not affect the logger
+    metadata = logger.getMetadata();
+    metadata.correlation_id = 'changed';
+    assert.deepEqual(logger.getMetadata(), { correlation_id: 'test' });
+
+    // Can overwrite existing metadata
+    logger.setMetadata('correlation_id', 'changed');
+    assert.deepEqual(logger.getMetadata(), { correlation_id: 'changed' });
+
+    // Can merge metadata
+    logger.decorate({ other: 'metadata' });
+    assert.deepEqual(logger.getMetadata(), { correlation_id: 'changed', other: 'metadata' });
+
+    // Can overwrite existing metadata
+    logger.decorate({ other: 'overwrite' });
+    assert.deepEqual(logger.getMetadata(), { correlation_id: 'changed', other: 'overwrite' });
+
+    // Can clear metadata
+    logger.clearMetadata();
+    assert.deepEqual(logger.getMetadata(), {});
+  });
+
+  it('respect logging levels', testContext => {
+    const metadata = { correlation_id: '123456789' };
+    const logger = new Logger(metadata);
+
+    const logSpy = testContext.mock.method(global.console, 'log', () => {});
+    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({ message: 'test', correlation_id: '123456789' }),
+    ]);
+
+    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({ message: 'test', correlation_id: '123456789' }),
+    ]);
+
+    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({ message: 'test', correlation_id: '123456789' }),
+    ]);
+
+    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({ message: 'test', correlation_id: '123456789' }),
+    ]);
+
+    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({ message: 'test', correlation_id: '123456789' }),
+    ]);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "esnext",
+    "moduleResolution": "NodeNext",
+    "allowJs": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "baseUrl": "./",
+    "checkJs": true,
+    "declaration": true,
+    "exactOptionalPropertyTypes": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "./dist",
+    "skipLibCheck": true,
+    "strict": true
+  },
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules"]
+}