@unito/integration-sdk 0.1.0 → 0.1.1

package/dist/src/errors.d.ts

@@ -1,3 +1,4 @@
+import * as HttpErrors from './httpErrors.js';
 export declare class NoIntegrationFoundError extends Error {
 }
 export declare class NoConfigurationFileError extends Error {
@@ -7,9 +8,9 @@ export declare class ConfigurationMalformed extends Error {
 export declare 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
  */
-export declare function handleErrorResponse(responseStatus: number, message: string): void;
+export declare function buildHttpError(responseStatus: number, message: string): HttpErrors.HttpError;

package/dist/src/errors.js

@@ -8,32 +8,34 @@ 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, message) {
+export function buildHttpError(responseStatus, message) {
+    let 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/dist/src/httpErrors.d.ts

@@ -20,3 +20,6 @@ export declare class UnprocessableEntityError extends HttpError {
 export declare class RateLimitExceededError extends HttpError {
     constructor(message?: string);
 }
+export declare class WouldExceedLimitError extends HttpError {
+    constructor(message?: string);
+}

package/dist/src/httpErrors.js

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

package/dist/src/index.d.ts

@@ -1,6 +1,7 @@
 export * as Api from '@unito/integration-api';
 export { default as Integration } from './integration.js';
 export * from './handler.js';
-export { Provider, type Response as ProviderResponse, type RequestOptions as ProviderRequestOptions, } from './resources/provider.js';
+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';

package/dist/src/index.js

@@ -1,6 +1,8 @@
+/* c8 ignore start */
 export * as Api from '@unito/integration-api';
 export { default as Integration } from './integration.js';
 export * from './handler.js';
 export { Provider, } from './resources/provider.js';
 export * as HttpErrors from './httpErrors.js';
 export * from './resources/context.js';
+/* c8 ignore stop */

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

@@ -6,6 +6,9 @@ declare global {
         }
     }
 }
-export type Credentials = Record<string, unknown>;
+export type Credentials = {
+    accessToken?: string;
+    [keys: string]: unknown;
+};
 declare const middleware: (req: Request, res: Response, next: NextFunction) => void;
 export default middleware;

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

@@ -1,36 +1,59 @@
 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 declare class Provider {
-    protected prepareRequest: ((context: {
+    protected rateLimiter: RateLimiter | undefined;
+    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;
+    };
+    /**
+     * 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;
     });
     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>>;
+    post<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
+    put<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
+    patch<T>(endpoint: string, body: Record<string, unknown>, options: RequestOptions): Promise<Response<T>>;
+    delete<T>(endpoint: string, options: RequestOptions): Promise<Response<T>>;
     private fetchWrapper;
 }

package/dist/src/resources/provider.js

@@ -1,11 +1,19 @@
-import { handleErrorResponse as throwHttpError } from '../errors.js';
+import { buildHttpError } from '../errors.js';
 export class Provider {
-    prepareRequest = undefined;
+    rateLimiter = undefined;
+    prepareRequest;
+    /**
+     * 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) {
         this.prepareRequest = options.prepareRequest;
+        this.rateLimiter = options.rateLimiter;
     }
     async get(endpoint, options) {
-        return this.fetchWrapper(endpoint, {
+        return this.fetchWrapper(endpoint, null, {
             ...options,
             method: 'GET',
             defaultHeaders: {
@@ -14,8 +22,8 @@ export class Provider {
             },
         });
     }
-    async post(endpoint, options) {
-        return this.fetchWrapper(endpoint, {
+    async post(endpoint, body, options) {
+        return this.fetchWrapper(endpoint, body, {
             ...options,
             method: 'POST',
             defaultHeaders: {
@@ -24,8 +32,18 @@ export class Provider {
             },
         });
     }
-    async patch(endpoint, options) {
-        return this.fetchWrapper(endpoint, {
+    async put(endpoint, body, options) {
+        return this.fetchWrapper(endpoint, body, {
+            ...options,
+            method: 'PUT',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async patch(endpoint, body, options) {
+        return this.fetchWrapper(endpoint, body, {
             ...options,
             method: 'PATCH',
             defaultHeaders: {
@@ -34,43 +52,50 @@ export class Provider {
             },
         });
     }
-    async fetchWrapper(endpoint, options) {
-        if (!this.prepareRequest) {
-            throw new Error('Provider not initialized');
-        }
+    async delete(endpoint, options) {
+        return this.fetchWrapper(endpoint, null, {
+            ...options,
+            method: 'DELETE',
+            defaultHeaders: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+            },
+        });
+    }
+    async fetchWrapper(endpoint, body, options) {
         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) {
+        let stringifiedBody = null;
+        if (body) {
             if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
-                body = new URLSearchParams(options.body).toString(); // this doesn't support objects!
+                stringifiedBody = new URLSearchParams(body).toString();
             }
             else if (headers['Content-Type'] === 'application/json') {
-                body = JSON.stringify(options.body);
+                stringifiedBody = JSON.stringify(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 };
+        const callToProvider = async () => {
+            const response = await fetch(absoluteUrl, {
+                method: options.method,
+                headers,
+                body: stringifiedBody,
+            });
+            if (response.status >= 400) {
+                const textResult = await response.text();
+                throw buildHttpError(response.status, textResult);
+            }
+            try {
+                const data = response.body ? await response.json() : undefined;
+                return { status: response.status, headers: response.headers, data };
+            }
+            catch {
+                throw buildHttpError(400, 'Invalid JSON response');
+            }
+        };
+        return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
     }
 }

package/dist/test/errors.test.js

@@ -4,13 +4,12 @@ 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);
+        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/dist/test/handler.test.js

@@ -13,7 +13,7 @@ describe('Handler', () => {
     describe('constructor', () => {
         it('returns a Handler', () => {
             const itemHandler = new Handler('/', {});
-            assert.equal(itemHandler instanceof Handler, true);
+            assert.ok(itemHandler instanceof Handler);
         });
         it('validates path', () => {
             const paths = [

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

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

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.1",
   "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;
 }