@unito/integration-sdk 0.1.0 → 0.1.2

package/dist/test/resources/provider.test.js

@@ -0,0 +1,229 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { Provider } from '../../src/resources/provider.js';
+describe('Provider', () => {
+    const provider = new Provider({
+        prepareRequest: requestOptions => {
+            return {
+                url: `www.${requestOptions.credentials.domain ?? 'myApi.com'}`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            };
+        },
+    });
+    it('get', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.get('/endpoint', {
+            credentials: { apiKey: 'apikey#1111' },
+            additionnalheaders: { 'X-Additional-Header': 'value1' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint',
+            {
+                method: 'GET',
+                body: null,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, data: { data: 'value' } });
+    });
+    it('post with url encoded body', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 201,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.post('/endpoint', {
+            data: 'createdItemInfo',
+        }, {
+            credentials: { apiKey: 'apikey#1111' },
+            additionnalheaders: { 'X-Additional-Header': 'value1' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint',
+            {
+                method: 'POST',
+                body: 'data=createdItemInfo',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, data: { data: 'value' } });
+    });
+    it('put with json body', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 201,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        // Removing leading '/' on endpoint to make sure we support both cases
+        const actualResponse = await provider.put('endpoint/123', {
+            data: 'updatedItemInfo',
+        }, {
+            credentials: { apiKey: 'apikey#1111' },
+            additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/json' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint/123',
+            {
+                method: 'PUT',
+                body: JSON.stringify({ data: 'updatedItemInfo' }),
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, data: { data: 'value' } });
+    });
+    it('patch with query params', async (context) => {
+        const response = new Response('{"data": "value"}', {
+            status: 201,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.patch('/endpoint/123', {
+            data: 'updatedItemInfo',
+        }, {
+            credentials: { apiKey: 'apikey#1111' },
+            queryParams: { param1: 'value1', param2: 'value2' },
+            additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/json' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint/123?param1=value1&param2=value2',
+            {
+                method: 'PATCH',
+                body: JSON.stringify({ data: 'updatedItemInfo' }),
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, data: { data: 'value' } });
+    });
+    it('delete', async (context) => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const actualResponse = await provider.delete('/endpoint/123', {
+            credentials: { apiKey: 'apikey#1111' },
+            additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/json' },
+        });
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint/123',
+            {
+                method: 'DELETE',
+                body: null,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 204, headers: response.headers, data: undefined });
+    });
+    it('uses rate limiter if provided', async (context) => {
+        const mockRateLimiter = context.mock.fn((_context, request) => Promise.resolve(request()));
+        const rateLimitedProvider = new Provider({
+            prepareRequest: requestOptions => {
+                return {
+                    url: `www.${requestOptions.credentials.domain ?? 'myApi.com'}`,
+                    headers: {
+                        'X-Custom-Provider-Header': 'value',
+                        'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                    },
+                };
+            },
+            rateLimiter: mockRateLimiter,
+        });
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const options = {
+            credentials: { apiKey: 'apikey#1111' },
+            additionnalheaders: { 'X-Additional-Header': 'value1', 'Content-Type': 'application/json' },
+        };
+        const actualResponse = await rateLimitedProvider.delete('/endpoint/123', options);
+        assert.equal(mockRateLimiter.mock.calls.length, 1);
+        assert.deepEqual(mockRateLimiter.mock.calls[0]?.arguments[0]?.credentials, options.credentials);
+        assert.equal(fetchMock.mock.calls.length, 1);
+        assert.deepEqual(fetchMock.mock.calls[0]?.arguments, [
+            'www.myApi.com/endpoint/123',
+            {
+                method: 'DELETE',
+                body: null,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': 'apikey#1111',
+                    'X-Additional-Header': 'value1',
+                },
+            },
+        ]);
+        assert.deepEqual(actualResponse, { status: 204, headers: response.headers, data: undefined });
+    });
+    it('throws on invalid json response', async (context) => {
+        const response = new Response('{invalidJSON}', {
+            status: 200,
+        });
+        context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        assert.rejects(() => provider.get('/endpoint/123', {
+            credentials: { apiKey: 'apikey#1111' },
+        }));
+    });
+    it('throws on status 400', async (context) => {
+        const response = new Response(undefined, {
+            status: 400,
+        });
+        context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        assert.rejects(() => provider.get('/endpoint/123', {
+            credentials: { apiKey: 'apikey#1111' },
+        }));
+    });
+    it('throws on status 429', async (context) => {
+        const response = new Response(undefined, {
+            status: 429,
+        });
+        context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        assert.rejects(() => provider.get('/endpoint/123', {
+            credentials: { apiKey: 'apikey#1111' },
+        }));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",
@@ -30,13 +30,11 @@
   "devDependencies": {
     "@types/express": "4.x",
     "@types/node": "20.x",
-    "@types/prettier": "2.x",
     "@types/uuid": "9.x",
     "@typescript-eslint/eslint-plugin": "6.x",
     "@typescript-eslint/parser": "6.x",
     "c8": "9.x",
     "eslint": "8.x",
-    "json-schema-to-typescript": "13.x",
     "prettier": "3.x",
     "ts-node": "10.x",
     "typescript": "5.x"

package/src/errors.ts

@@ -9,26 +9,29 @@ export class ConfigurationMalformed extends Error {}
 export class InvalidHandler extends Error {}
 
 /**
- * Processes provider response codes and throw corresponding errors to be translated further in our responses
+ * Processes provider response codes and returns the corresponding errors to be translated further in our responses
  *
  * @param responseStatus the reponseStatus of the request. Any HTTP response code passed here will result in an error!
  * @param message The message returned by the provider
  */
 // Keep in errors.ts instead of httpErrors.ts because we do not need to export it outside of the sdk
-export function handleErrorResponse(responseStatus: number, message: string): void {
+export function buildHttpError(responseStatus: number, message: string): HttpErrors.HttpError {
+  let httpError: HttpErrors.HttpError;
   if (responseStatus === 400) {
-    throw new HttpErrors.BadRequestError(message);
+    httpError = new HttpErrors.BadRequestError(message);
   } else if (responseStatus === 401 || responseStatus === 403) {
-    throw new HttpErrors.UnauthorizedError(message);
+    httpError = new HttpErrors.UnauthorizedError(message);
   } else if (responseStatus === 404) {
-    throw new HttpErrors.NotFoundError(message);
+    httpError = new HttpErrors.NotFoundError(message);
   } else if (responseStatus === 408) {
-    throw new HttpErrors.TimeoutError(message);
+    httpError = new HttpErrors.TimeoutError(message);
   } else if (responseStatus === 422) {
-    throw new HttpErrors.UnprocessableEntityError(message);
+    httpError = new HttpErrors.UnprocessableEntityError(message);
   } else if (responseStatus === 429) {
-    throw new HttpErrors.RateLimitExceededError(message);
+    httpError = new HttpErrors.RateLimitExceededError(message);
   } else {
-    throw new HttpErrors.HttpError(message, responseStatus);
+    httpError = new HttpErrors.HttpError(message, responseStatus);
   }
+
+  return httpError;
 }

package/src/handler.ts

@@ -118,6 +118,22 @@ function assertValidPath(path: string): asserts path is Path {
   }
 }
 
+function assertValidConfiguration(path: Path, pathWithIdentifier: Path, handlers: Handlers) {
+  if (path === pathWithIdentifier) {
+    const individualHandlers = ['getItem', 'updateItem', 'deleteItem'];
+    const collectionHandlers = ['getCollection', 'createItem'];
+
+    const hasIndividualHandlers = individualHandlers.some(handler => handler in handlers);
+    const hasCollectionHandlers = collectionHandlers.some(handler => handler in handlers);
+
+    if (hasIndividualHandlers && hasCollectionHandlers) {
+      throw new InvalidHandler(
+        `The provided path '${path}' doesn't differentiate between individual and collection level operation, so you cannot define both. `,
+      );
+    }
+  }
+}
+
 function parsePath(path: Path) {
   const pathParts = path.split('/');
 
@@ -185,11 +201,12 @@ export class Handler {
   private handlers: Handlers;
 
   constructor(inputPath: string, handlers: HandlersInput) {
-    // Build paths.
     assertValidPath(inputPath);
 
     const { pathWithIdentifier, path } = parsePath(inputPath);
 
+    assertValidConfiguration(path, pathWithIdentifier, handlers);
+
     this.pathWithIdentifier = pathWithIdentifier;
     this.path = path;
 

package/src/httpErrors.ts

@@ -39,6 +39,12 @@ export class UnprocessableEntityError extends HttpError {
 
 export class RateLimitExceededError extends HttpError {
   constructor(message?: string) {
-    super(message || 'Unprocessable Entity', 429);
+    super(message || 'Rate Limit Exceeded', 429);
+  }
+}
+
+export class WouldExceedLimitError extends HttpError {
+  constructor(message?: string) {
+    super(message || 'Would Exceed Limit', 429);
   }
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+/* c8 ignore start */
 export * as Api from '@unito/integration-api';
 export { default as Integration } from './integration.js';
 export * from './handler.js';
@@ -5,6 +6,9 @@ export {
   Provider,
   type Response as ProviderResponse,
   type RequestOptions as ProviderRequestOptions,
+  type RateLimiter,
 } from './resources/provider.js';
+export type { Credentials } from './middlewares/credentials.js';
 export * as HttpErrors from './httpErrors.js';
 export * from './resources/context.js';
+/* c8 ignore stop */

package/src/middlewares/credentials.ts

@@ -10,7 +10,7 @@ declare global {
   }
 }
 
-export type Credentials = Record<string, unknown>;
+export type Credentials = { accessToken?: string; [keys: string]: unknown };
 
 const CREDENTIALS_HEADER = 'X-Unito-Credentials';
 

package/src/resources/provider.ts

@@ -1,38 +1,59 @@
-import { handleErrorResponse as throwHttpError } from '../errors.js';
+import { buildHttpError } from '../errors.js';
 import { Credentials } from '../middlewares/credentials.js';
 
+/**
+ * RateLimiter is a wrapper function that you can provide to limit the rate of calls to the provider based on the
+ * caller's credentials.
+ *
+ * When necessary, the Provider's Response headers can be inspected to update the rate limit before being returned.
+ *
+ * NOTE: make sure to return one of the supported HttpErrors from the SDK, otherwise the error will be translated to a
+ * generic server (500) error.
+ *
+ * @param context - The credentials of the caller.
+ * @param targetFunction - The function to call the provider.
+ * @returns The response from the provider.
+ * @throws RateLimitExceededError when the rate limit is exceeded.
+ * @throws WouldExceedRateLimitError when the next call would exceed the rate limit.
+ * @throws HttpError when the provider returns an error.
+ */
+export type RateLimiter = <T>(
+  context: { credentials: Credentials },
+  targetFunction: () => Promise<Response<T>>,
+) => Promise<Response<T>>;
+
 export interface RequestOptions {
   credentials: Credentials;
   queryParams?: { [key: string]: string };
-  body?: Record<string, unknown>;
   additionnalheaders?: { [key: string]: string };
 }
 
 export interface Response<T> {
-  data: T;
+  data: T | undefined;
+  status: number;
   headers: Headers;
 }
 
 export 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 = undefined;
-
-  constructor(options: { prepareRequest: typeof Provider.prototype.prepareRequest }) {
+  protected rateLimiter: RateLimiter | undefined = undefined;
+  protected prepareRequest: (context: { credentials: Credentials }) => {
+    url: string;
+    headers: Record<string, string>;
+  };
+
+  /**
+   * Initialize a Provider with the given options.
+   *
+   * @property prepareRequest - function to define the Provider's base URL and specific headers to add to the request.
+   * @property rateLimiter - function to limit the rate of calls to the provider based on the caller's credentials.
+   */
+  constructor(options: { prepareRequest: typeof Provider.prototype.prepareRequest; rateLimiter?: RateLimiter }) {
     this.prepareRequest = options.prepareRequest;
+    this.rateLimiter = options.rateLimiter;
   }
 
   public async get<T>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
-    return this.fetchWrapper<T>(endpoint, {
+    return this.fetchWrapper<T>(endpoint, null, {
       ...options,
       method: 'GET',
       defaultHeaders: {
@@ -42,8 +63,8 @@ export class Provider {
     });
   }
 
-  public async post<T>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
-    return this.fetchWrapper<T>(endpoint, {
+  public async post<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>> {
+    return this.fetchWrapper<T>(endpoint, body, {
       ...options,
       method: 'POST',
       defaultHeaders: {
@@ -53,8 +74,23 @@ export class Provider {
     });
   }
 
-  public async patch<T>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
-    return this.fetchWrapper<T>(endpoint, {
+  public async put<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>> {
+    return this.fetchWrapper<T>(endpoint, body, {
+      ...options,
+      method: 'PUT',
+      defaultHeaders: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json',
+      },
+    });
+  }
+
+  public async patch<T>(
+    endpoint: string,
+    body: Record<string, unknown>,
+    options: RequestOptions,
+  ): Promise<Response<T>> {
+    return this.fetchWrapper<T>(endpoint, body, {
       ...options,
       method: 'PATCH',
       defaultHeaders: {
@@ -64,14 +100,22 @@ export class Provider {
     });
   }
 
+  public async delete<T>(endpoint: string, options: RequestOptions): Promise<Response<T>> {
+    return this.fetchWrapper<T>(endpoint, null, {
+      ...options,
+      method: 'DELETE',
+      defaultHeaders: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: 'application/json',
+      },
+    });
+  }
+
   private async fetchWrapper<T>(
     endpoint: string,
+    body: Record<string, unknown> | null,
     options: RequestOptions & { defaultHeaders: { 'Content-Type': string; Accept: string }; method: string },
   ): Promise<Response<T>> {
-    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('/');
@@ -82,39 +126,37 @@ export class Provider {
 
     const headers = { ...options.defaultHeaders, ...providerHeaders, ...options.additionnalheaders };
 
-    let body: string | null = null;
+    let stringifiedBody: string | null = null;
 
-    if (options.body) {
+    if (body) {
       if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
-        body = new URLSearchParams(options.body as Record<string, string>).toString(); // this doesn't support objects!
+        stringifiedBody = new URLSearchParams(body as Record<string, string>).toString();
       } else if (headers['Content-Type'] === 'application/json') {
-        body = JSON.stringify(options.body);
+        stringifiedBody = JSON.stringify(body);
       }
     }
 
-    const callToProvider = async () =>
-      await fetch(absoluteUrl, {
+    const callToProvider = async (): Promise<Response<T>> => {
+      const response = await fetch(absoluteUrl, {
         method: options.method,
         headers,
-        body: body,
+        body: stringifiedBody,
       });
 
-    // TODO: add back rate limiter
-    const response = await callToProvider();
-
-    if (response.status >= 400) {
-      const textResult = await response.text();
-      throwHttpError(response.status, textResult);
-    }
+      if (response.status >= 400) {
+        const textResult = await response.text();
+        throw buildHttpError(response.status, textResult);
+      }
 
-    let data;
+      try {
+        const data: T | undefined = response.body ? await response.json() : undefined;
 
-    try {
-      data = await response.json();
-    } catch {
-      throwHttpError(400, 'Invalid JSON response');
-    }
+        return { status: response.status, headers: response.headers, data };
+      } catch {
+        throw buildHttpError(400, 'Invalid JSON response');
+      }
+    };
 
-    return { headers: response.headers, data };
+    return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
   }
 }

package/test/errors.test.ts

@@ -5,13 +5,12 @@ 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);
+    assert.ok(errors.buildHttpError(401, 'unauthorized') instanceof httpErrors.UnauthorizedError);
+    assert.ok(errors.buildHttpError(403, 'forbidden') instanceof httpErrors.UnauthorizedError);
+    assert.ok(errors.buildHttpError(404, 'not found') instanceof httpErrors.NotFoundError);
+    assert.ok(errors.buildHttpError(408, 'timeout') instanceof httpErrors.TimeoutError);
+    assert.ok(errors.buildHttpError(422, 'unprocessable entity') instanceof httpErrors.UnprocessableEntityError);
+    assert.ok(errors.buildHttpError(429, 'rate limit exceeded') instanceof httpErrors.RateLimitExceededError);
+    assert.ok(errors.buildHttpError(500, 'internal server error') instanceof httpErrors.HttpError);
   });
 });

package/test/handler.test.ts

@@ -1,7 +1,15 @@
 import { Request, Response } from 'express';
 import assert from 'node:assert/strict';
 import { afterEach, beforeEach, describe, it, mock } from 'node:test';
-import { Handler } from '../src/handler.js';
+import {
+  Handler,
+  HandlersInput,
+  GetItemHandler,
+  GetCollectionHandler,
+  UpdateItemHandler,
+  DeleteItemHandler,
+  CreateItemHandler,
+} from '../src/handler.js';
 import { BadRequestError } from '../src/httpErrors.js';
 
 describe('Handler', () => {
@@ -18,7 +26,7 @@ describe('Handler', () => {
     it('returns a Handler', () => {
       const itemHandler = new Handler('/', {});
 
-      assert.equal(itemHandler instanceof Handler, true);
+      assert.ok(itemHandler instanceof Handler);
     });
 
     it('validates path', () => {
@@ -42,6 +50,32 @@ describe('Handler', () => {
         }
       }
     });
+
+    it('validates configuration', () => {
+      const getItem = (() => {}) as unknown as GetItemHandler;
+      const updateItem = (() => {}) as unknown as UpdateItemHandler;
+      const deleteItem = (() => {}) as unknown as DeleteItemHandler;
+      const getCollection = (() => {}) as unknown as GetCollectionHandler;
+      const createItem = (() => {}) as unknown as CreateItemHandler;
+
+      const paths: [string, HandlersInput, boolean][] = [
+        ['/foo', { getItem }, true],
+        ['/foo', { getCollection }, true],
+        ['/foo', { getItem, getCollection }, false],
+        ['/foo', { updateItem, createItem }, false],
+        ['/foo', { deleteItem, createItem }, false],
+        ['/foo/:bar', { getItem, getCollection }, true],
+        ['/foo/:bar', { getItem, updateItem, deleteItem, createItem, getCollection }, true],
+      ];
+
+      for (const [path, handlers, valid] of paths) {
+        if (valid) {
+          assert.doesNotThrow(() => new Handler(path, handlers));
+        } else {
+          assert.throws(() => new Handler(path, handlers));
+        }
+      }
+    });
   });
 
   describe('generate', () => {