@unito/integration-sdk 1.3.0 → 1.4.0

package/dist/src/index.cjs

@@ -1236,22 +1236,22 @@ class Provider {
                             try {
                                 const body = JSON.parse(responseBody);
                                 if (body.error) {
-                                    reject(this.handleError(400, body.error.message));
+                                    reject(this.handleError(400, body.error.message, options));
                                 }
                                 resolve({ status: 201, headers: response.headers, body: body });
                             }
                             catch (error) {
-                                reject(this.handleError(500, `Failed to parse response body: "${error}"`));
+                                reject(this.handleError(500, `Failed to parse response body: "${error}"`, options));
                             }
                         });
                     });
                     request.on('error', error => {
-                        reject(this.handleError(400, `Error while calling the provider: "${error}"`));
+                        reject(this.handleError(400, `Error while calling the provider: "${error}"`, options));
                     });
                     form.pipe(request);
                 }
                 catch (error) {
-                    reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`));
+                    reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`, options));
                 }
             });
         };
@@ -1361,17 +1361,17 @@ class Provider {
                 if (error instanceof Error) {
                     switch (error.name) {
                         case 'AbortError':
-                            throw this.handleError(408, 'Request aborted');
+                            throw this.handleError(408, 'Request aborted', options);
                         case 'TimeoutError':
-                            throw this.handleError(408, 'Request timeout');
+                            throw this.handleError(408, 'Request timeout', options);
                     }
-                    throw this.handleError(500, `Unexpected error while calling the provider: name: "${error.name}" \n message: "${error.message}" \n stack: ${error.stack}`);
+                    throw this.handleError(500, `Unexpected error while calling the provider: name: "${error.name}" \n message: "${error.message}" \n stack: ${error.stack}`, options);
                 }
-                throw this.handleError(500, 'Unexpected error while calling the provider - this is not normal, investigate');
+                throw this.handleError(500, 'Unexpected error while calling the provider - this is not normal, investigate', options);
             }
             if (response.status >= 400) {
                 const textResult = await response.text();
-                throw this.handleError(response.status, textResult);
+                throw this.handleError(response.status, textResult, options);
             }
             const responseContentType = response.headers.get('content-type');
             let body;
@@ -1382,13 +1382,13 @@ class Provider {
                 if (responseContentType && !responseContentType.includes('application/json')) {
                     const textResult = await response.text();
                     throw this.handleError(500, `Unsupported content-type, expected 'application/json' but got '${responseContentType}'.
-             Original response (${response.status}): ${textResult}`);
+             Original response (${response.status}): ${textResult}`, options);
                 }
                 try {
                     body = response.body ? await response.json() : undefined;
                 }
                 catch (err) {
-                    throw this.handleError(500, `Invalid JSON response`);
+                    throw this.handleError(500, `Invalid JSON response`, options);
                 }
             }
             else if (headers.Accept == 'application/octet-stream') {
@@ -1400,14 +1400,14 @@ class Provider {
                 body = (await response.text());
             }
             else {
-                throw this.handleError(500, 'Unsupported Content-Type');
+                throw this.handleError(500, 'Unsupported Content-Type', options);
             }
             return { status: response.status, headers: response.headers, body };
         };
         return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
     }
-    handleError(responseStatus, message) {
-        const customError = this.customErrorHandler?.(responseStatus, message);
+    handleError(responseStatus, message, options) {
+        const customError = this.customErrorHandler?.(responseStatus, message, options);
         return customError ?? buildHttpError(responseStatus, message);
     }
 }

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

@@ -95,7 +95,10 @@ export declare class Provider {
      *
      * @see buildHttpError for the list of standard errors the SDK can handle.
      */
-    protected customErrorHandler: ((responseStatus: number, message: string) => HttpErrors.HttpError | undefined) | undefined;
+    protected customErrorHandler: ((responseStatus: number, message: string, options: {
+        credentials: Credentials;
+        logger: Logger;
+    }) => HttpErrors.HttpError | undefined) | undefined;
     /**
      * Initializes a Provider with the given options.
      *

package/dist/src/resources/provider.js

@@ -137,22 +137,22 @@ export class Provider {
                             try {
                                 const body = JSON.parse(responseBody);
                                 if (body.error) {
-                                    reject(this.handleError(400, body.error.message));
+                                    reject(this.handleError(400, body.error.message, options));
                                 }
                                 resolve({ status: 201, headers: response.headers, body: body });
                             }
                             catch (error) {
-                                reject(this.handleError(500, `Failed to parse response body: "${error}"`));
+                                reject(this.handleError(500, `Failed to parse response body: "${error}"`, options));
                             }
                         });
                     });
                     request.on('error', error => {
-                        reject(this.handleError(400, `Error while calling the provider: "${error}"`));
+                        reject(this.handleError(400, `Error while calling the provider: "${error}"`, options));
                     });
                     form.pipe(request);
                 }
                 catch (error) {
-                    reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`));
+                    reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`, options));
                 }
             });
         };
@@ -262,17 +262,17 @@ export class Provider {
                 if (error instanceof Error) {
                     switch (error.name) {
                         case 'AbortError':
-                            throw this.handleError(408, 'Request aborted');
+                            throw this.handleError(408, 'Request aborted', options);
                         case 'TimeoutError':
-                            throw this.handleError(408, 'Request timeout');
+                            throw this.handleError(408, 'Request timeout', options);
                     }
-                    throw this.handleError(500, `Unexpected error while calling the provider: name: "${error.name}" \n message: "${error.message}" \n stack: ${error.stack}`);
+                    throw this.handleError(500, `Unexpected error while calling the provider: name: "${error.name}" \n message: "${error.message}" \n stack: ${error.stack}`, options);
                 }
-                throw this.handleError(500, 'Unexpected error while calling the provider - this is not normal, investigate');
+                throw this.handleError(500, 'Unexpected error while calling the provider - this is not normal, investigate', options);
             }
             if (response.status >= 400) {
                 const textResult = await response.text();
-                throw this.handleError(response.status, textResult);
+                throw this.handleError(response.status, textResult, options);
             }
             const responseContentType = response.headers.get('content-type');
             let body;
@@ -283,13 +283,13 @@ export class Provider {
                 if (responseContentType && !responseContentType.includes('application/json')) {
                     const textResult = await response.text();
                     throw this.handleError(500, `Unsupported content-type, expected 'application/json' but got '${responseContentType}'.
