@retab/node 0.0.0-reserved → 0.0.42

package/dist/client.js

@@ -0,0 +1,135 @@
+import * as z from "zod";
+export class AbstractClient {
+    _fetch(_) {
+        throw new Error("Method not implemented");
+    }
+    async _fetchJson(bodyType, params) {
+        let response = await this._fetch(params);
+        if (!response.ok) {
+            throw new APIError(response.status, await response.text());
+        }
+        if (response.headers.get("Content-Type") !== "application/json")
+            throw new APIError(response.status, "Response is not JSON");
+        return bodyType.parse(await response.json());
+    }
+}
+export class CompositionClient extends AbstractClient {
+    constructor(client) {
+        super();
+        this._client = client;
+    }
+    _fetch(params) {
+        return this._client["_fetch"](params);
+    }
+}
+export class APIError extends Error {
+    constructor(status, info) {
+        super(`API Error ${status}: ${info}`);
+        this.status = status;
+        this.info = info;
+    }
+}
+export async function* streamResponse(response, schema) {
+    let body = "";
+    let depth = 0;
+    let inString = false;
+    if (!response.body) {
+        throw new APIError(response.status, "Response body is empty");
+    }
+    let reader = response.body.getReader();
+    while (true) {
+        let chunk = await reader.read();
+        if (!chunk.value)
+            break;
+        let string = new TextDecoder().decode(chunk.value, { stream: true });
+        let prevBodyLength = body.length;
+        body += string;
+        for (let i = 0; i < string.length; i++) {
+            let char = string[i];
+            if (char === '"') {
+                inString = !inString;
+            }
+            if (inString) {
+                if (char === "\\") {
+                    i++;
+                }
+            }
+            else {
+                if (char === "{") {
+                    depth++;
+                }
+                else if (char === "}") {
+                    depth--;
+                    if (depth === 0) {
+                        yield schema.parse(JSON.parse(body.slice(0, prevBodyLength + i + 1)));
+                        body = body.slice(prevBodyLength + i + 1);
+                        prevBodyLength = -i - 1;
+                    }
+                }
+            }
+        }
+        if (chunk.done)
+            break;
+    }
+}
+export const DateOrISO = z.union([
+    z.date(),
+    z.string().refine(val => !isNaN(Date.parse(val)), {
+        message: "Invalid date string",
+    }).transform(val => new Date(val)),
+]);
+export class FetcherClient extends AbstractClient {
+    constructor(options) {
+        super();
+        this.options = options || {};
+    }
+    async _fetch(params) {
+        let query = "";
+        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 headers = params.headers || {};
+        let init = {
+            method: params.method,
+        };
+        if (params.method !== "GET") {
+            headers["Content-Type"] = params.bodyMime || "application/json";
+            if (params.bodyMime === "multipart/form-data") {
+                let formData = new FormData();
+                for (const key of Object.keys(params.body || {})) {
+                    let value = params.body[key];
+                    if (Array.isArray(value)) {
+                        for (const item of value) {
+                            formData.append(key, item);
+                        }
+                        continue;
+                    }
+                    formData.append(key, value);
+                }
+                init.body = formData;
+            }
+            else {
+                init.body = JSON.stringify(params.body);
+            }
+        }
+        let bearerToken = "bearer" in this.options ? this.options.bearer : process.env["RETAB_BEARER_TOKEN"];
+        let masterKey = "masterKey" in this.options ? this.options.masterKey : process.env["RETAB_MASTER_KEY"];
+        let apiKey = "apiKey" in this.options ? this.options.apiKey : process.env["RETAB_API_KEY"];
+        if (bearerToken) {
+            headers["Authorization"] = `Bearer ${bearerToken}`;
+        }
+        else if (masterKey) {
+            headers["Master-Key"] = masterKey;
+        }
+        else if (apiKey) {
+            headers["Api-Key"] = apiKey;
+        }
+        init.headers = headers;
+        let res = await fetch(url, init);
+        if (!res.ok) {
+            throw new APIError(res.status, await res.text());
+        }
+        return res;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,34 @@
+export declare class MaxRetriesExceeded extends Error {
+    attempts: number;
+    cause?: Error;
+    constructor(attempts: number, cause?: Error);
+    toJSON(): {
+        name: string;
+        message: string;
+        attempts: number;
+        stack: string | undefined;
+    };
+}
+export declare class APIError extends Error {
+    status: number;
+    response?: any;
+    constructor(status: number, message: string, response?: any);
+    toJSON(): {
+        name: string;
+        message: string;
+        status: number;
+        response: any;
+        stack: string | undefined;
+    };
+}
+export declare class ValidationError extends Error {
+    details?: any;
+    constructor(message: string, details?: any);
+    toJSON(): {
+        name: string;
+        message: string;
+        details: any;
+        stack: string | undefined;
+    };
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;gBAET,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;IAY3C,MAAM;;;;;;CAQP;AAED,qBAAa,QAAS,SAAQ,KAAK;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,GAAG,CAAC;gBAEV,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG;IAO3D,MAAM;;;;;;;CASP;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACjC,OAAO,CAAC,EAAE,GAAG,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG;IAM1C,MAAM;;;;;;CAQP"}

package/dist/errors.js

@@ -0,0 +1,53 @@
+export class MaxRetriesExceeded extends Error {
+    constructor(attempts, cause) {
+        const message = cause
+            ? `Max tries exceeded after ${attempts} attempts. ${cause.message}`
+            : `Max tries exceeded after ${attempts} attempts.`;
+        super(message);
+        this.name = 'MaxRetriesExceeded';
+        this.attempts = attempts;
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            attempts: this.attempts,
+            stack: this.stack
+        };
+    }
+}
+export class APIError extends Error {
+    constructor(status, message, response) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+        this.response = response;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            response: this.response,
+            stack: this.stack
+        };
+    }
+}
+export class ValidationError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.name = 'ValidationError';
+        this.details = details;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            details: this.details,
+            stack: this.stack
+        };
+    }
+}