fix: Quality fixes

Author: asafgardin

src/APIClient.ts

@@ -1,9 +1,15 @@
 import { AI21Error } from './errors';
 import { VERSION } from './version';
 
-import { RequestOptions, FinalRequestOptions, APIResponseProps, HTTPMethod, Headers, UnifiedResponse } from './types';
+import {
+  RequestOptions,
+  FinalRequestOptions,
+  APIResponseProps,
+  HTTPMethod,
+  Headers,
+  UnifiedResponse,
+} from './types';
 import { AI21EnvConfig } from './EnvConfig';
-import { handleAPIResponse } from './ResponseHandler';
 import { createFetchInstance } from 'envFetch';
 import { Fetch } from 'fetch';
 

src/ResponseHandler.ts

@@ -21,40 +21,39 @@ abstract class BaseSSEDecoder implements SSEDecoder {
   abstract iterLines(response: UnifiedResponse): AsyncIterableIterator<string>;
 
   async *_iterLines(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncIterableIterator<string> {
-    
-      let buffer = '';
-  
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-  
-          if (done) {
-            if (buffer.length > 0) {
-              const decoded = this.decode(buffer.trim());
-              if (decoded) yield decoded;
-            }
-            break;
-          }
-  
-          buffer += new TextDecoder().decode(value);
-          const lines = buffer.split('\n');
-          buffer = lines.pop() || '';
-  
-          for (const line of lines) {
-            const decoded = this.decode(line.trim());
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          if (buffer.length > 0) {
+            const decoded = this.decode(buffer.trim());
             if (decoded) yield decoded;
           }
+          break;
+        }
+
+        buffer += new TextDecoder().decode(value);
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          const decoded = this.decode(line.trim());
+          if (decoded) yield decoded;
         }
-      } finally {
-        reader.releaseLock();
       }
+    } finally {
+      reader.releaseLock();
+    }
   }
 }
 
 export class BrowserSSEDecoder extends BaseSSEDecoder {
   async *iterLines(response: UnifiedResponse): AsyncIterableIterator<string> {
     if (!response.body) {
-        throw new Error('Response body is null');
+      throw new Error('Response body is null');
     }
 
     const body = response.body as ReadableStream<Uint8Array>;
@@ -63,9 +62,10 @@ export class BrowserSSEDecoder extends BaseSSEDecoder {
 }
 
 export class NodeSSEDecoder extends BaseSSEDecoder {
-    async *iterLines(response: UnifiedResponse): AsyncIterableIterator<string> {
-        const readerStream = (await import("stream/web")).ReadableStream as any;
-        const reader = readerStream.from(response.body).getReader();
-        yield* this._iterLines(reader);
-    }
+  async *iterLines(response: UnifiedResponse): AsyncIterableIterator<string> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const readerStream = (await import('stream/web')).ReadableStream as any;
+    const reader = readerStream.from(response.body).getReader();
+    yield* this._iterLines(reader);
+  }
 }

src/Streaming/SSEDecoder.ts

@@ -1,20 +1,20 @@
 import { BrowserFetch, Fetch, NodeFetch } from 'fetch';
 
-export const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+export const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 export const isWebWorker =
-    typeof self === "object" &&
-    typeof self?.importScripts === "function" &&
-    (self.constructor?.name === "DedicatedWorkerGlobalScope" ||
-        self.constructor?.name === "ServiceWorkerGlobalScope" ||
-        self.constructor?.name === "SharedWorkerGlobalScope");
+  typeof self === 'object' &&
+  typeof self?.importScripts === 'function' &&
+  (self.constructor?.name === 'DedicatedWorkerGlobalScope' ||
+    self.constructor?.name === 'ServiceWorkerGlobalScope' ||
+    self.constructor?.name === 'SharedWorkerGlobalScope');
 
-
-export const isNode = typeof process !== "undefined" && Boolean(process.version) && Boolean(process.versions?.node);
+export const isNode =
+  typeof process !== 'undefined' && Boolean(process.version) && Boolean(process.versions?.node);
 
 export function createFetchInstance(): Fetch {
-    if (isBrowser || isWebWorker) {
-        return new BrowserFetch();
-    } else {
-        return new NodeFetch();
-    }
-}
+  if (isBrowser || isWebWorker) {
+    return new BrowserFetch();
+  } else {
+    return new NodeFetch();
+  }
+}

src/envFetch.ts