-             Original response (${response.status}): ${textResult}`);
+             Original response (${response.status}): ${textResult}`, options);
                 }
                 try {
                     body = response.body ? await response.json() : undefined;
                 }
                 catch (err) {
-                    throw this.handleError(500, `Invalid JSON response`);
+                    throw this.handleError(500, `Invalid JSON response`, options);
                 }
             }
             else if (headers.Accept == 'application/octet-stream') {
@@ -301,14 +301,14 @@ export class Provider {
                 body = (await response.text());
             }
             else {
-                throw this.handleError(500, 'Unsupported Content-Type');
+                throw this.handleError(500, 'Unsupported Content-Type', options);
             }
             return { status: response.status, headers: response.headers, body };
         };
         return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
     }
-    handleError(responseStatus, message) {
-        const customError = this.customErrorHandler?.(responseStatus, message);
+    handleError(responseStatus, message, options) {
+        const customError = this.customErrorHandler?.(responseStatus, message, options);
         return customError ?? buildHttpError(responseStatus, message);
     }
 }

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

@@ -314,6 +314,47 @@ describe('Provider', () => {
         assert.ok(error instanceof HttpErrors.HttpError);
         assert.equal(error.message, 'Weird provider behavior');
     });
+    it('should contain the credential in the custom error handler', async (context) => {
+        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,
+                    },
+                };
+            },
+            rateLimiter: undefined,
+            customErrorHandler: (responseStatus, _message, options) => {
+                if (responseStatus === 400) {
+                    // What matter is that we have access to the context in the error handler
+                    throw new HttpErrors.BadRequestError(`Error with API key ${options?.credentials.apiKey}`);
+                }
+                return undefined;
+            },
+        });
+        const response = new Response(undefined, {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        context.mock.method(global, 'fetch', () => Promise.resolve(response));
+        const options = {
+            credentials: { apiKey: 'apikey#1111' },
+            logger: logger,
+            signal: new AbortController().signal,
+            additionnalheaders: { 'X-Additional-Header': 'value1' },
+        };
+        let error;
+        try {
+            await provider.delete('/endpoint/123', options);
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.HttpError);
+        assert.equal(error.message, 'Error with API key apikey#1111');
+    });
     it('uses default behavior if custom error handler returns undefined', async (context) => {
         const rateLimitedProvider = new Provider({
             prepareRequest: requestOptions => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/resources/provider.ts

@@ -100,7 +100,14 @@ export class Provider {
    * @see buildHttpError for the list of standard errors the SDK can handle.
    */
   protected customErrorHandler:
-    | ((responseStatus: number, message: string) => HttpErrors.HttpError | undefined)
+    | ((
+        responseStatus: number,
+        message: string,
+        options: {
+          credentials: Credentials;
+          logger: Logger;
+        },
+      ) => HttpErrors.HttpError | undefined)
     | undefined;
 
   /**
@@ -216,22 +223,22 @@ export class Provider {
               try {
                 const body = JSON.parse(responseBody);
                 if (body.error) {
-                  reject(this.handleError(400, body.error.message));
+                  reject(this.handleError(400, body.error.message, options));
                 }
                 resolve({ status: 201, headers: response.headers as unknown as Headers, body: body as T });
               } catch (error) {
-                reject(this.handleError(500, `Failed to parse response body: "${error}"`));
+                reject(this.handleError(500, `Failed to parse response body: "${error}"`, options));
               }
             });
           });
 
           request.on('error', error => {
-            reject(this.handleError(400, `Error while calling the provider: "${error}"`));
+            reject(this.handleError(400, `Error while calling the provider: "${error}"`, options));
           });
 
           form.pipe(request);
         } catch (error) {
-          reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`));
+          reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`, options));
         }
       });
     };
@@ -358,22 +365,27 @@ export class Provider {
         if (error instanceof Error) {
           switch (error.name) {
             case 'AbortError':
-              throw this.handleError(408, 'Request aborted');
+              throw this.handleError(408, 'Request aborted', options);
             case 'TimeoutError':
-              throw this.handleError(408, 'Request timeout');
+              throw this.handleError(408, 'Request timeout', options);
           }
           throw this.handleError(
             500,
             `Unexpected error while calling the provider: name: "${error.name}" \n message: "${error.message}" \n stack: ${error.stack}`,
+            options,
           );
         }
 
-        throw this.handleError(500, 'Unexpected error while calling the provider - this is not normal, investigate');
+        throw this.handleError(
+          500,
+          'Unexpected error while calling the provider - this is not normal, investigate',
+          options,
+        );
       }
 
       if (response.status >= 400) {
         const textResult = await response.text();
-        throw this.handleError(response.status, textResult);
+        throw this.handleError(response.status, textResult, options);
       }
 
       const responseContentType = response.headers.get('content-type');
@@ -389,13 +401,14 @@ export class Provider {
             500,
             `Unsupported content-type, expected 'application/json' but got '${responseContentType}'.
              Original response (${response.status}): ${textResult}`,
+            options,
           );
         }
 
         try {
           body = response.body ? await response.json() : undefined;
         } catch (err) {
-          throw this.handleError(500, `Invalid JSON response`);
+          throw this.handleError(500, `Invalid JSON response`, options);
         }
       } else if (headers.Accept == 'application/octet-stream') {
         // When we expect octet-stream, we accept any Content-Type the provider sends us, we just want to stream it.
@@ -404,7 +417,7 @@ export class Provider {
         // Accept text based content types
         body = (await response.text()) as T;
       } else {
-        throw this.handleError(500, 'Unsupported Content-Type');
+        throw this.handleError(500, 'Unsupported Content-Type', options);
       }
 
       return { status: response.status, headers: response.headers, body };
@@ -413,8 +426,8 @@ export class Provider {
     return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
   }
 
-  private handleError(responseStatus: number, message: string): HttpErrors.HttpError {
-    const customError = this.customErrorHandler?.(responseStatus, message);
+  private handleError(responseStatus: number, message: string, options: RequestOptions): HttpErrors.HttpError {
+    const customError = this.customErrorHandler?.(responseStatus, message, options);
 
     return customError ?? buildHttpError(responseStatus, message);
   }

package/test/resources/provider.test.ts

@@ -374,6 +374,53 @@ describe('Provider', () => {
     assert.equal(error.message, 'Weird provider behavior');
   });
 
+  it('should contain the credential in the custom error handler', async context => {
+    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,
+          },
+        };
+      },
+      rateLimiter: undefined,
+      customErrorHandler: (responseStatus: number, _message: string, options) => {
+        if (responseStatus === 400) {
+          // What matter is that we have access to the context in the error handler
+          throw new HttpErrors.BadRequestError(`Error with API key ${options?.credentials.apiKey}`);
+        }
+
+        return undefined;
+      },
+    });
+
+    const response = new Response(undefined, {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+    context.mock.method(global, 'fetch', () => Promise.resolve(response));
+
+    const options = {
+      credentials: { apiKey: 'apikey#1111' },
+      logger: logger,
+      signal: new AbortController().signal,
+      additionnalheaders: { 'X-Additional-Header': 'value1' },
+    };
+
+    let error;
+    try {
+      await provider.delete('/endpoint/123', options);
+    } catch (e) {
+      error = e;
+    }
+
+    assert.ok(error instanceof HttpErrors.HttpError);
+    assert.equal(error.message, 'Error with API key apikey#1111');
+  });
+
   it('uses default behavior if custom error handler returns undefined', async context => {
     const rateLimitedProvider = new Provider({
       prepareRequest: requestOptions => {