@unito/integration-sdk 0.1.0 → 0.1.1

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

@@ -18,7 +18,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', () => {

package/test/resources/provider.test.ts

@@ -0,0 +1,285 @@
+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 as string,
+        },
+      };
+    },
+  });
+
+  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 as string,
+          },
+        };
+      },
+      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/dist/src/api/index.d.ts

@@ -1,2 +0,0 @@
-export * from '@unito/integration-api';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/src/api/index.js

@@ -1,2 +0,0 @@
-export * from '@unito/integration-api';
-//# sourceMappingURL=index.js.map

package/dist/src/api/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/src/app/errors/HTTPError.d.ts

@@ -1,5 +0,0 @@
-export declare class HTTPError extends Error {
-    readonly status: number;
-    constructor(message: string, status: number);
-}
-//# sourceMappingURL=HTTPError.d.ts.map

package/dist/src/app/errors/HTTPError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HTTPError.d.ts","sourceRoot":"","sources":["../../../../src/app/errors/HTTPError.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAO;gBAElB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI5C"}

package/dist/src/app/errors/HTTPError.js

@@ -1,8 +0,0 @@
-export class HTTPError extends Error {
-    status = 500;
-    constructor(message, status) {
-        super(message);
-        this.status = status;
-    }
-}
-//# sourceMappingURL=HTTPError.js.map

package/dist/src/app/errors/HTTPError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HTTPError.js","sourceRoot":"","sources":["../../../../src/app/errors/HTTPError.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,SAAU,SAAQ,KAAK;IACzB,MAAM,GAAW,GAAG,CAAC;IAE9B,YAAY,OAAe,EAAE,MAAc;QACzC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF"}

package/dist/src/app/errors/HTTPNotFoundError.d.ts

@@ -1,5 +0,0 @@
-import { HTTPError } from './HTTPError.js';
-export declare class HTTPNotFoundError extends HTTPError {
-    constructor(message?: string);
-}
-//# sourceMappingURL=HTTPNotFoundError.d.ts.map

package/dist/src/app/errors/HTTPNotFoundError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HTTPNotFoundError.d.ts","sourceRoot":"","sources":["../../../../src/app/errors/HTTPNotFoundError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,qBAAa,iBAAkB,SAAQ,SAAS;gBAClC,OAAO,CAAC,EAAE,MAAM;CAG7B"}

package/dist/src/app/errors/HTTPNotFoundError.js

@@ -1,7 +0,0 @@
-import { HTTPError } from './HTTPError.js';
-export class HTTPNotFoundError extends HTTPError {
-    constructor(message) {
-        super(message || 'Not found', 404);
-    }
-}
-//# sourceMappingURL=HTTPNotFoundError.js.map

package/dist/src/app/errors/HTTPNotFoundError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HTTPNotFoundError.js","sourceRoot":"","sources":["../../../../src/app/errors/HTTPNotFoundError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,OAAO,iBAAkB,SAAQ,SAAS;IAC9C,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,WAAW,EAAE,GAAG,CAAC,CAAC;IACrC,CAAC;CACF"}

package/dist/src/app/errors/HTTPUnprocessableEntityError.d.ts

@@ -1,5 +0,0 @@
-import { HTTPError } from './HTTPError.js';
-export declare class HTTPUnprocessableEntityError extends HTTPError {
-    constructor(message?: string);
-}
-//# sourceMappingURL=HTTPUnprocessableEntityError.d.ts.map

package/dist/src/app/errors/HTTPUnprocessableEntityError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HTTPUnprocessableEntityError.d.ts","sourceRoot":"","sources":["../../../../src/app/errors/HTTPUnprocessableEntityError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,qBAAa,4BAA6B,SAAQ,SAAS;gBAC7C,OAAO,CAAC,EAAE,MAAM;CAG7B"}

package/dist/src/app/errors/HTTPUnprocessableEntityError.js

@@ -1,7 +0,0 @@
-import { HTTPError } from './HTTPError.js';
-export class HTTPUnprocessableEntityError extends HTTPError {
-    constructor(message) {
-        super(message || 'Unprocessable Entity', 422);
-    }
-}
-//# sourceMappingURL=HTTPUnprocessableEntityError.js.map

package/dist/src/app/errors/HTTPUnprocessableEntityError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HTTPUnprocessableEntityError.js","sourceRoot":"","sources":["../../../../src/app/errors/HTTPUnprocessableEntityError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,OAAO,4BAA6B,SAAQ,SAAS;IACzD,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,IAAI,sBAAsB,EAAE,GAAG,CAAC,CAAC;IAChD,CAAC;CACF"}

package/dist/src/app/errors/index.d.ts

@@ -1,4 +0,0 @@
-export { HTTPError } from './HTTPError.js';
-export { HTTPNotFoundError } from './HTTPNotFoundError.js';
-export { HTTPUnprocessableEntityError } from './HTTPUnprocessableEntityError.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/app/errors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/app/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/src/app/errors/index.js

@@ -1,4 +0,0 @@
-export { HTTPError } from './HTTPError.js';
-export { HTTPNotFoundError } from './HTTPNotFoundError.js';
-export { HTTPUnprocessableEntityError } from './HTTPUnprocessableEntityError.js';
-//# sourceMappingURL=index.js.map