@planqk/planqk-service-sdk 1.9.1 → 2.1.1

package/src/sdk/core/fetcher/Fetcher.ts

@@ -1,6 +1,10 @@
-import axios, { AxiosAdapter, AxiosError, AxiosResponse } from "axios";
-import qs from "qs";
 import { APIResponse } from "./APIResponse";
+import { createRequestUrl } from "./createRequestUrl";
+import { getFetchFn } from "./getFetchFn";
+import { getRequestBody } from "./getRequestBody";
+import { getResponseBody } from "./getResponseBody";
+import { makeRequest } from "./makeRequest";
+import { requestWithRetries } from "./requestWithRetries";
 
 export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 
@@ -10,14 +14,15 @@ export declare namespace Fetcher {
         method: string;
         contentType?: string;
         headers?: Record<string, string | undefined>;
-        queryParameters?: Record<string, string | string[]>;
+        queryParameters?: Record<string, string | string[] | object | object[]>;
         body?: unknown;
         timeoutMs?: number;
         maxRetries?: number;
         withCredentials?: boolean;
-        responseType?: "json" | "blob";
-        adapter?: AxiosAdapter;
-        onUploadProgress?: (event: ProgressEvent) => void;
+        abortSignal?: AbortSignal;
+        requestType?: "json" | "file" | "bytes";
+        responseType?: "json" | "blob" | "sse" | "streaming" | "text";
+        duplex?: "half";
     }
 
     export type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
@@ -44,11 +49,7 @@ export declare namespace Fetcher {
     }
 }
 
-const INITIAL_RETRY_DELAY = 1;
-const MAX_RETRY_DELAY = 60;
-const DEFAULT_MAX_RETRIES = 2;
-
-async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse<R, Fetcher.Error>> {
+export async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse<R, Fetcher.Error>> {
     const headers: Record<string, string> = {};
     if (args.body !== undefined && args.contentType != null) {
         headers["Content-Type"] = args.contentType;
@@ -62,70 +63,36 @@ async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse
         }
     }
 
-    const makeRequest = async (): Promise<AxiosResponse> =>
-        await axios({
-            url: args.url,
-            params: args.queryParameters,
-            paramsSerializer: (params) => {
-                return qs.stringify(params, { arrayFormat: "repeat" });
-            },
-            method: args.method,
-            headers,
-            data: args.body,
-            validateStatus: () => true,
-            transformResponse: (response) => response,
-            timeout: args.timeoutMs,
-            transitional: {
-                clarifyTimeoutError: true,
-            },
-            withCredentials: args.withCredentials,
-            adapter: args.adapter,
-            onUploadProgress: args.onUploadProgress,
-            maxBodyLength: Infinity,
-            maxContentLength: Infinity,
-            responseType: args.responseType ?? "json",
-        });
+    const url = createRequestUrl(args.url, args.queryParameters);
+    let requestBody: BodyInit | undefined = await getRequestBody({
+        body: args.body,
+        type: args.requestType === "json" ? "json" : "other",
+    });
+    const fetchFn = await getFetchFn();
 
     try {
-        let response = await makeRequest();
-
-        for (let i = 0; i < (args.maxRetries ?? DEFAULT_MAX_RETRIES); ++i) {
-            if (
-                response.status === 408 ||
-                response.status === 409 ||
-                response.status === 429 ||
-                response.status >= 500
-            ) {
-                const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(i, 2), MAX_RETRY_DELAY);
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                response = await makeRequest();
-            } else {
-                break;
-            }
-        }
-
-        let body: unknown;
-        if (args.responseType === "blob") {
-            body = response.data;
-        } else if (response.data != null && response.data.length > 0) {
-            try {
-                body = JSON.parse(response.data) ?? undefined;
-            } catch {
-                return {
-                    ok: false,
-                    error: {
-                        reason: "non-json",
-                        statusCode: response.status,
-                        rawBody: response.data,
-                    },
-                };
-            }
-        }
+        const response = await requestWithRetries(
+            async () =>
+                makeRequest(
+                    fetchFn,
+                    url,
+                    args.method,
+                    headers,
+                    requestBody,
+                    args.timeoutMs,
+                    args.abortSignal,
+                    args.withCredentials,
+                    args.duplex
+                ),
+            args.maxRetries
+        );
+        let responseBody = await getResponseBody(response, args.responseType);
 
         if (response.status >= 200 && response.status < 400) {
             return {
                 ok: true,
-                body: body as R,
+                body: responseBody as R,
+                headers: response.headers,
             };
         } else {
             return {
@@ -133,25 +100,41 @@ async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse
                 error: {
                     reason: "status-code",
                     statusCode: response.status,
-                    body,
+                    body: responseBody,
                 },
             };
         }
     } catch (error) {
-        if ((error as AxiosError).code === "ETIMEDOUT") {
+        if (args.abortSignal != null && args.abortSignal.aborted) {
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: "The user aborted a request",
+                },
+            };
+        } else if (error instanceof Error && error.name === "AbortError") {
             return {
                 ok: false,
                 error: {
                     reason: "timeout",
                 },
             };
+        } else if (error instanceof Error) {
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: error.message,
+                },
+            };
         }
 
         return {
             ok: false,
             error: {
                 reason: "unknown",
-                errorMessage: (error as AxiosError).message,
+                errorMessage: JSON.stringify(error),
             },
         };
     }

