@captapi/sdk 0.1.0 → 0.3.0

package/dist/core.d.ts

@@ -29,5 +29,13 @@ export declare class HttpCore {
     private readonly timeoutMs;
     private readonly fetchImpl;
     constructor(options?: CaptapiOptions);
+    private fail;
+    private parseBody;
+    private send;
     get(path: string, params?: object): Promise<ApiEnvelope>;
+    /**
+     * POST multipart/form-data. ``file`` may be a local path (Node), Blob, or File.
+     * Other params become additional form fields.
+     */
+    postMultipart(path: string, params?: object): Promise<ApiEnvelope>;
 }

package/dist/core.js

@@ -13,6 +13,27 @@ export class CaptapiError extends Error {
         this.detail = detail;
     }
 }
+const RETRY_STATUSES = new Set([502, 503]);
+const RETRY_DELAY_MS = 500;
+function errorBag(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const root = body;
+    if (root.error && typeof root.error === "object") {
+        return root.error;
+    }
+    if (root.detail && typeof root.detail === "object") {
+        return root.detail;
+    }
+    return root;
+}
+function shouldRetry(status, body) {
+    const bag = errorBag(body);
+    if (bag && typeof bag.retryable === "boolean") {
+        return bag.retryable === true;
+    }
+    return RETRY_STATUSES.has(status);
+}
 export class HttpCore {
     apiKey;
     baseUrl;
@@ -29,39 +50,97 @@ export class HttpCore {
         this.timeoutMs = options.timeoutMs ?? 120_000;
         this.fetchImpl = options.fetch ?? globalThis.fetch;
     }
+    fail(path, status, body) {
+        const bag = errorBag(body);
+        const detail = bag ?? body?.detail ?? body?.error ?? body;
+        const code = typeof bag?.code === "string"
+            ? bag.code
+            : typeof body?.error === "string"
+                ? body.error
+                : undefined;
+        const message = typeof bag?.message === "string"
+            ? bag.message
+            : typeof detail === "string"
+                ? detail
+                : JSON.stringify(detail ?? "unknown error");
+        return new CaptapiError(`Captapi ${path} returned ${status}: ${message}`, status, code, detail);
+    }
+    async parseBody(res) {
+        try {
+            return await res.json();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async send(path, init) {
+        let last;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            let res;
+            try {
+                res = await this.fetchImpl(this.baseUrl + path, {
+                    ...init,
+                    headers: {
+                        authorization: `Bearer ${this.apiKey}`,
+                        accept: "application/json",
+                        ...(init.headers ?? {}),
+                    },
+                    signal: AbortSignal.timeout(this.timeoutMs),
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                throw new CaptapiError(`Request to ${path} failed: ${message}`, 0, "network_error", err);
+            }
+            const body = await this.parseBody(res);
+            if (res.ok && body?.success !== false)
+                return body;
+            last = this.fail(path, res.status, body);
+            if (attempt === 0 && shouldRetry(res.status, body)) {
+                await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+                continue;
+            }
+            throw last;
+        }
+        throw last ?? new CaptapiError(`Request to ${path} failed`, 0, "network_error");
+    }
     async get(path, params = {}) {
         const url = new URL(this.baseUrl + path);
         for (const [k, v] of Object.entries(params)) {
             if (v !== undefined && v !== null)
                 url.searchParams.set(k, String(v));
         }
-        let res;
-        try {
-            res = await this.fetchImpl(url, {
-                headers: { authorization: `Bearer ${this.apiKey}`, accept: "application/json" },
-                signal: AbortSignal.timeout(this.timeoutMs),
-            });
+        return this.send(url.pathname + url.search, { method: "GET" });
+    }
+    /**
+     * POST multipart/form-data. ``file`` may be a local path (Node), Blob, or File.
+     * Other params become additional form fields.
+     */
+    async postMultipart(path, params = {}) {
+        const form = new FormData();
+        const entries = params;
+        const fileVal = entries.file;
+        if (fileVal == null) {
+            throw new CaptapiError("Missing required form field: file", 400, "missing_file");
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            throw new CaptapiError(`Request to ${path} failed: ${message}`, 0, "network_error", err);
+        if (typeof fileVal === "string") {
+            // Node: treat string as a filesystem path.
+            const fs = await import("node:fs");
+            const pathMod = await import("node:path");
+            const buf = fs.readFileSync(fileVal);
+            form.append("file", new Blob([buf]), pathMod.basename(fileVal));
         }
-        let body;
-        try {
-            body = await res.json();
+        else if (typeof Blob !== "undefined" && fileVal instanceof Blob) {
+            form.append("file", fileVal, fileVal.name || "upload.bin");
         }
-        catch {
-            body = undefined;
+        else {
+            form.append("file", fileVal);
         }
-        if (!res.ok || body?.success === false) {
-            const detail = body?.detail ?? body?.error ?? body;
-            const code = typeof body?.detail === "object" && body?.detail?.error
-                ? String(body.detail.error)
-                : typeof body?.error === "string"
-                    ? body.error
-                    : undefined;
-            throw new CaptapiError(`Captapi ${path} returned ${res.status}: ${typeof detail === "string" ? detail : JSON.stringify(detail ?? "unknown error")}`, res.status, code, detail);
+        for (const [k, v] of Object.entries(entries)) {
+            if (k === "file" || v === undefined || v === null)
+                continue;
+            form.append(k, String(v));
         }
-        return body;
+        return this.send(path, { method: "POST", body: form });
     }
 }