@planqk/planqk-service-sdk 1.9.1 → 2.1.0

package/dist/sdk/core/fetcher/stream-wrappers/UndiciStreamWrapper.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndiciStreamWrapper = void 0;
+class UndiciStreamWrapper {
+    readableStream;
+    reader;
+    events;
+    paused;
+    resumeCallback;
+    encoding;
+    constructor(readableStream) {
+        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;
+    }
+    on(event, callback) {
+        this.events[event]?.push(callback);
+    }
+    off(event, callback) {
+        this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+    }
+    pipe(dest) {
+        this.on("data", (chunk) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._write(chunk);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.write(chunk).then(() => writer.releaseLock());
+            }
+        });
+        this.on("end", () => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._end();
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.close();
+            }
+        });
+        this.on("error", (error) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._error(error);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.abort(error);
+            }
+        });
+        this._startReading();
+        return dest;
+    }
+    pipeTo(dest) {
+        return this.pipe(dest);
+    }
+    unpipe(dest) {
+        this.off("data", (chunk) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._write(chunk);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.write(chunk).then(() => writer.releaseLock());
+            }
+        });
+        this.off("end", () => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._end();
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.close();
+            }
+        });
+        this.off("error", (error) => {
+            if (dest instanceof UndiciStreamWrapper) {
+                dest._error(error);
+            }
+            else {
+                const writer = dest.getWriter();
+                writer.abort(error);
+            }
+        });
+    }
+    destroy(error) {
+        this.reader
+            .cancel(error)
+            .then(() => {
+            this._emit("close");
+        })
+            .catch((err) => {
+            this._emit("error", err);
+        });
+    }
+    pause() {
+        this.paused = true;
+        this._emit("pause");
+    }
+    resume() {
+        if (this.paused) {
+            this.paused = false;
+            this._emit("resume");
+            if (this.resumeCallback) {
+                this.resumeCallback();
+                this.resumeCallback = null;
+            }
+        }
+    }
+    get isPaused() {
+        return this.paused;
+    }
+    async read() {
+        if (this.paused) {
+            await new Promise((resolve) => {
+                this.resumeCallback = resolve;
+            });
+        }
+        const { done, value } = await this.reader.read();
+        if (done) {
+            return undefined;
+        }
+        return value;
+    }
+    setEncoding(encoding) {
+        this.encoding = encoding;
+    }
+    async text() {
+        const chunks = [];
+        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());
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    _write(chunk) {
+        this._emit("data", chunk);
+    }
+    _end() {
+        this._emit("end");
+    }
+    _error(error) {
+        this._emit("error", error);
+    }
+    _emit(event, data) {
+        if (this.events[event]) {
+            for (const callback of this.events[event] || []) {
+                callback(data);
+            }
+        }
+    }
+    async _startReading() {
+        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]() {
+        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;
+            },
+        };
+    }
+}
+exports.UndiciStreamWrapper = UndiciStreamWrapper;

package/dist/sdk/core/fetcher/stream-wrappers/chooseStreamWrapper.d.ts

@@ -0,0 +1,18 @@
+export type EventCallback = (data?: any) => void;
+export interface StreamWrapper<WritableStream, ReadFormat> {
+    setEncoding(encoding?: string): void;
+    on(event: string, callback: EventCallback): void;
+    off(event: string, callback: EventCallback): void;
+    pipe(dest: WritableStream): WritableStream;
+    pipeTo(dest: WritableStream): WritableStream;
+    unpipe(dest?: WritableStream): void;
+    destroy(error?: Error): void;
+    pause(): void;
+    resume(): void;
+    get isPaused(): boolean;
+    read(): Promise<ReadFormat | undefined>;
+    text(): Promise<string>;
+    json<T>(): Promise<T>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<ReadFormat>;
+}
+export declare function chooseStreamWrapper(responseBody: any): Promise<Promise<StreamWrapper<any, any>>>;

package/dist/sdk/core/fetcher/stream-wrappers/chooseStreamWrapper.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseStreamWrapper = chooseStreamWrapper;
+const runtime_1 = require("../../runtime");
+async function chooseStreamWrapper(responseBody) {
+    if (runtime_1.RUNTIME.type === "node" && runtime_1.RUNTIME.parsedVersion != null && runtime_1.RUNTIME.parsedVersion >= 18) {
+        return new (await Promise.resolve().then(() => __importStar(require("./Node18UniversalStreamWrapper")))).Node18UniversalStreamWrapper(responseBody);
+    }
+    else if (runtime_1.RUNTIME.type !== "node" && typeof fetch == "function") {
+        return new (await Promise.resolve().then(() => __importStar(require("./UndiciStreamWrapper")))).UndiciStreamWrapper(responseBody);
+    }
+    else {
+        return new (await Promise.resolve().then(() => __importStar(require("./NodePre18StreamWrapper")))).NodePre18StreamWrapper(responseBody);
+    }
+}

package/dist/sdk/core/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./fetcher";
 export * from "./auth";
+export * from "./runtime";

