@retab/node 1.0.96 → 1.0.99

package/dist/client.js

@@ -1,5 +1,22 @@
 import * as z from "zod";
 import * as crypto from "crypto";
+const PYTHON_PUBLIC_PREPARE_METHODS = {
+    APIModels: ["list"],
+    APISchemas: ["generate"],
+    APIExtractions: ["list", "download", "update", "get", "sources", "delete"],
+    APIFiles: ["upload", "list", "get", "get_download_link"],
+    APIProjects: ["create", "get", "list", "delete", "publish", "extract", "split"],
+    ProjectDatasets: ["create", "get", "list", "update", "delete", "duplicate", "add_document", "get_document", "list_documents", "update_document", "delete_document"],
+    ProjectIterations: ["create", "get", "list", "update_draft", "delete", "finalize", "get_schema", "process_documents", "get_document", "list_documents", "update_document", "delete_document", "get_metrics"],
+    APIWorkflows: ["get", "list", "create", "update", "delete", "publish", "duplicate", "get_entities"],
+    APIWorkflowBlocks: ["list", "get", "create", "create_batch", "update", "delete"],
+    APIWorkflowEdges: ["list", "get", "create", "create_batch", "delete", "delete_all"],
+    APIWorkflowRuns: ["create", "get", "list", "delete", "cancel", "restart", "resume"],
+    APIWorkflowRunSteps: ["get", "list", "get_many"],
+    APIEvalsExtract: ["process", "process_stream"],
+    APIEvalsSplit: ["process"],
+    APIEvalsClassify: ["process"],
+};
 async function* streamResponse(schema, response) {
     let body = "";
     let depth = 0;
@@ -57,7 +74,7 @@ export class AbstractClient {
         if (!bodyType) {
             return;
         }
-        if (response.headers.get("Content-Type") !== "application/json")
+        if (!response.headers.get("Content-Type")?.startsWith("application/json"))
             throw new APIError(response.status, "Response is not JSON");
         return bodyType.parseAsync(await response.json());
     }
@@ -66,7 +83,7 @@ export class AbstractClient {
         if (!response.ok) {
             throw new APIError(response.status, await response.text());
         }
-        if (response.headers.get("Content-Type") !== "application/stream+json")
+        if (!response.headers.get("Content-Type")?.startsWith("application/stream+json"))
             throw new APIError(response.status, "Response is not stream JSON");
         return streamResponse(schema, response);
     }
@@ -75,10 +92,66 @@ export class CompositionClient extends AbstractClient {
     constructor(client) {
         super();
         this._client = client;
+        this._installPrepareMethods();
     }
     _fetch(params) {
         return this._client["_fetch"](params);
     }
+    _installPrepareMethods() {
+        const allowedMethods = PYTHON_PUBLIC_PREPARE_METHODS[this.constructor.name] ?? [];
+        if (allowedMethods.length === 0) {
+            return;
+        }
+        for (const methodName of allowedMethods) {
+            const method = this[methodName];
+            const prepareMethodName = `prepare_${methodName}`;
+            if (typeof method !== "function" || prepareMethodName in this) {
+                continue;
+            }
+            Object.defineProperty(this, prepareMethodName, {
+                configurable: true,
+                enumerable: false,
+                writable: false,
+                value: (...args) => this._capturePreparedRequest(methodName, args),
+            });
+        }
+    }
+    async _capturePreparedRequest(methodName, args) {
+        let capturedRequest;
+        const self = this;
+        const originalFetch = self._fetch;
+        const originalFetchJson = self._fetchJson;
+        const originalFetchStream = self._fetchStream;
+        self._fetch = async (params) => {
+            capturedRequest = params;
+            return new Response("{}", {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+        };
+        self._fetchJson = async (...fetchArgs) => {
+            capturedRequest = (fetchArgs.length === 2 ? fetchArgs[1] : fetchArgs[0]);
+            return {};
+        };
+        self._fetchStream = async (...fetchArgs) => {
+            capturedRequest = fetchArgs[1];
+            return (async function* emptyStream() { })();
+        };
+        try {
+            await self[methodName](...args);
+        }
+        finally {
+            self._fetch = originalFetch;
+            self._fetchJson = originalFetchJson;
+            self._fetchStream = originalFetchStream;
+        }
+        if (!capturedRequest) {
+            throw new Error(`Unable to capture prepared request for ${methodName}`);
+        }
+        return capturedRequest;
+    }
 }
 export class APIError extends Error {
     constructor(status, info) {
@@ -116,7 +189,7 @@ export class FetcherClient extends AbstractClient {
         if (params.params) {
             query = "?" + new URLSearchParams(Object.fromEntries(Object.entries(params.params).filter(([_, v]) => v !== undefined))).toString();
         }
-        let url = (this.options.baseUrl || "https://api.retab.com") + params.url + query;
+        let url = (this.options.baseUrl || "https://api.retab.com/v1") + params.url + query;
         let headers = params.headers || {};
         let init = {
             method: params.method,
@@ -124,8 +197,9 @@ export class FetcherClient extends AbstractClient {
         if (params.method !== "GET") {
             if (params.bodyMime === "multipart/form-data") {
                 let formData = new FormData();
-                for (const key of Object.keys(params.body || {})) {
-                    let value = params.body[key];
+                const multipartBody = (params.body || {});
+                for (const key of Object.keys(multipartBody)) {
+                    let value = multipartBody[key];
                     if (Array.isArray(value)) {
                         for (const item of value) {
                             formData.append(key, item);