@rendobar/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,640 @@
+import { WebSocket } from "partysocket";
+//#region src/errors.ts
+/**
+* SDK error class. All API errors are thrown as ApiError.
+* Use isApiError() to narrow in catch blocks.
+*/
+var ApiError = class extends Error {
+	constructor(code, statusCode, message, details, retryAfter) {
+		super(message);
+		this.code = code;
+		this.statusCode = statusCode;
+		this.details = details;
+		this.retryAfter = retryAfter;
+		this.name = "ApiError";
+	}
+};
+function isApiError(error) {
+	return error instanceof ApiError;
+}
+//#endregion
+//#region src/lib/request.ts
+/**
+* Core HTTP request layer. Handles auth, retries, timeouts, envelope
+* unwrapping, and error mapping. No external dependencies beyond fetch.
+*/
+const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_MAX_RETRIES = 2;
+const RETRY_BASE_DELAY = 500;
+const RETRYABLE_STATUS_CODES = new Set([
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+function createRequestFn(config) {
+	const { baseUrl = "https://api.rendobar.com", apiKey, accessToken, credentials, orgId, timeout = DEFAULT_TIMEOUT, maxRetries = DEFAULT_MAX_RETRIES, debug = false, fetch: fetchFn = globalThis.fetch } = config;
+	return async function request(path, options = {}) {
+		const url = buildUrl(baseUrl, path, options.query);
+		const init = buildInit(options, apiKey, accessToken, credentials, orgId);
+		const combinedSignal = combineSignals(options.signal, timeout);
+		let lastError;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			if (attempt > 0) await sleep$1(calcRetryDelay(attempt, lastError));
+			const start = Date.now();
+			try {
+				const response = await fetchFn(url, {
+					...init,
+					signal: combinedSignal
+				});
+				const duration = Date.now() - start;
+				if (debug) console.debug(`[sdk] ${init.method ?? "GET"} ${path} → ${response.status} (${duration}ms)`);
+				if (response.ok) {
+					if (response.status === 204) return void 0;
+					if (options.raw) return response;
+					return parseResponse(await response.json());
+				}
+				const apiError = await parseErrorResponse(response);
+				lastError = apiError;
+				if (!RETRYABLE_STATUS_CODES.has(response.status) || attempt === maxRetries) throw apiError;
+			} catch (error) {
+				if (error instanceof ApiError) {
+					if (!RETRYABLE_STATUS_CODES.has(error.statusCode) || attempt === maxRetries) throw error;
+					lastError = error;
+					continue;
+				}
+				if (isAbortError(error)) throw error;
+				lastError = error instanceof Error ? error : new Error(String(error));
+				if (attempt === maxRetries) throw lastError;
+			}
+		}
+		throw lastError;
+	};
+}
+function buildUrl(baseUrl, path, query) {
+	let url = `${baseUrl}${path}`;
+	if (query) {
+		const params = new URLSearchParams();
+		for (const [k, v] of Object.entries(query)) if (v != null) params.set(k, String(v));
+		const qs = params.toString();
+		if (qs) url += `?${qs}`;
+	}
+	return url;
+}
+function buildInit(options, apiKey, accessToken, credentials, orgId) {
+	const headers = { "Content-Type": "application/json" };
+	if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+	else if (accessToken) headers["Authorization"] = `Bearer ${accessToken}`;
+	if (orgId) headers["X-Org-Id"] = orgId;
+	const init = {
+		method: options.method ?? "GET",
+		headers
+	};
+	if (credentials) init.credentials = credentials;
+	if (options.bodyRaw !== void 0) {
+		init.body = options.bodyRaw;
+		delete headers["Content-Type"];
+	} else if (options.body !== void 0) init.body = JSON.stringify(options.body);
+	return init;
+}
+function combineSignals(userSignal, timeout) {
+	const timeoutSignal = AbortSignal.timeout(timeout);
+	if (!userSignal) return timeoutSignal;
+	return AbortSignal.any([userSignal, timeoutSignal]);
+}
+function isDataEnvelope(json) {
+	return json !== null && typeof json === "object" && "data" in json;
+}
+function parseResponse(json) {
+	if (isDataEnvelope(json)) {
+		if (json.meta !== void 0) return json;
+		return json.data;
+	}
+	return json;
+}
+async function parseErrorResponse(response) {
+	let code = "UNKNOWN_ERROR";
+	let message = `Request failed with status ${response.status}`;
+	let details;
+	let retryAfter;
+	try {
+		const body = await response.json();
+		if (body.error) {
+			code = body.error.code ?? code;
+			message = body.error.message ?? message;
+			details = body.error.details;
+		}
+	} catch {}
+	if (response.status === 429) {
+		const header = response.headers.get("Retry-After");
+		if (header) retryAfter = Number(header);
+	}
+	return new ApiError(code, response.status, message, details, retryAfter);
+}
+function calcRetryDelay(attempt, lastError) {
+	if (lastError instanceof ApiError && lastError.retryAfter) return lastError.retryAfter * 1e3;
+	return RETRY_BASE_DELAY * 2 ** (attempt - 1);
+}
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortError(error) {
+	return error instanceof DOMException && error.name === "AbortError";
+}
+//#endregion
+//#region src/resources/jobs.ts
+const TERMINAL_STATUSES$1 = new Set([
+	"complete",
+	"failed",
+	"cancelled"
+]);
+function createJobsResource(request) {
+	return {
+		async create(params, options) {
+			return request("/jobs", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async get(id, options) {
+			return request(`/jobs/${id}`, { signal: options?.signal });
+		},
+		async list(params, options) {
+			return request("/jobs", {
+				query: params,
+				signal: options?.signal
+			});
+		},
+		async *listAll(params) {
+			let offset = 0;
+			const limit = params?.limit ?? 50;
+			while (true) {
+				const page = await request("/jobs", { query: {
+					...params,
+					limit,
+					offset
+				} });
+				for (const job of page.data) yield job;
+				if (offset + page.data.length >= page.meta.total) break;
+				offset += limit;
+			}
+		},
+		async wait(id, options = {}) {
+			const { timeout = 3e5, interval = 2e3, onProgress, signal } = options;
+			const deadline = Date.now() + timeout;
+			while (Date.now() < deadline) {
+				if (signal?.aborted) throw new DOMException("Wait aborted", "AbortError");
+				const job = await request(`/jobs/${id}`, { signal });
+				onProgress?.(job);
+				if (TERMINAL_STATUSES$1.has(job.status)) return job;
+				const remaining = deadline - Date.now();
+				const delay = Math.min(interval, remaining);
+				if (delay <= 0) break;
+				await sleep(delay, signal);
+			}
+			const job = await request(`/jobs/${id}`, { signal });
+			if (TERMINAL_STATUSES$1.has(job.status)) return job;
+			throw new Error(`Job ${id} did not complete within ${timeout}ms (status: ${job.status})`);
+		},
+		async cancel(id, options) {
+			return request(`/jobs/${id}/cancel`, {
+				method: "POST",
+				signal: options?.signal
+			});
+		},
+		async download(id, options) {
+			return request(`/jobs/${id}/download`, {
+				raw: true,
+				signal: options?.signal
+			});
+		},
+		async logs(id, options) {
+			return request(`/jobs/${id}/logs`, { signal: options?.signal });
+		},
+		async types(options) {
+			return request("/jobs/types", { signal: options?.signal });
+		}
+	};
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("Wait aborted", "AbortError"));
+			return;
+		}
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(new DOMException("Wait aborted", "AbortError"));
+		}, { once: true });
+	});
+}
+//#endregion
+//#region src/resources/billing.ts
+function createBillingResource(request) {
+	return {
+		async state(options) {
+			return request("/billing/state", { signal: options?.signal });
+		},
+		async usage(params, options) {
+			return request("/billing/usage", {
+				query: params,
+				signal: options?.signal
+			});
+		},
+		async transactions(params, options) {
+			return request("/billing/transactions", {
+				query: params,
+				signal: options?.signal
+			});
+		},
+		async checkoutCredits(amount, options) {
+			return request("/billing/checkout/credits", {
+				method: "POST",
+				body: { amount },
+				signal: options?.signal
+			});
+		},
+		async checkoutPro(options) {
+			return request("/billing/checkout/pro", {
+				method: "POST",
+				signal: options?.signal
+			});
+		},
+		async cancelSubscription(options) {
+			await request("/billing/subscription", {
+				method: "PATCH",
+				body: { cancelAtPeriodEnd: true },
+				signal: options?.signal
+			});
+		},
+		async reactivateSubscription(options) {
+			await request("/billing/subscription", {
+				method: "PATCH",
+				body: { cancelAtPeriodEnd: false },
+				signal: options?.signal
+			});
+		},
+		async history(params, options) {
+			return request("/billing/history", {
+				query: params,
+				signal: options?.signal
+			});
+		},
+		async paymentMethods(options) {
+			return request("/billing/payment-methods", { signal: options?.signal });
+		},
+		async deletePaymentMethod(id, options) {
+			await request(`/billing/payment-methods/${id}`, {
+				method: "DELETE",
+				signal: options?.signal
+			});
+		},
+		async portalUrl(options) {
+			return request("/billing/payment-methods/portal-url", { signal: options?.signal });
+		}
+	};
+}
+//#endregion
+//#region src/resources/uploads.ts
+function createUploadsResource(request) {
+	return { async upload(file, options) {
+		return request("/uploads", {
+			method: "POST",
+			bodyRaw: file,
+			query: options?.filename ? { filename: options.filename } : void 0,
+			signal: options?.signal
+		});
+	} };
+}
+//#endregion
+//#region src/resources/webhooks.ts
+function createWebhooksResource(request) {
+	return {
+		async create(params, options) {
+			return request("/webhooks/endpoints", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async list(options) {
+			return request("/webhooks/endpoints", { signal: options?.signal });
+		},
+		async get(id, options) {
+			return request(`/webhooks/endpoints/${id}`, { signal: options?.signal });
+		},
+		async update(id, params, options) {
+			return request(`/webhooks/endpoints/${id}`, {
+				method: "PATCH",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async delete(id, options) {
+			await request(`/webhooks/endpoints/${id}`, {
+				method: "DELETE",
+				signal: options?.signal
+			});
+		},
+		async rotateSecret(id, options) {
+			return request(`/webhooks/endpoints/${id}/secret`, {
+				method: "POST",
+				signal: options?.signal
+			});
+		},
+		async test(id, options) {
+			return request(`/webhooks/endpoints/${id}/test`, {
+				method: "POST",
+				signal: options?.signal
+			});
+		},
+		async listDeliveries(params, options) {
+			return request("/webhooks/deliveries", {
+				query: params,
+				signal: options?.signal
+			});
+		},
+		async retryDelivery(id, options) {
+			return request(`/webhooks/deliveries/${id}/retry`, {
+				method: "POST",
+				signal: options?.signal
+			});
+		}
+	};
+}
+//#endregion
+//#region src/resources/api-keys.ts
+function createApiKeysResource(request) {
+	return {
+		async create(params, options) {
+			return request("/api-keys", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async list(options) {
+			return request("/api-keys", { signal: options?.signal });
+		},
+		async revoke(id, options) {
+			return request(`/api-keys/${id}`, {
+				method: "DELETE",
+				signal: options?.signal
+			});
+		}
+	};
+}
+//#endregion
+//#region src/resources/orgs.ts
+function createOrgsResource(request) {
+	return {
+		async list(options) {
+			return request("/orgs", { signal: options?.signal });
+		},
+		async current(options) {
+			return request("/orgs/current", { signal: options?.signal });
+		},
+		async create(params, options) {
+			return request("/orgs", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async update(params, options) {
+			return request("/orgs/current", {
+				method: "PATCH",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async delete(options) {
+			await request("/orgs/current", {
+				method: "DELETE",
+				signal: options?.signal
+			});
+		}
+	};
+}
+//#endregion
+//#region src/resources/batches.ts
+function createBatchesResource(request) {
+	return {
+		async create(params, options) {
+			return request("/batches", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async get(id, options) {
+			return request(`/batches/${id}`, { signal: options?.signal });
+		}
+	};
+}
+//#endregion
+//#region src/resources/assets.ts
+function createAssetsResource(request) {
+	return { async templates(params, options) {
+		return request("/assets/templates", {
+			query: params ? { ...params } : void 0,
+			signal: options?.signal
+		});
+	} };
+}
+//#endregion
+//#region src/resources/team.ts
+function createTeamResource(request) {
+	return {
+		async invite(params, options) {
+			return request("/team/invite", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async changeRole(params, options) {
+			await request("/team/role", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async remove(params, options) {
+			await request("/team/remove", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		},
+		async revokeInvitation(params, options) {
+			await request("/team/revoke-invitation", {
+				method: "POST",
+				body: params,
+				signal: options?.signal
+			});
+		}
+	};
+}
+//#endregion
+//#region src/realtime/client.ts
+/**
+* Realtime event client using partysocket for reconnection
+* and the Rendobar OrgHub protocol for event replay + dedup.
+*
+* Protocol:
+* 1. On connect: send { type: "init", lastEventId }
+* 2. Server replays buffered events (each has monotonic `id` field)
+* 3. Server sends { type: "replay.done" } — switch to live mode
+* 4. Server sends { type: "resync" } — buffer overflow, caller should full-refresh
+* 5. Dedup: skip events where id <= lastEventId
+*/
+function parseMessage(raw) {
+	try {
+		const data = JSON.parse(raw);
+		if (data && typeof data === "object" && typeof data.type === "string") return data;
+		return null;
+	} catch {
+		return null;
+	}
+}
+const WS_OPTIONS = {
+	maxReconnectionDelay: 3e4,
+	minReconnectionDelay: 1e3,
+	reconnectionDelayGrowFactor: 1.5,
+	maxRetries: Infinity
+};
+const TERMINAL_STATUSES = new Set([
+	"complete",
+	"failed",
+	"cancelled"
+]);
+/** Known OrgEvent types — only dispatch events with recognized types. */
+const KNOWN_EVENT_TYPES = new Set([
+	"job.created",
+	"job.status",
+	"job.result",
+	"job.progress",
+	"job.step",
+	"job.log",
+	"balance.updated",
+	"subscription.updated",
+	"notification",
+	"org.updated"
+]);
+/**
+* Create a realtime client for WebSocket event streaming.
+*
+* Auth: session cookie (credentials: "include") OR API key via ?token= query param.
+* The client appends the token automatically when apiKey is provided.
+*/
+function createRealtimeClient(baseUrl, options) {
+	const wsUrl = baseUrl.replace("https://", "wss://").replace("http://", "ws://");
+	const token = options?.apiKey ?? options?.accessToken;
+	const tokenSuffix = token ? `?token=${encodeURIComponent(token)}` : "";
+	return {
+		connect(options) {
+			let lastEventId = options.lastEventId ?? 0;
+			const ws = new WebSocket(`${wsUrl}/events/ws${tokenSuffix}`, void 0, WS_OPTIONS);
+			ws.addEventListener("open", () => {
+				options.onReconnect?.();
+				ws.send(JSON.stringify({
+					type: "init",
+					lastEventId
+				}));
+			});
+			ws.addEventListener("message", (evt) => {
+				if (typeof evt.data !== "string") return;
+				const data = parseMessage(evt.data);
+				if (!data) return;
+				if (typeof data.id === "number") {
+					if (data.id <= lastEventId) return;
+					lastEventId = data.id;
+				}
+				if (data.type === "replay.done") {
+					options.onLive?.();
+					return;
+				}
+				if (data.type === "resync") {
+					options.onResync?.();
+					return;
+				}
+				if (KNOWN_EVENT_TYPES.has(data.type)) options.onEvent(data);
+			});
+			return { disconnect: () => ws.close() };
+		},
+		subscribeJob(jobId, options) {
+			const ws = new WebSocket(`${wsUrl}/events/ws${tokenSuffix}${tokenSuffix ? "&" : "?"}jobId=${jobId}`, void 0, WS_OPTIONS);
+			ws.addEventListener("open", () => {
+				ws.send(JSON.stringify({
+					type: "init",
+					lastEventId: 0
+				}));
+			});
+			ws.addEventListener("message", (evt) => {
+				if (typeof evt.data !== "string") return;
+				const data = parseMessage(evt.data);
+				if (!data || data.type === "replay.done" || data.type === "resync") return;
+				try {
+					dispatchJobEvent(data, options);
+				} catch (err) {
+					options.onError?.(err instanceof Error ? err : new Error(String(err)));
+				}
+			});
+			return { unsubscribe: () => ws.close() };
+		}
+	};
+}
+function dispatchJobEvent(event, options) {
+	switch (event.type) {
+		case "job.progress":
+			options.onProgress?.(event);
+			break;
+		case "job.step":
+			options.onStep?.(event);
+			break;
+		case "job.log":
+			options.onLog?.(event);
+			break;
+		case "job.status": {
+			const statusEvent = event;
+			options.onStatus?.(statusEvent);
+			if (TERMINAL_STATUSES.has(statusEvent.status)) options.onComplete?.(statusEvent);
+			break;
+		}
+		case "job.result":
+			options.onResult?.(event);
+			break;
+	}
+}
+//#endregion
+//#region src/client.ts
+/**
+* SDK client factory. Creates a configured client with resource namespaces.
+*/
+function createClient(config = {}) {
+	const baseUrl = config.baseUrl ?? "https://api.rendobar.com";
+	const request = createRequestFn(config);
+	return {
+		jobs: createJobsResource(request),
+		billing: createBillingResource(request),
+		uploads: createUploadsResource(request),
+		webhooks: createWebhooksResource(request),
+		apiKeys: createApiKeysResource(request),
+		orgs: createOrgsResource(request),
+		batches: createBatchesResource(request),
+		assets: createAssetsResource(request),
+		team: createTeamResource(request),
+		realtime: createRealtimeClient(baseUrl, {
+			apiKey: config.apiKey,
+			accessToken: config.accessToken
+		})
+	};
+}
+//#endregion
+export { ApiError, createClient, isApiError };
+
+//# sourceMappingURL=index.mjs.map