package/src/sdk/core/fetcher/createRequestUrl.ts

@@ -0,0 +1,10 @@
+import qs from "qs";
+
+export function createRequestUrl(
+    baseUrl: string,
+    queryParameters?: Record<string, string | string[] | object | object[]>
+): string {
+    return Object.keys(queryParameters ?? {}).length > 0
+        ? `${baseUrl}?${qs.stringify(queryParameters, { arrayFormat: "repeat" })}`
+        : baseUrl;
+}

package/src/sdk/core/fetcher/getFetchFn.ts

@@ -0,0 +1,25 @@
+import { RUNTIME } from "../runtime";
+
+/**
+ * Returns a fetch function based on the runtime
+ */
+export async function getFetchFn(): Promise<any> {
+    // In Node.js 18+ environments, use native fetch
+    if (RUNTIME.type === "node" && RUNTIME.parsedVersion != null && RUNTIME.parsedVersion >= 18) {
+        return fetch;
+    }
+
+    // In Node.js 18 or lower environments, the SDK always uses`node-fetch`.
+    if (RUNTIME.type === "node") {
+        return (await import("node-fetch")).default as any;
+    }
+
+    // Otherwise the SDK uses global fetch if available,
+    // and falls back to node-fetch.
+    if (typeof fetch == "function") {
+        return fetch;
+    }
+
+    // Defaults to node `node-fetch` if global fetch isn't available
+    return (await import("node-fetch")).default as any;
+}

package/src/sdk/core/fetcher/getHeader.ts

@@ -0,0 +1,8 @@
+export function getHeader(headers: Record<string, any>, header: string): string | undefined {
+    for (const [headerKey, headerValue] of Object.entries(headers)) {
+        if (headerKey.toLowerCase() === header.toLowerCase()) {
+            return headerValue;
+        }
+    }
+    return undefined;
+}

package/src/sdk/core/fetcher/getRequestBody.ts

@@ -0,0 +1,14 @@
+export declare namespace GetRequestBody {
+    interface Args {
+        body: unknown;
+        type: "json" | "file" | "bytes" | "other";
+    }
+}
+
+export async function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined> {
+    if (type.includes("json")) {
+        return JSON.stringify(body);
+    } else {
+        return body as BodyInit;
+    }
+}

package/src/sdk/core/fetcher/getResponseBody.ts

@@ -0,0 +1,32 @@
+import { chooseStreamWrapper } from "./stream-wrappers/chooseStreamWrapper";
+
+export async function getResponseBody(response: Response, responseType?: string): Promise<unknown> {
+    if (response.body != null && responseType === "blob") {
+        return await response.blob();
+    } else if (response.body != null && responseType === "sse") {
+        return response.body;
+    } else if (response.body != null && responseType === "streaming") {
+        return chooseStreamWrapper(response.body);
+    } else if (response.body != null && responseType === "text") {
+        return await response.text();
+    } else {
+        const text = await response.text();
+        if (text.length > 0) {
+            try {
+                let responseBody = JSON.parse(text);
+                return responseBody;
+            } catch (err) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "non-json",
+                        statusCode: response.status,
+                        rawBody: text,
+                    },
+                };
+            }
+        } else {
+            return undefined;
+        }
+    }
+}

package/src/sdk/core/fetcher/index.ts

@@ -1,4 +1,5 @@
 export type { APIResponse } from "./APIResponse";
 export { fetcher } from "./Fetcher";
 export type { Fetcher, FetchFunction } from "./Fetcher";
+export { getHeader } from "./getHeader";
 export { Supplier } from "./Supplier";

package/src/sdk/core/fetcher/makeRequest.ts

