fix: Typing of both fetches

Author: asafgardin

src/APIClient.ts

@@ -1,7 +1,7 @@
 import { AI21Error } from './errors';
 import { VERSION } from './version';
 
-import { RequestOptions, FinalRequestOptions, APIResponseProps, HTTPMethod, Headers } from './types/index.js';
+import { RequestOptions, FinalRequestOptions, APIResponseProps, HTTPMethod, Headers, UnifiedResponse } from './types';
 import { AI21EnvConfig } from './EnvConfig';
 import { handleAPIResponse } from './ResponseHandler';
 import { createFetchInstance } from 'envFetch';
@@ -90,25 +90,19 @@ export abstract class APIClient {
   }
 
   private async performRequest(options: FinalRequestOptions): Promise<APIResponseProps> {
-    const controller = new AbortController();
     const url = `${this.baseURL}${options.path}`;
 
     const headers = {
       ...this.defaultHeaders(options),
       ...options.headers,
     };
-    const response = await this.fetch.call(url, {
-      method: options.method,
-      headers: headers as any,
-      signal: controller.signal,
-      body: options.body ? JSON.stringify(options.body) : undefined,
-    });
+    const response = await this.fetch.call(url, { ...options, headers });
 
     if (!response.ok) {
       throw new AI21Error(`Request failed with status ${response.status}. ${await response.text()}`);
     }
 
-    return { response, options, controller };
+    return { response: response as UnifiedResponse, options };
   }
 
   protected isRunningInBrowser(): boolean {

src/Streaming/Stream.ts

@@ -2,6 +2,7 @@ import { DefaultSSEDecoder } from './SSEDecoder';
 import { SSEDecoder } from './SSEDecoder';
 import { SSE_DONE_MSG } from './Consts';
 import { StreamingDecodeError } from '../errors';
+import { UnifiedResponse } from '../types';
 
 function getStreamMessage<T>(chunk: string): T {
   try {
@@ -16,15 +17,15 @@ export class Stream<T> implements AsyncIterableIterator<T> {
   private iterator: AsyncIterableIterator<T>;
 
   constructor(
-    private response: Response,
+    private response: UnifiedResponse,
     decoder?: SSEDecoder,
   ) {
     this.decoder = decoder || new DefaultSSEDecoder();
     this.iterator = this.stream();
   }
 
   private async *stream(): AsyncIterableIterator<T> {
-    for await (const chunk of this.decoder.iterLines(this.response)) {
+    for await (const chunk of this.decoder.iterLines(this.response as Response)) {
       if (chunk === SSE_DONE_MSG) break;
       yield getStreamMessage(chunk);
     }

src/fetch/BaseFetch.ts

@@ -1,3 +1,6 @@
+import { FinalRequestOptions, UnifiedResponse } from "types";
+
+
 export abstract class Fetch {
-    abstract call(url: string, options?: RequestInit): Promise<Response>;
+    abstract call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse>;
 }

src/fetch/BrowserFetch.ts

@@ -1,7 +1,15 @@
+import { FinalRequestOptions, UnifiedResponse } from 'types';
 import { Fetch } from './BaseFetch';
 
 export class BrowserFetch extends Fetch {
-    call(url: string, options?: RequestInit): Promise<Response> {
-        return fetch(url, options);
+    call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse> {
+        const controller = new AbortController();
+
+        return fetch(url, {
+            method: options?.method,
+            headers: options?.headers as HeadersInit,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+            signal: controller.signal,
+        });
     }
 }

src/fetch/NodeFetch.ts

@@ -1,11 +1,15 @@
-// import { RequestInit as NodeRequestInit } from 'node-fetch';
-
+import { FinalRequestOptions, UnifiedResponse } from "types";
 import { Fetch } from "./BaseFetch";
 
 export class NodeFetch extends Fetch {
-    async call(url: string, options?: RequestInit): Promise<Response> {
-        const nodeFetch = (await import("node-fetch")).default;
-        // @ts-ignore
-        return nodeFetch(url, options);
+    async call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse> {
+        const nodeFetchModule = await import("node-fetch");
+        const nodeFetch = nodeFetchModule.default;
+
+        return nodeFetch(url, {
+            method: options?.method,
+            headers: options.headers as Record<string, string>,
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+        });
     }
 }

src/types/API.ts

@@ -1,9 +1,9 @@
 export type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
 
 export type APIResponseProps = {
-  response: Response;
+  response: UnifiedResponse;
   options: FinalRequestOptions;
-  controller: AbortController;
+  controller?: AbortController;
 };
 
 export type RequestOptions<
@@ -27,3 +27,4 @@ export type FinalRequestOptions = RequestOptions & {
 
 export type DefaultQuery = Record<string, unknown>;
 export type Headers = Record<string, string | null | undefined>;
+export type UnifiedResponse = Response | import('node-fetch').Response;

src/types/index.ts

@@ -34,4 +34,5 @@ export {
   type HTTPMethod,
   type DefaultQuery,
   type Headers,
+  type UnifiedResponse,
 } from './API';