@@ -1,29 +1,25 @@
-import { AI21Error } from "errors";
-import { Stream } from "Streaming";
-import { FinalRequestOptions, UnifiedResponse } from "types";
-import { APIResponseProps, UnifiedReadableStream } from "types/API";
-
+import { AI21Error } from 'errors';
+import { Stream } from 'Streaming';
+import { FinalRequestOptions, UnifiedResponse } from 'types';
+import { APIResponseProps } from 'types/API';
 
 export type APIResponse<T> = {
-    data?: T;
-    response: UnifiedResponse;
-  };
+  data?: T;
+  response: UnifiedResponse;
+};
 export abstract class Fetch {
-    abstract call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse>;
-    async handleResponse<T>({
-        response,
-        options
-    }: APIResponseProps) {
-        if (options.stream) {
-            if (!response.body) {
-              throw new AI21Error('Response body is null');
-            }
-            
-            return this.handleStream<T>(response);
-        }
+  abstract call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse>;
+  async handleResponse<T>({ response, options }: APIResponseProps) {
+    if (options.stream) {
+      if (!response.body) {
+        throw new AI21Error('Response body is null');
+      }
 
-        const contentType = response.headers.get('content-type');
-        return contentType?.includes('application/json') ? await response.json() : null;
+      return this.handleStream<T>(response);
     }
-    abstract handleStream<T>(response: UnifiedResponse): Stream<T>;
+
+    const contentType = response.headers.get('content-type');
+    return contentType?.includes('application/json') ? await response.json() : null;
+  }
+  abstract handleStream<T>(response: UnifiedResponse): Stream<T>;
 }

src/fetch/BaseFetch.ts

@@ -4,18 +4,18 @@ import { Stream } from 'Streaming';
 import { BrowserSSEDecoder } from 'Streaming/SSEDecoder';
 
 export class BrowserFetch extends Fetch {
-    call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse> {
-        const controller = new AbortController();
+  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,
-        });
-    }
+    return fetch(url, {
+      method: options?.method,
+      headers: options?.headers as HeadersInit,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: controller.signal,
+    });
+  }
 
-    handleStream<T>(response: UnifiedResponse): Stream<T> {
-        return new Stream<T>(response as Response, new BrowserSSEDecoder());
-    }
+  handleStream<T>(response: UnifiedResponse): Stream<T> {
+    return new Stream<T>(response as Response, new BrowserSSEDecoder());
+  }
 }

src/fetch/BrowserFetch.ts

@@ -1,22 +1,22 @@
-import { FinalRequestOptions, UnifiedResponse } from "types";
-import { Fetch } from "./BaseFetch";
-import { NodeSSEDecoder } from "Streaming/SSEDecoder";
-import { Stream } from "Streaming";
+import { FinalRequestOptions, UnifiedResponse } from 'types';
+import { Fetch } from './BaseFetch';
+import { NodeSSEDecoder } from 'Streaming/SSEDecoder';
+import { Stream } from 'Streaming';
 
 export class NodeFetch extends Fetch {
-    async call(url: string, options: FinalRequestOptions): Promise<UnifiedResponse> {
-        const nodeFetchModule = await import("node-fetch");
-        const nodeFetch = nodeFetchModule.default;
+  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,
-        });
-    }
+    return nodeFetch(url, {
+      method: options?.method,
+      headers: options.headers as Record<string, string>,
+      body: options?.body ? JSON.stringify(options.body) : undefined,
+    });
+  }
 
-    handleStream<T>(response: UnifiedResponse): Stream<T> {
-        type NodeRespose = import('node-fetch').Response
-        return new Stream<T>(response as NodeRespose, new NodeSSEDecoder());
-    }
+  handleStream<T>(response: UnifiedResponse): Stream<T> {
+    type NodeRespose = import('node-fetch').Response;
+    return new Stream<T>(response as NodeRespose, new NodeSSEDecoder());
+  }
 }

src/fetch/NodeFetch.ts

@@ -1,14 +1,12 @@
 export type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
 
 export type APIResponseProps = {
-  response: UnifiedResponse;
+  response: CrossPlatformResponse;
   options: FinalRequestOptions;
   controller?: AbortController;
 };
 
-export type RequestOptions<
-  Req = unknown | Record<string, unknown> | ArrayBufferView | ArrayBuffer,
-> = {
+export type RequestOptions<Req = unknown | Record<string, unknown> | ArrayBufferView | ArrayBuffer> = {
   method?: HTTPMethod;
   path?: string;
   query?: Req | undefined;
@@ -27,5 +25,5 @@ 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;
-export type UnifiedReadableStream = ReadableStream<Uint8Array> | import('stream/web').ReadableStream;
+export type CrossPlatformResponse = Response | import('node-fetch').Response;
+export type CrossPlatformReadableStream = ReadableStream<Uint8Array> | import('stream/web').ReadableStream;

src/types/API.ts

@@ -34,7 +34,7 @@ export {
   type HTTPMethod,
   type DefaultQuery,
   type Headers,
-  type UnifiedResponse,
+  type CrossPlatformResponse as UnifiedResponse,
 } from './API';
 
 export {