@unito/integration-sdk 0.1.0

package/dist/src/resources/cache.js

@@ -0,0 +1,25 @@
+import { WriteThroughCache, LocalCache } from 'cachette';
+import { createHash } from 'node:crypto';
+import * as uuid from 'uuid';
+import Logger from './logger.js';
+export function initializeCache() {
+    const cacheInstance = process.env.REDIS_URL ? new WriteThroughCache(process.env.REDIS_URL) : new LocalCache();
+    // Intended: the correlation id will be the same for all logs of Cachette.
+    const correlationId = uuid.v4();
+    const logger = new Logger({ correlation_id: correlationId });
+    cacheInstance
+        .on('info', message => {
+        logger.info(message);
+    })
+        .on('warn', message => {
+        logger.warn(message);
+    })
+        .on('error', message => {
+        logger.error(message);
+    });
+    return cacheInstance;
+}
+const shake256 = createHash('shake256');
+export function generateCacheKey(value) {
+    return shake256.update(value).digest('hex');
+}

package/dist/src/resources/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/resources/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAiB,MAAM,UAAU,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAC3B,OAAO,MAAM,MAAM,aAAa,CAAC;AAEjC,MAAM,CAAC,IAAI,QAAuB,CAAC;AAInC,MAAM,UAAU,eAAe;IAC7B,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QAC1B,QAAQ,GAAG,IAAI,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC1D,CAAC;SAAM,CAAC;QACN,QAAQ,GAAG,IAAI,UAAU,EAAE,CAAC;IAC9B,CAAC;IAED,0EAA0E;IAC1E,MAAM,aAAa,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC;IAEhC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC,CAAC;IAE7D,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;QAC5B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;QAC5B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;QAC7B,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,KAAkB,EAAE,YAA+B,OAAO;IACzF,IAAI,QAAgB,CAAC;IAErB,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,UAAU;YACb,QAAQ,GAAG,GAAG,UAAU,CAAC,UAAU,CAAC;iBACjC,MAAM,CAAC,KAAe,CAAC;iBACvB,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACnB,MAAM;QACR,KAAK,MAAM;YACT,QAAQ,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACxC,MAAM;QACR,KAAK,OAAO;YACV,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACzC,MAAM;QACR,KAAK,OAAO;YACV,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YACzC,MAAM;QACR,KAAK,OAAO,CAAC;QACb;YACE,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/src/resources/context.d.ts

@@ -0,0 +1,78 @@
+import * as API from '@unito/integration-api';
+import Logger from './logger.js';
+import { Credentials } from '../middlewares/credentials.js';
+import { Filter } from '../middlewares/filters.js';
+type Context<P extends Record<string, string>, Q extends ParsedQueryString> = {
+    /**
+     * The parsed credentials associated with the request through the X-Unito-Credentials header.
+     *
+     * Will contain the keys for the variables defined in the corresponding configuration's authorization.
+     */
+    credentials: Credentials;
+    /**
+     * The logger pre decorated with the correlation ID and the additionnal metadata provided through the request headers.
+     */
+    logger: Logger;
+    /**
+     * The request params.
+     *
+     * A call to `/customers/:customerId/subscriptions/:subscriptionId` => `/customers/123/subscriptions/2` will yield:
+     *
+     * {
+     *  customerId: '123',
+     *  subscriptionId: '2'
+     * }
+     */
+    params: P;
+    /**
+     * The raw query string parsed as an object.
+     */
+    query: Q;
+};
+export type GetItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q>;
+export type GetCollectionContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q> & {
+    /**
+     * Parsed filter query param yielding a list of filters.
+     *
+     *  Given a filter query param:
+     *  `filter=name=John,department.name=Engineering`
+     *
+     *  Context.filters will be:
+     *  [
+     *    { field: 'name', operator: 'EQUAL', values: ['John'] },
+     *    { field: 'department.name', operator: 'EQUAL', values: ['Engineering'] }
+     *  ]
+     */
+    filters: Filter[];
+    /**
+     * Parsed select query param yielding a list of fields to select.
+     *
+     *  Given a select query param:
+     *  `select=name,department.name`
+     *
+     *  Context.selects will be:
+     *  ['name', 'department.name']
+     */
+    selects: string[];
+};
+export type CreateItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.CreateItemRequestPayload = API.CreateItemRequestPayload> = Context<P, Q> & {
+    body: B;
+};
+export type UpdateItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.UpdateItemRequestPayload = API.UpdateItemRequestPayload> = Context<P, Q> & {
+    body: B;
+};
+export type DeleteItemContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q>;
+export type GetCredentialAccountContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>> = Context<P, Q>;
+export type ParseWebhooksContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
+    body: B;
+};
+export type UpdateWebhookSubscriptionsContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookSubscriptionRequestPayload = API.WebhookSubscriptionRequestPayload> = Context<P, Q> & {
+    body: B;
+};
+export type AckknowledgeWebhooksContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
+    body: B;
+};
+interface ParsedQueryString {
+    [key: string]: undefined | string | string[] | ParsedQueryString | ParsedQueryString[];
+}
+export {};

