@unito/integration-sdk 2.3.14 → 2.3.15

package/dist/src/index.cjs

@@ -1369,6 +1369,21 @@ class Provider {
                     request.on('error', error => {
                         reject(this.handleError(400, `Error while calling the provider: "${error}"`, options));
                     });
+                    if (options.signal) {
+                        const abortHandler = () => {
+                            request.destroy();
+                            reject(this.handleError(408, 'Timeout', options));
+                        };
+                        if (options.signal.aborted) {
+                            abortHandler();
+                        }
+                        options.signal.addEventListener('abort', abortHandler);
+                        request.on('close', () => {
+                            if (options.signal) {
+                                options.signal.removeEventListener('abort', abortHandler);
+                            }
+                        });
+                    }
                     form.pipe(request);
                 }
                 catch (error) {
@@ -1423,6 +1438,7 @@ class Provider {
                         path: urlObj.pathname + urlObj.search,
                         method: 'POST',
                         headers,
+                        timeout: 0,
                     };
                     const request = https.request(requestOptions, response => {
                         response.setEncoding('utf8');
@@ -1462,6 +1478,21 @@ class Provider {
                         request.destroy();
                         safeReject(this.handleError(500, `Stream error: "${error}"`, options));
                     });
+                    if (options.signal) {
+                        const abortHandler = () => {
+                            request.destroy();
+                            safeReject(this.handleError(408, 'Timeout', options));
+                        };
+                        if (options.signal.aborted) {
+                            abortHandler();
+                        }
+                        options.signal.addEventListener('abort', abortHandler);
+                        request.on('close', () => {
+                            if (options.signal) {
+                                options.signal.removeEventListener('abort', abortHandler);
+                            }
+                        });
+                    }
                     // Stream the data directly without buffering
                     stream.pipe(request);
                 }

package/dist/src/resources/provider.js

@@ -150,6 +150,21 @@ export class Provider {
                     request.on('error', error => {
                         reject(this.handleError(400, `Error while calling the provider: "${error}"`, options));
                     });
+                    if (options.signal) {
+                        const abortHandler = () => {
+                            request.destroy();
+                            reject(this.handleError(408, 'Timeout', options));
+                        };
+                        if (options.signal.aborted) {
+                            abortHandler();
+                        }
+                        options.signal.addEventListener('abort', abortHandler);
+                        request.on('close', () => {
+                            if (options.signal) {
+                                options.signal.removeEventListener('abort', abortHandler);
+                            }
+                        });
+                    }
                     form.pipe(request);
                 }
                 catch (error) {
@@ -204,6 +219,7 @@ export class Provider {
                         path: urlObj.pathname + urlObj.search,
                         method: 'POST',
                         headers,
+                        timeout: 0,
                     };
                     const request = https.request(requestOptions, response => {
                         response.setEncoding('utf8');
@@ -243,6 +259,21 @@ export class Provider {
                         request.destroy();
                         safeReject(this.handleError(500, `Stream error: "${error}"`, options));
                     });
+                    if (options.signal) {
+                        const abortHandler = () => {
+                            request.destroy();
+                            safeReject(this.handleError(408, 'Timeout', options));
+                        };
+                        if (options.signal.aborted) {
+                            abortHandler();
+                        }
+                        options.signal.addEventListener('abort', abortHandler);
+                        request.on('close', () => {
+                            if (options.signal) {
+                                options.signal.removeEventListener('abort', abortHandler);
+                            }
+                        });
+                    }
                     // Stream the data directly without buffering
                     stream.pipe(request);
                 }

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

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import { Readable } from 'stream';
 import nock from 'nock';
+import https from 'https';
 import { Provider } from '../../src/resources/provider.js';
 import * as HttpErrors from '../../src/httpErrors.js';
 import Logger from '../../src/resources/logger.js';
@@ -23,6 +24,21 @@ describe('Provider', () => {
         },
     });
     const logger = new Logger();
+    // Helper to spy on https.request and capture options
+    const spyOnHttpsRequest = () => {
+        let capturedOptions;
+        const originalRequest = https.request;
+        https.request = function (options, callback) {
+            capturedOptions = options;
+            return originalRequest.call(https, options, callback);
+        };
+        return {
+            getCapturedOptions: () => capturedOptions,
+            restore: () => {
+                https.request = originalRequest;
+            },
+        };
+    };
     it('get', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
@@ -941,4 +957,212 @@ describe('Provider', () => {
             unitoCredentialId: '123',
         });
     });