@@ -0,0 +1,44 @@
+import { anySignal, getTimeoutSignal } from "./signals";
+
+export const makeRequest = async (
+    fetchFn: (url: string, init: RequestInit) => Promise<Response>,
+    url: string,
+    method: string,
+    headers: Record<string, string>,
+    requestBody: BodyInit | undefined,
+    timeoutMs?: number,
+    abortSignal?: AbortSignal,
+    withCredentials?: boolean,
+    duplex?: "half"
+): Promise<Response> => {
+    const signals: AbortSignal[] = [];
+
+    // Add timeout signal
+    let timeoutAbortId: NodeJS.Timeout | undefined = undefined;
+    if (timeoutMs != null) {
+        const { signal, abortId } = getTimeoutSignal(timeoutMs);
+        timeoutAbortId = abortId;
+        signals.push(signal);
+    }
+
+    // Add arbitrary signal
+    if (abortSignal != null) {
+        signals.push(abortSignal);
+    }
+    let newSignals = anySignal(signals);
+    const response = await fetchFn(url, {
+        method: method,
+        headers,
+        body: requestBody,
+        signal: newSignals,
+        credentials: withCredentials ? "include" : undefined,
+        // @ts-ignore
+        duplex,
+    });
+
+    if (timeoutAbortId != null) {
+        clearTimeout(timeoutAbortId);
+    }
+
+    return response;
+};

package/src/sdk/core/fetcher/requestWithRetries.ts

@@ -0,0 +1,21 @@
+const INITIAL_RETRY_DELAY = 1;
+const MAX_RETRY_DELAY = 60;
+const DEFAULT_MAX_RETRIES = 2;
+
+export async function requestWithRetries(
+    requestFn: () => Promise<Response>,
+    maxRetries: number = DEFAULT_MAX_RETRIES
+): Promise<Response> {
+    let response: Response = await requestFn();
+
+    for (let i = 0; i < maxRetries; ++i) {
+        if ([408, 409, 429].includes(response.status) || response.status >= 500) {
+            const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(2, i), MAX_RETRY_DELAY);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            response = await requestFn();
+        } else {
+            break;
+        }
+    }
+    return response!;
+}

package/src/sdk/core/fetcher/signals.ts

@@ -0,0 +1,38 @@
+const TIMEOUT = "timeout";
+
+export function getTimeoutSignal(timeoutMs: number): { signal: AbortSignal; abortId: NodeJS.Timeout } {
+    const controller = new AbortController();
+    const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+    return { signal: controller.signal, abortId };
+}
+
+/**
+ * Returns an abort signal that is getting aborted when
+ * at least one of the specified abort signals is aborted.
+ *
+ * Requires at least node.js 18.
+ */
+export function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal {
+    // Allowing signals to be passed either as array
+    // of signals or as multiple arguments.
+    const signals = <AbortSignal[]>(args.length === 1 && Array.isArray(args[0]) ? args[0] : args);
+
+    const controller = new AbortController();
+
+    for (const signal of signals) {
+        if (signal.aborted) {
+            // Exiting early if one of the signals
+            // is already aborted.
+            controller.abort((signal as any)?.reason);
+            break;
+        }
+
+        // Listening for signals and removing the listeners
+        // when at least one symbol is aborted.
+        signal.addEventListener("abort", () => controller.abort((signal as any)?.reason), {
+            signal: controller.signal,
+        });
+    }
+
+    return controller.signal;
+}

package/src/sdk/core/fetcher/stream-wrappers/Node18UniversalStreamWrapper.ts