package/dist/src/resources/context.js

@@ -0,0 +1,2 @@
+export {};
+/* c8 ignore stop */

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

@@ -0,0 +1,14 @@
+export default class Logger {
+    private metadata;
+    constructor(metadata?: Record<string, unknown>);
+    private send;
+    log(data: unknown): void;
+    error(data: unknown): void;
+    warn(data: unknown): void;
+    info(data: unknown): void;
+    debug(data: unknown): void;
+    decorate(metadata: Record<string, unknown>): void;
+    getMetadata(): Record<string, unknown>;
+    setMetadata(key: string, value: unknown): void;
+    clearMetadata(): void;
+}

package/dist/src/resources/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/resources/logger.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,OAAO,CAAC,QAAQ,CAA+B;gBAEnC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAM9C,OAAO,CAAC,IAAI;IAKL,GAAG,CAAC,IAAI,EAAE,OAAO;IAIjB,KAAK,CAAC,IAAI,EAAE,OAAO;IAInB,IAAI,CAAC,IAAI,EAAE,OAAO;IAIlB,IAAI,CAAC,IAAI,EAAE,OAAO;IAIlB,KAAK,CAAC,IAAI,EAAE,OAAO;IAInB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAI1C,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAInC,SAAS;CAGjB"}

package/dist/src/resources/logger.js

@@ -0,0 +1,46 @@
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["LOG"] = "log";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (LogLevel = {}));
+export default class Logger {
+    metadata = {};
+    constructor(metadata) {
+        if (metadata) {
+            this.metadata = structuredClone(metadata);
+        }
+    }
+    send(logLevel, message) {
+        console[logLevel](JSON.stringify({ message, ...this.metadata }));
+    }
+    log(data) {
+        this.send(LogLevel.LOG, data);
+    }
+    error(data) {
+        this.send(LogLevel.ERROR, data);
+    }
+    warn(data) {
+        this.send(LogLevel.WARN, data);
+    }
+    info(data) {
+        this.send(LogLevel.INFO, data);
+    }
+    debug(data) {
+        this.send(LogLevel.DEBUG, data);
+    }
+    decorate(metadata) {
+        this.metadata = { ...this.metadata, ...metadata };
+    }
+    getMetadata() {
+        return structuredClone(this.metadata);
+    }
+    setMetadata(key, value) {
+        this.metadata[key] = value;
+    }
+    clearMetadata() {
+        this.metadata = {};
+    }
+}

package/dist/src/resources/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../src/resources/logger.ts"],"names":[],"mappings":"AAAA,IAAK,QAMJ;AAND,WAAK,QAAQ;IACX,2BAAe,CAAA;IACf,yBAAa,CAAA;IACb,yBAAa,CAAA;IACb,uBAAW,CAAA;IACX,2BAAe,CAAA;AACjB,CAAC,EANI,QAAQ,KAAR,QAAQ,QAMZ;AAED,MAAM,CAAC,OAAO,OAAO,MAAM;IACjB,QAAQ,GAA4B,EAAE,CAAC;IAE/C,YAAY,QAAkC;QAC5C,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;IAEO,IAAI,CAAC,QAAkB,EAAE,OAAgB;QAC/C,sCAAsC;QACtC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACnE,CAAC;IAEM,GAAG,CAAC,IAAa;QACtB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IAEM,KAAK,CAAC,IAAa;QACxB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAClC,CAAC;IAEM,IAAI,CAAC,IAAa;QACvB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAEM,IAAI,CAAC,IAAa;QACvB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,IAAa;QACxB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAClC,CAAC;IAEM,QAAQ,CAAC,QAAiC;QAC/C,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAAC;IACpD,CAAC;IAEM,OAAO,CAAC,GAAW,EAAE,KAAc;QACxC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC7B,CAAC;IAEM,SAAS;QACd,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;CACF"}

