@unito/integration-sdk 2.3.13 → 2.3.15

package/src/resources/provider.ts

@@ -1,5 +1,7 @@
 import https from 'https';
 import FormData from 'form-data';
+import * as stream from 'stream';
+import { IncomingHttpHeaders } from 'http';
 
 import { buildHttpError } from '../errors.js';
 import * as HttpErrors from '../httpErrors.js';
@@ -56,7 +58,7 @@ export type RequestOptions = {
 export type Response<T> = {
   body: T;
   status: number;
-  headers: Headers;
+  headers: Headers | IncomingHttpHeaders;
 };
 
 export type PreparedRequest = {
@@ -230,7 +232,7 @@ export class Provider {
                 if (body.error) {
                   reject(this.handleError(400, body.error.message, options));
                 }
-                resolve({ status: 201, headers: response.headers as unknown as Headers, body: body as T });
+                resolve({ status: 201, headers: response.headers, body });
               } catch (error) {
                 reject(this.handleError(500, `Failed to parse response body: "${error}"`, options));
               }
@@ -241,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));
@@ -251,6 +272,134 @@ export class Provider {
     return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
   }
 
+  /**
+   * Performs a POST request to the provider streaming a Readable directly without loading it into memory.
+   *
+   * @param endpoint Path to the provider's resource. Will be added to the URL returned by the prepareRequest function.
+   * @param stream The Readable stream containing the binary data to be sent.
+   * @param options RequestOptions used to adjust the call made to the provider (use to override default headers).
+   * @returns The {@link Response} extracted from the provider.
+   */
+  public async postStream<T>(endpoint: string, stream: stream.Readable, options: RequestOptions): Promise<Response<T>> {
+    const { url: providerUrl, headers: providerHeaders } = await this.prepareRequest(options);
+    const absoluteUrl = this.generateAbsoluteUrl(providerUrl, endpoint, options.queryParams);
+    const headers = {
+      'Content-Type': 'application/octet-stream',
+      Accept: 'application/json',
+      ...providerHeaders,
+      ...options.additionnalheaders,
+    };
+
+    const callToProvider = async (): Promise<Response<T>> => {
+      return new Promise((resolve, reject) => {
+        let isSettled = false; // Prevent double rejection
+
+        const cleanup = () => {
+          if (!stream.destroyed) {
+            stream.destroy();
+          }
+        };
+
+        const safeReject = (error: HttpErrors.HttpError) => {
+          if (!isSettled) {
+            isSettled = true;
+            cleanup();
+            reject(error);
+          }
+        };
+
+        const safeResolve = (response: Response<T>) => {
+          if (!isSettled) {
+            isSettled = true;
+            resolve(response);
+          }
+        };
+
+        try {
+          const urlObj = new URL(absoluteUrl);
+          const requestOptions: https.RequestOptions = {
+            hostname: urlObj.hostname,
+            path: urlObj.pathname + urlObj.search,
+            method: 'POST',
+            headers,
+            timeout: 0,
+          };
+
+          const request = https.request(requestOptions, response => {
+            response.setEncoding('utf8');
+            let responseBody = '';
+
+            response.on('data', chunk => {
+              responseBody += chunk;
+            });
+
+            response.on('error', error => {
+              safeReject(this.handleError(500, `Response stream error: "${error}"`, options));
+            });
+
+            response.on('end', () => {
+              try {
+                if (response.statusCode && response.statusCode >= 400) {
+                  safeReject(this.handleError(response.statusCode, responseBody, options));
+                  return;
+                }
+
+                const body = responseBody ? JSON.parse(responseBody) : undefined;
+                safeResolve({
+                  status: response.statusCode || 200,
+                  headers: response.headers,
+                  body,
+                });
+              } catch (error) {
+                safeReject(this.handleError(500, `Failed to parse response body: "${error}"`, options));
+              }
+            });
+          });
+
+          request.on('timeout', () => {
+            request.destroy();
+            safeReject(this.handleError(408, 'Request timeout', options));
+          });
+
+          request.on('error', error => {
+            safeReject(this.handleError(500, `Error while calling the provider: "${error}"`, options));
+          });
+
+          stream.on('error', error => {
+            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);
+        } catch (error) {
+          safeReject(this.handleError(500, `Unexpected error while calling the provider: "${error}"`, options));
+        }
+      });
+    };
+
+    return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();
+  }
+
   /**
    * Performs a PUT request to the provider.
    *
@@ -409,7 +558,7 @@ export class Provider {
         response = await fetch(absoluteUrl, {
           method: options.method,
           headers,
-          body: fetchBody,
+          body: fetchBody as BodyInit | null,
           ...(options.signal ? { signal: options.signal } : {}),
         });
       } catch (error) {