@@ -0,0 +1,252 @@
+import type { Writable } from "stream";
+import { EventCallback, StreamWrapper } from "./chooseStreamWrapper";
+
+export class Node18UniversalStreamWrapper<ReadFormat extends Uint8Array | Uint16Array | Uint32Array>
+    implements
+        StreamWrapper<Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat>, ReadFormat>
+{
+    private readableStream: ReadableStream<ReadFormat>;
+    private reader: ReadableStreamDefaultReader<ReadFormat>;
+    private events: Record<string, EventCallback[] | undefined>;
+    private paused: boolean;
+    private resumeCallback: ((value?: unknown) => void) | null;
+    private encoding: string | null;
+
+    constructor(readableStream: ReadableStream<ReadFormat>) {
+        this.readableStream = readableStream;
+        this.reader = this.readableStream.getReader();
+        this.events = {
+            data: [],
+            end: [],
+            error: [],
+            readable: [],
+            close: [],
+            pause: [],
+            resume: [],
+        };
+        this.paused = false;
+        this.resumeCallback = null;
+        this.encoding = null;
+    }
+
+    public on(event: string, callback: EventCallback): void {
+        this.events[event]?.push(callback);
+    }
+
+    public off(event: string, callback: EventCallback): void {
+        this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+    }
+
+    public pipe(
+        dest: Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat>
+    ): Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat> {
+        this.on("data", async (chunk) => {
+            if (dest instanceof Node18UniversalStreamWrapper) {
+                dest._write(chunk);
+            } else if (dest instanceof WritableStream) {
+                const writer = dest.getWriter();
+                writer.write(chunk).then(() => writer.releaseLock());
+            } else {
+                dest.write(chunk);
+            }
+        });
+
+        this.on("end", async () => {
+            if (dest instanceof Node18UniversalStreamWrapper) {
+                dest._end();
+            } else if (dest instanceof WritableStream) {
+                const writer = dest.getWriter();
+                writer.close();
+            } else {
+                dest.end();
+            }
+        });
+
+        this.on("error", async (error) => {
+            if (dest instanceof Node18UniversalStreamWrapper) {
+                dest._error(error);
+            } else if (dest instanceof WritableStream) {
+                const writer = dest.getWriter();
+                writer.abort(error);
+            } else {
+                dest.destroy(error);
+            }
+        });
+
+        this._startReading();
+
+        return dest;
+    }
+
+    public pipeTo(
+        dest: Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat>
+    ): Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat> {
+        return this.pipe(dest);
+    }
+
+    public unpipe(dest: Node18UniversalStreamWrapper<ReadFormat> | Writable | WritableStream<ReadFormat>): void {
+        this.off("data", async (chunk) => {
+            if (dest instanceof Node18UniversalStreamWrapper) {
+                dest._write(chunk);
+            } else if (dest instanceof WritableStream) {
+                const writer = dest.getWriter();
+                writer.write(chunk).then(() => writer.releaseLock());
+            } else {
+                dest.write(chunk);
+            }
+        });
+
+        this.off("end", async () => {
+            if (dest instanceof Node18UniversalStreamWrapper) {
+                dest._end();
+            } else if (dest instanceof WritableStream) {
+                const writer = dest.getWriter();
+                writer.close();
+            } else {
+                dest.end();
+            }
+        });
+
+        this.off("error", async (error) => {
+            if (dest instanceof Node18UniversalStreamWrapper) {
+                dest._error(error);
+            } else if (dest instanceof WritableStream) {
+                const writer = dest.getWriter();
+                writer.abort(error);
+            } else {
+                dest.destroy(error);
+            }
+        });
+    }
+
+    public destroy(error?: Error): void {
+        this.reader
+            .cancel(error)
+            .then(() => {
+                this._emit("close");
+            })
+            .catch((err) => {
+                this._emit("error", err);
+            });
+    }
+
+    public pause(): void {
+        this.paused = true;
+        this._emit("pause");
+    }
+
+    public resume(): void {
+        if (this.paused) {
+            this.paused = false;
+            this._emit("resume");
+            if (this.resumeCallback) {
+                this.resumeCallback();
+                this.resumeCallback = null;
+            }
+        }
+    }
+
+    public get isPaused(): boolean {
+        return this.paused;
+    }
+
+    public async read(): Promise<ReadFormat | undefined> {
+        if (this.paused) {
+            await new Promise((resolve) => {
+                this.resumeCallback = resolve;
+            });
+        }
+        const { done, value } = await this.reader.read();
+
+        if (done) {
+            return undefined;
+        }
+        return value;
+    }
+
+    public setEncoding(encoding: string): void {
+        this.encoding = encoding;
+    }
+
+    public async text(): Promise<string> {
+        const chunks: ReadFormat[] = [];
+
+        while (true) {
+            const { done, value } = await this.reader.read();
+            if (done) break;
+            if (value) chunks.push(value);
+        }
+
+        const decoder = new TextDecoder(this.encoding || "utf-8");
+        return decoder.decode(await new Blob(chunks).arrayBuffer());
+    }
+
+    public async json<T>(): Promise<T> {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+
+    private _write(chunk: ReadFormat): void {
+        this._emit("data", chunk);
+    }
+
+    private _end(): void {
+        this._emit("end");
+    }
+
+    private _error(error: any): void {
+        this._emit("error", error);
+    }
+
+    private _emit(event: string, data?: any): void {
+        if (this.events[event]) {
+            for (const callback of this.events[event] || []) {
+                callback(data);
+            }
+        }
+    }
+
+    private async _startReading(): Promise<void> {
+        try {
+            this._emit("readable");
+            while (true) {
+                if (this.paused) {
+                    await new Promise((resolve) => {
+                        this.resumeCallback = resolve;
+                    });
+                }
+                const { done, value } = await this.reader.read();
+                if (done) {
+                    this._emit("end");
+                    this._emit("close");
+                    break;
+                }
+                if (value) {
+                    this._emit("data", value);
+                }
+            }
+        } catch (error) {
+            this._emit("error", error);
+        }
+    }
+
+    [Symbol.asyncIterator](): AsyncIterableIterator<ReadFormat> {
+        return {
+            next: async () => {
+                if (this.paused) {
+                    await new Promise((resolve) => {
+                        this.resumeCallback = resolve;
+                    });
+                }
+                const { done, value } = await this.reader.read();
+                if (done) {
+                    return { done: true, value: undefined };
+                }
+                return { done: false, value };
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
+}