package/dist/sdk/core/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./fetcher"), exports);
 __exportStar(require("./auth"), exports);
+__exportStar(require("./runtime"), exports);

package/dist/sdk/core/runtime/index.d.ts

@@ -0,0 +1 @@
+export { RUNTIME } from "./runtime";

package/dist/sdk/core/runtime/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME = void 0;
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "RUNTIME", { enumerable: true, get: function () { return runtime_1.RUNTIME; } });

package/dist/sdk/core/runtime/runtime.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export declare const RUNTIME: Runtime;
+export interface Runtime {
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd";
+    version?: string;
+    parsedVersion?: number;
+}

package/dist/sdk/core/runtime/runtime.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME = void 0;
+/**
+ * A constant that indicates whether the environment the code is running is a Web Browser.
+ */
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+/**
+ * A constant that indicates whether the environment the code is running is a Web Worker.
+ */
+const isWebWorker = typeof self === "object" &&
+    // @ts-ignore
+    typeof self?.importScripts === "function" &&
+    (self.constructor?.name === "DedicatedWorkerGlobalScope" ||
+        self.constructor?.name === "ServiceWorkerGlobalScope" ||
+        self.constructor?.name === "SharedWorkerGlobalScope");
+/**
+ * A constant that indicates whether the environment the code is running is Deno.
+ */
+const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+/**
+ * A constant that indicates whether the environment the code is running is Bun.sh.
+ */
+const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+/**
+ * A constant that indicates whether the environment the code is running is Node.JS.
+ */
+const isNode = typeof process !== "undefined" &&
+    Boolean(process.version) &&
+    Boolean(process.versions?.node) &&
+    // Deno spoofs process.versions.node, see https://deno.land/std@0.177.0/node/process.ts?s=versions
+    !isDeno &&
+    !isBun;
+/**
+ * A constant that indicates whether the environment the code is running is in React-Native.
+ * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
+ */
+const isReactNative = typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+/**
+ * A constant that indicates whether the environment the code is running is Cloudflare.
+ * https://developers.cloudflare.com/workers/runtime-apis/web-standards/#navigatoruseragent
+ */
+const isCloudflare = typeof globalThis !== "undefined" && globalThis?.navigator?.userAgent === "Cloudflare-Workers";
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+exports.RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+    if (isBrowser) {
+        return {
+            type: "browser",
+            version: window.navigator.userAgent,
+        };
+    }
+    if (isCloudflare) {
+        return {
+            type: "workerd",
+        };
+    }
+    if (isWebWorker) {
+        return {
+            type: "web-worker",
+        };
+    }
+    if (isDeno) {
+        return {
+            type: "deno",
+            version: Deno.version.deno,
+        };
+    }
+    if (isBun) {
+        return {
+            type: "bun",
+            version: Bun.version,
+        };
+    }
+    if (isNode) {
+        return {
+            type: "node",
+            version: process.versions.node,
+            parsedVersion: Number(process.versions.node.split(".")[0]),
+        };
+    }
+    if (isReactNative) {
+        return {
+            type: "react-native",
+        };
+    }
+    return {
+        type: "unknown",
+    };
+}

package/dist/sdk/errors/PlanqkServiceApiError.js

@@ -5,6 +5,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlanqkServiceApiError = void 0;
 class PlanqkServiceApiError extends Error {
+    statusCode;
+    body;
     constructor({ message, statusCode, body }) {
         super(buildMessage({ message, statusCode, body }));
         Object.setPrototypeOf(this, PlanqkServiceApiError.prototype);

package/dist/sdk/index.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlanqkServiceApiTimeoutError = exports.PlanqkServiceApiError = exports.PlanqkServiceApiEnvironment = exports.PlanqkServiceApiClient = exports.PlanqkServiceApi = void 0;
 exports.PlanqkServiceApi = __importStar(require("./api"));

package/eslint.config.mjs

@@ -0,0 +1,11 @@
+import eslint from "@eslint/js";
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  tseslint.configs.recommended,
+  tseslint.configs.stylistic,
+  {
+    ignores: ["dist", "src/sdk", "generated"]
+  },
+);

package/fern/fern.config.json

@@ -0,0 +1,4 @@
+{
+  "organization": "planqk-service",
+  "version": "0.56.17"
+}

package/fern/generators.yml

@@ -0,0 +1,25 @@
+# yaml-language-server: $schema=https://schema.buildwithfern.dev/generators-yml.json
+api:
+  specs:
+    - openapi: openapi/openapi.yml
+default-group: local
+groups:
+  local:
+    generators:
+      - name: fernapi/fern-typescript-node-sdk
+        version: 0.39.3
+        output:
+          location: local-file-system
+          path: ../generated/typescript
+        config:
+          outputSourceFiles: true
+          includeCredentialsOnCrossOriginRequests: true
+          treatUnknownAsAny: true
+          skipResponseValidation: true
+          noSerdeLayer: true
+      - name: fernapi/fern-python-sdk
+        version: 4.3.16
+        output:
+          location: local-file-system
+          path: ../generated/python
+        config: {}