+    it('postStream sets timeout to 0 (no timeout)', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const testData = 'timeout test data';
+        const stream = Readable.from([testData]);
+        const spy = spyOnHttpsRequest();
+        const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+            });
+            assert.ok(scope.isDone());
+            assert.equal(spy.getCapturedOptions().timeout, 0, 'Timeout should be set to 0 (no timeout)');
+        }
+        finally {
+            spy.restore();
+        }
+    });
+    it('postStream handles AbortSignal for request cancellation', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const stream = Readable.from(['abort signal test']);
+        const abortController = new AbortController();
+        // Simulate aborting the request immediately
+        abortController.abort();
+        let error;
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postStream handles AbortSignal timeout during request', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const stream = Readable.from(['timeout during request test']);
+        const abortController = new AbortController();
+        // Delay response to simulate a slow server
+        nock('https://www.myApi.com').post('/upload').delayConnection(100).reply(201, { success: true });
+        // Abort after 50ms
+        setTimeout(() => abortController.abort(), 50);
+        let error;
+        try {
+            await streamProvider.postStream('/upload', stream, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postStream cleans up AbortSignal listener on success', async () => {
+        const streamProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const testData = 'cleanup test';
+        const stream = Readable.from([testData]);
+        const abortController = new AbortController();
+        const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+        const response = await streamProvider.postStream('/upload', stream, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+            signal: abortController.signal,
+        });
+        assert.ok(scope.isDone());
+        assert.equal(response.status, 201);
+        // Verify the listener was removed by checking that aborting after completion
+        // doesn't cause any side effects (if listener wasn't removed, this could cause issues)
+        assert.doesNotThrow(() => {
+            abortController.abort();
+        }, 'Aborting after completion should not throw or cause issues');
+        // Verify the signal is indeed aborted
+        assert.ok(abortController.signal.aborted, 'Signal should be aborted');
+    });
+    it('postForm handles AbortSignal for request cancellation', async () => {
+        const FormData = (await import('form-data')).default;
+        const formProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const form = new FormData();
+        form.append('field1', 'value1');
+        form.append('field2', 'value2');
+        const abortController = new AbortController();
+        // Simulate aborting the request immediately
+        abortController.abort();
+        let error;
+        try {
+            await formProvider.postForm('/upload-form', form, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postForm handles AbortSignal timeout during request', async () => {
+        const FormData = (await import('form-data')).default;
+        const formProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const form = new FormData();
+        form.append('field1', 'value1');
+        const abortController = new AbortController();
+        // Mock a delayed response
+        nock('https://www.myApi.com').post('/upload-form').delayConnection(100).reply(201, { success: true, id: '12345' });
+        // Abort after 50ms
+        setTimeout(() => abortController.abort(), 50);
+        let error;
+        try {
+            await formProvider.postForm('/upload-form', form, {
+                credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+                logger,
+                signal: abortController.signal,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        assert.ok(error instanceof HttpErrors.TimeoutError);
+        assert.equal(error.message, 'Timeout');
+    });
+    it('postForm successfully completes with AbortSignal provided', async () => {
+        const FormData = (await import('form-data')).default;
+        const formProvider = new Provider({
+            prepareRequest: requestOptions => ({
+                url: `https://www.myApi.com`,
+                headers: {
+                    'X-Custom-Provider-Header': 'value',
+                    'X-Provider-Credential-Header': requestOptions.credentials.apiKey,
+                },
+            }),
+        });
+        const form = new FormData();
+        form.append('field1', 'value1');
+        form.append('field2', 'value2');
+        const abortController = new AbortController();
+        const scope = nock('https://www.myApi.com').post('/upload-form').reply(201, { success: true, id: '12345' });
+        const response = await formProvider.postForm('/upload-form', form, {
+            credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+            logger,
+            signal: abortController.signal,
+        });
+        assert.ok(scope.isDone());
+        assert.equal(response.status, 201);
+        assert.deepEqual(response.body, { success: true, id: '12345' });
+        // Verify the listener was removed by checking that aborting after completion
+        // doesn't cause any side effects
+        assert.doesNotThrow(() => {
+            abortController.abort();
+        }, 'Aborting after completion should not throw or cause issues');
+        // Verify the signal is indeed aborted
+        assert.ok(abortController.signal.aborted, 'Signal should be aborted');
+    });
 });

package/package.json

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

package/src/resources/provider.ts

@@ -243,6 +243,25 @@ export class Provider {
             reject(this.handleError(400, `Error while calling the provider: "${error}"`, options));
           });
 
+          if (options.signal) {
+            const abortHandler = () => {
+              request.destroy();
+              reject(this.handleError(408, 'Timeout', options));
+            };
+
+            if (options.signal.aborted) {
+              abortHandler();
+            }
+
+            options.signal.addEventListener('abort', abortHandler);
+
+            request.on('close', () => {
+              if (options.signal) {
+                options.signal.removeEventListener('abort', abortHandler);
+              }
+            });
+          }
+
           form.pipe(request);
         } catch (error) {
           reject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`, options));
@@ -303,6 +322,7 @@ export class Provider {
             path: urlObj.pathname + urlObj.search,
             method: 'POST',
             headers,
+            timeout: 0,
           };
 
           const request = https.request(requestOptions, response => {
@@ -350,6 +370,25 @@ export class Provider {
             safeReject(this.handleError(500, `Stream error: "${error}"`, options));
           });
 
+          if (options.signal) {
+            const abortHandler = () => {
+              request.destroy();
+              safeReject(this.handleError(408, 'Timeout', options));
+            };
+
+            if (options.signal.aborted) {
+              abortHandler();
+            }
+
+            options.signal.addEventListener('abort', abortHandler);
+
+            request.on('close', () => {
+              if (options.signal) {
+                options.signal.removeEventListener('abort', abortHandler);
+              }
+            });
+          }
+
           // Stream the data directly without buffering
           stream.pipe(request);
         } catch (error) {

package/test/resources/provider.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import { Readable } from 'stream';
 import nock from 'nock';
+import https from 'https';
 
 import { Provider } from '../../src/resources/provider.js';
 import * as HttpErrors from '../../src/httpErrors.js';
@@ -28,6 +29,24 @@ describe('Provider', () => {
 
   const logger = new Logger();
 
+  // Helper to spy on https.request and capture options
+  const spyOnHttpsRequest = (): { getCapturedOptions: () => any; restore: () => void } => {
+    let capturedOptions: any;
+    const originalRequest = https.request;
+
+    (https as any).request = function (options: any, callback: any) {
+      capturedOptions = options;
+      return originalRequest.call(https, options, callback);
+    };
+
+    return {
+      getCapturedOptions: () => capturedOptions,
+      restore: () => {
+        (https as any).request = originalRequest;
+      },
+    };
+  };
+
   it('get', async context => {
     const response = new Response('{"data": "value"}', {
       status: 200,
@@ -1132,4 +1151,254 @@ describe('Provider', () => {
       unitoCredentialId: '123',
     });
   });
+
+  it('postStream sets timeout to 0 (no timeout)', async () => {
+    const streamProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const testData = 'timeout test data';
+    const stream = Readable.from([testData]);
+
+    const spy = spyOnHttpsRequest();
+    const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+
+    try {
+      await streamProvider.postStream('/upload', stream, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+      });
+
+      assert.ok(scope.isDone());
+      assert.equal(spy.getCapturedOptions().timeout, 0, 'Timeout should be set to 0 (no timeout)');
+    } finally {
+      spy.restore();
+    }
+  });
+
+  it('postStream handles AbortSignal for request cancellation', async () => {
+    const streamProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const stream = Readable.from(['abort signal test']);
+    const abortController = new AbortController();
+
+    // Simulate aborting the request immediately
+    abortController.abort();
+
+    let error;
+    try {
+      await streamProvider.postStream('/upload', stream, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        signal: abortController.signal,
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    assert.ok(error instanceof HttpErrors.TimeoutError);
+    assert.equal(error.message, 'Timeout');
+  });
+
+  it('postStream handles AbortSignal timeout during request', async () => {
+    const streamProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const stream = Readable.from(['timeout during request test']);
+    const abortController = new AbortController();
+
+    // Delay response to simulate a slow server
+    nock('https://www.myApi.com').post('/upload').delayConnection(100).reply(201, { success: true });
+
+    // Abort after 50ms
+    setTimeout(() => abortController.abort(), 50);
+
+    let error;
+    try {
+      await streamProvider.postStream('/upload', stream, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        signal: abortController.signal,
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    assert.ok(error instanceof HttpErrors.TimeoutError);
+    assert.equal(error.message, 'Timeout');
+  });
+
+  it('postStream cleans up AbortSignal listener on success', async () => {
+    const streamProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const testData = 'cleanup test';
+    const stream = Readable.from([testData]);
+    const abortController = new AbortController();
+
+    const scope = nock('https://www.myApi.com').post('/upload', testData).reply(201, { success: true });
+
+    const response = await streamProvider.postStream('/upload', stream, {
+      credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+      logger,
+      signal: abortController.signal,
+    });
+
+    assert.ok(scope.isDone());
+    assert.equal(response.status, 201);
+
+    // Verify the listener was removed by checking that aborting after completion
+    // doesn't cause any side effects (if listener wasn't removed, this could cause issues)
+    assert.doesNotThrow(() => {
+      abortController.abort();
+    }, 'Aborting after completion should not throw or cause issues');
+
+    // Verify the signal is indeed aborted
+    assert.ok(abortController.signal.aborted, 'Signal should be aborted');
+  });
+
+  it('postForm handles AbortSignal for request cancellation', async () => {
+    const FormData = (await import('form-data')).default;
+
+    const formProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const form = new FormData();
+    form.append('field1', 'value1');
+    form.append('field2', 'value2');
+
+    const abortController = new AbortController();
+
+    // Simulate aborting the request immediately
+    abortController.abort();
+
+    let error;
+    try {
+      await formProvider.postForm('/upload-form', form, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        signal: abortController.signal,
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    assert.ok(error instanceof HttpErrors.TimeoutError);
+    assert.equal(error.message, 'Timeout');
+  });
+
+  it('postForm handles AbortSignal timeout during request', async () => {
+    const FormData = (await import('form-data')).default;
+
+    const formProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const form = new FormData();
+    form.append('field1', 'value1');
+
+    const abortController = new AbortController();
+
+    // Mock a delayed response
+    nock('https://www.myApi.com').post('/upload-form').delayConnection(100).reply(201, { success: true, id: '12345' });
+
+    // Abort after 50ms
+    setTimeout(() => abortController.abort(), 50);
+
+    let error;
+    try {
+      await formProvider.postForm('/upload-form', form, {
+        credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+        logger,
+        signal: abortController.signal,
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    assert.ok(error instanceof HttpErrors.TimeoutError);
+    assert.equal(error.message, 'Timeout');
+  });
+
+  it('postForm successfully completes with AbortSignal provided', async () => {
+    const FormData = (await import('form-data')).default;
+
+    const formProvider = new Provider({
+      prepareRequest: requestOptions => ({
+        url: `https://www.myApi.com`,
+        headers: {
+          'X-Custom-Provider-Header': 'value',
+          'X-Provider-Credential-Header': requestOptions.credentials.apiKey as string,
+        },
+      }),
+    });
+
+    const form = new FormData();
+    form.append('field1', 'value1');
+    form.append('field2', 'value2');
+
+    const abortController = new AbortController();
+
+    const scope = nock('https://www.myApi.com').post('/upload-form').reply(201, { success: true, id: '12345' });
+
+    const response = await formProvider.postForm('/upload-form', form, {
+      credentials: { apiKey: 'apikey#1111', unitoCredentialId: '123' },
+      logger,
+      signal: abortController.signal,
+    });
+
+    assert.ok(scope.isDone());
+    assert.equal(response.status, 201);
+    assert.deepEqual(response.body, { success: true, id: '12345' });
+
+    // Verify the listener was removed by checking that aborting after completion
+    // doesn't cause any side effects
+    assert.doesNotThrow(() => {
+      abortController.abort();
+    }, 'Aborting after completion should not throw or cause issues');
+
+    // Verify the signal is indeed aborted
+    assert.ok(abortController.signal.aborted, 'Signal should be aborted');
+  });
 });