package/dist/src/resources/provider.d.ts

@@ -0,0 +1,36 @@
+import { Credentials } from '../middlewares/credentials.js';
+export interface RequestOptions {
+    credentials: Credentials;
+    queryParams?: {
+        [key: string]: string;
+    };
+    body?: Record<string, unknown>;
+    additionnalheaders?: {
+        [key: string]: string;
+    };
+}
+export interface Response<T> {
+    data: T;
+    headers: Headers;
+}
+export declare class Provider {
+    protected prepareRequest: ((context: {
+        credentials: Credentials;
+    }) => {
+        /**
+         * The base URL of the provider.
+         */
+        url: string;
+        /**
+         * The additional headers to add to the request.
+         */
+        headers: Record<string, string>;
+    }) | undefined;
+    constructor(options: {
+        prepareRequest: typeof Provider.prototype.prepareRequest;
+    });
+    get<T>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
+    post<T>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
+    patch<T>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
+    private fetchWrapper;
+}

package/dist/src/resources/provider.js

@@ -0,0 +1,76 @@
+import { handleErrorResponse as throwHttpError } from '../errors.js';
+export class Provider {
+    prepareRequest = undefined;
+    constructor(options) {
+        this.prepareRequest = options.prepareRequest;
+    }
+    async get(endpoint, options) {
+        return this.fetchWrapper(endpoint, {
+            ...options,
+            method: 'GET',
+            defaultHeaders: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async post(endpoint, options) {
+        return this.fetchWrapper(endpoint, {
+            ...options,
+            method: 'POST',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async patch(endpoint, options) {
+        return this.fetchWrapper(endpoint, {
+            ...options,
+            method: 'PATCH',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async fetchWrapper(endpoint, options) {
+        if (!this.prepareRequest) {
+            throw new Error('Provider not initialized');
+        }
+        const { url: providerUrl, headers: providerHeaders } = this.prepareRequest({ credentials: options.credentials });
+        let absoluteUrl = [providerUrl, endpoint.charAt(0) === '/' ? endpoint.substring(1) : endpoint].join('/');
+        if (options.queryParams) {
+            absoluteUrl = `${absoluteUrl}?${new URLSearchParams(options.queryParams)}`;
+        }
+        const headers = { ...options.defaultHeaders, ...providerHeaders, ...options.additionnalheaders };
+        let body = null;
+        if (options.body) {
+            if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
+                body = new URLSearchParams(options.body).toString(); // this doesn't support objects!
+            }
+            else if (headers['Content-Type'] === 'application/json') {
+                body = JSON.stringify(options.body);
+            }
+        }
+        const callToProvider = async () => await fetch(absoluteUrl, {
+            method: options.method,
+            headers,
+            body: body,
+        });
+        // TODO: add back rate limiter
+        const response = await callToProvider();
+        if (response.status >= 400) {
+            const textResult = await response.text();
+            throwHttpError(response.status, textResult);
+        }
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            throwHttpError(400, 'Invalid JSON response');
+        }
+        return { headers: response.headers, data };
+    }
+}

package/dist/test/errors.test.d.ts

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

package/dist/test/errors.test.js

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import * as errors from '../src/errors.js';
+import * as httpErrors from '../src/httpErrors.js';
+describe('handleErrorResponse', () => {
+    it('returns correct httpError given status code', () => {
+        assert.throws(() => errors.handleErrorResponse(400, 'bad request'), httpErrors.BadRequestError);
+        assert.throws(() => errors.handleErrorResponse(401, 'unauthorized'), httpErrors.UnauthorizedError);
+        assert.throws(() => errors.handleErrorResponse(403, 'forbidden'), httpErrors.UnauthorizedError);
+        assert.throws(() => errors.handleErrorResponse(404, 'not found'), httpErrors.NotFoundError);
+        assert.throws(() => errors.handleErrorResponse(408, 'timeout'), httpErrors.TimeoutError);
+        assert.throws(() => errors.handleErrorResponse(422, 'unprocessable entity'), httpErrors.UnprocessableEntityError);
+        assert.throws(() => errors.handleErrorResponse(429, 'rate limit exceeded'), httpErrors.RateLimitExceededError);
+        assert.throws(() => errors.handleErrorResponse(500, 'internal server error'), httpErrors.HttpError);
+    });
+});

package/dist/test/handler.test.d.ts

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

package/dist/test/handler.test.js

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import { afterEach, beforeEach, describe, it, mock } from 'node:test';
+import { Handler } from '../src/handler.js';
+import { BadRequestError } from '../src/httpErrors.js';
+describe('Handler', () => {
+    beforeEach(() => {
+        // Disable debug logging to keep the test output clean.
+        mock.method(global.console, 'debug', () => { });
+    });
+    afterEach(() => {
+        mock.reset();
+    });
+    describe('constructor', () => {
+        it('returns a Handler', () => {
+            const itemHandler = new Handler('/', {});
+            assert.equal(itemHandler instanceof Handler, true);
+        });
+        it('validates path', () => {
+            const paths = [
+                ['', false],
+                ['invalid', false],
+                ['/', true],
+                ['/bar', true],
+                ['/bar/', false],
+                ['/foo/:bar', true],
+                ['/foo/:bar/', false],
+                ['/foo/:bar/spam/:baz', true],
+                ['/foo/:bar/:spam', true],
+            ];
+            for (const [path, valid] of paths) {
+                if (valid) {
+                    assert.doesNotThrow(() => new Handler(path, {}));
+                }
+                else {
+                    assert.throws(() => new Handler(path, {}));
+                }
+            }
+        });
+    });
+    describe('generate', () => {
+        async function executeHandler(handler, request = {}) {
+            let body = {};
+            let statusCode = 0;
+            const response = {
+                status: (receivedStatusCode) => ({
+                    send: (receivedBody) => {
+                        body = receivedBody;
+                        statusCode = receivedStatusCode;
+                    },
+                }),
+                statusCode: 0,
+                locals: {
+                    credentials: { foo: 'bar' },
+                },
+            };
+            await handler(request, response);
+            return { body, statusCode };
+        }
+        it('returns a router', async () => {
+            const handler = new Handler('/foo/:bar', {
+                getCollection: () => Promise.resolve({ info: {}, data: [] }),
+                getItem: () => Promise.resolve({ fields: {}, relations: [] }),
+                createItem: () => Promise.resolve({ fields: {}, path: '/' }),
+                updateItem: () => Promise.resolve({ fields: {}, relations: [] }),
+                deleteItem: () => Promise.resolve(),
+            });
+            const router = handler.generate();
+            const routes = router.stack;
+            assert.equal(routes.length, 5);
+            assert.equal(routes[0].route.path, '/foo');
+            assert.equal(routes[0].route.methods.get, true);
+            assert.equal(routes[1].route.path, '/foo');
+            assert.equal(routes[1].route.methods.post, true);
+            assert.equal(routes[2].route.path, '/foo/:bar');
+            assert.equal(routes[2].route.methods.get, true);
+            assert.equal(routes[3].route.path, '/foo/:bar');
+            assert.equal(routes[3].route.methods.patch, true);
+            assert.equal(routes[4].route.path, '/foo/:bar');
+            assert.equal(routes[4].route.methods.delete, true);
+            // GetCollection.
+            assert.deepEqual(await executeHandler(routes[0].route.stack[0].handle), {
+                body: { info: {}, data: [] },
+                statusCode: 200,
+            });
+            // CreateItem.
+            assert.deepEqual(await executeHandler(routes[1].route.stack[0].handle, { body: { foo: 'bar' } }), {
+                body: { fields: {}, path: '/' },
+                statusCode: 201,
+            });
+            // GetItem.
+            assert.deepEqual(await executeHandler(routes[2].route.stack[0].handle), {
+                body: { fields: {}, relations: [] },
+                statusCode: 200,
+            });
+            // UpdateItem.
+            assert.deepEqual(await executeHandler(routes[3].route.stack[0].handle, { body: { foo: 'bar' } }), {
+                body: { fields: {}, relations: [] },
+                statusCode: 200,
+            });
+            // DeleteItem.
+            assert.deepEqual(await executeHandler(routes[4].route.stack[0].handle), {
+                body: null,
+                statusCode: 204,
+            });
+        });
+        it('uses pathWithIdentifier as is when appropriate', async () => {
+            const handler = new Handler('/foo/:bar/baz', {
+                getCollection: () => Promise.resolve({ info: {}, data: [] }),
+            });
+            const router = handler.generate();
+            const routes = router.stack;
+            assert.equal(routes.length, 1);
+            assert.equal(routes[0].route.path, '/foo/:bar/baz');
+            assert.equal(routes[0].route.methods.get, true);
+            // GetCollection.
+            assert.deepEqual(await executeHandler(routes[0].route.stack[0].handle), {
+                body: { info: {}, data: [] },
+                statusCode: 200,
+            });
+        });
+        it('undefined handlers', async () => {
+            const handler = new Handler('/foo/:bar', {});
+            const router = handler.generate();
+            const routes = router.stack;
+            assert.equal(routes.length, 0);
+        });
+        it('returns a 400 for invalid request payloads', async () => {
+            const handler = new Handler('/foo/:bar', {
+                createItem: () => Promise.resolve({ fields: {}, path: '/' }),
+                updateItem: () => Promise.resolve({ fields: {}, relations: [] }),
+            });
+            const router = handler.generate();
+            const routes = router.stack;
+            // CreateItemRequestPayload.
+            const createHandler = routes[0].route.stack[0].handle;
+            await assert.doesNotReject(async () => await executeHandler(createHandler, { body: { foo: 'bar' } }));
+            await assert.rejects(async () => await executeHandler(createHandler, { body: null }), BadRequestError);
+            await assert.rejects(async () => await executeHandler(createHandler, { body: 'not json' }), BadRequestError);
+            // UpdateItemRequestPayload.
+            const updateHandler = routes[0].route.stack[0].handle;
+            await assert.doesNotReject(async () => await executeHandler(updateHandler, { body: { foo: 'bar' } }));
+            await assert.rejects(async () => await executeHandler(updateHandler, { body: null }), BadRequestError);
+            await assert.rejects(async () => await executeHandler(updateHandler, { body: 'not json' }), BadRequestError);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,19 @@
+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) => '123' };
+        const response = { locals: {} };
+        middleware(request, response, () => { });
+        assert.deepEqual(response.locals, {
+            correlationId: '123',
+        });
+    });
+    it('fallback', () => {
+        const request = { header: (_key) => undefined };
+        const response = { locals: {} };
+        middleware(request, response, () => { });
+        assert(response.locals.correlationId);
+    });
+});

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

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

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

@@ -0,0 +1,37 @@
+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) => credentials };
+        const response = { locals: {} };
+        middleware(request, response, () => { });
+        assert.deepEqual(response.locals, {
+            credentials: {
+                accessToken: 'abc',
+            },
+        });
+    });
+    it('malformed header', async () => {
+        const request = { header: (_key) => 'nope' };
+        const response = { locals: {} };
+        assert.throws(() => middleware(request, response, () => { }), BadRequestError);
+    });
+    it('variables', async () => {
+        const credentials = Buffer.from(JSON.stringify({
+            apiKey: 'abc',
+        })).toString('base64');
+        const request = { header: (_key) => credentials };
+        const response = { locals: {} };
+        middleware(request, response, () => { });
+        assert.deepEqual(response.locals, {
+            credentials: {
+                apiKey: 'abc',
+            },
+        });
+    });
+});

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

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

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

@@ -0,0 +1,64 @@
+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;
+        let actualJson;
+        const response = {
+            headersSent: true,
+            status: (code) => {
+                actualStatus = code;
+                return {
+                    json: (json) => {
+                        actualJson = json;
+                    },
+                };
+            },
+            locals: { logger: { error: () => undefined } },
+        };
+        middleware(new Error(), {}, response, () => { });
+        assert.strictEqual(actualStatus, undefined);
+        assert.strictEqual(actualJson, undefined);
+    });
+    it('handles httpError', () => {
+        let actualStatus;
+        let actualJson;
+        const response = {
+            headersSent: false,
+            status: (code) => {
+                actualStatus = code;
+                return {
+                    json: (json) => {
+                        actualJson = json;
+                    },
+                };
+            },
+            locals: { logger: { error: () => undefined } },
+        };
+        middleware(new HttpError('httpError', 429), {}, response, () => { });
+        assert.strictEqual(actualStatus, 429);
+        assert.strictEqual(actualJson, 'httpError');
+    });
+    it('handles other error', () => {
+        let actualStatus;
+        let actualJson;
+        const response = {
+            headersSent: false,
+            status: (code) => {
+                actualStatus = code;
+                return {
+                    json: (json) => {
+                        actualJson = json;
+                    },
+                };
+            },
+            locals: { logger: { error: () => undefined } },
+        };
+        middleware(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.d.ts

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

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

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

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

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