@rendobar/sdk 2.1.2 → 3.0.0

package/dist/index.mjs

@@ -302,13 +302,130 @@ function createBillingResource(request) {
 }
 //#endregion
 //#region src/resources/uploads.ts
+function toBlob(file) {
+	return file instanceof Blob ? file : new Blob([file]);
+}
+/**
+* PUT a body to a presigned R2 url with bounded retry.
+*
+* Returns the ETag string when the bucket exposes it, or `null` when the
+* response header is absent (e.g. bucket CORS not exposing ETag). Only
+* network/HTTP failures trigger retries; a missing ETag is not retried because
+* it is a deterministic misconfiguration, not a transient error.
+*/
+async function putWithRetry(url, body, signal, attempts = 3) {
+	let lastErr;
+	for (let i = 0; i < attempts; i++) {
+		if (signal?.aborted) throw new Error("Upload aborted");
+		try {
+			const res = await fetch(url, {
+				method: "PUT",
+				body,
+				signal
+			});
+			if (!res.ok) throw new Error(`Upload PUT failed: ${res.status}`);
+			return res.headers.get("etag");
+		} catch (e) {
+			lastErr = e;
+			if (signal?.aborted) throw e;
+			if (i < attempts - 1) await new Promise((r) => setTimeout(r, 200 * 2 ** i));
+		}
+	}
+	throw lastErr;
+}
+/**
+* Run `fn` over `items` with at most `limit` in flight; preserves order.
+* Workers stop pulling new items once `signal` is aborted, enabling fast
+* cancellation when one part fails.
+*/
+async function mapLimit(items, limit, fn, signal) {
+	const out = new Array(items.length);
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) {
+			if (signal?.aborted) break;
+			const i = next++;
+			out[i] = await fn(items[i]);
+		}
+	};
+	const workers = Math.min(Math.max(1, limit), items.length);
+	await Promise.all(Array.from({ length: workers }, worker));
+	return out;
+}
 function createUploadsResource(request) {
-	return { async upload(file, options) {
-		return request("/uploads", {
+	return { async create(file, options) {
+		const blob = toBlob(file);
+		const size = options.size ?? blob.size;
+		if (options.signal?.aborted) throw new Error("Upload aborted");
+		const init = await (await request("/assets", {
 			method: "POST",
-			bodyRaw: file,
-			query: options?.filename ? { filename: options.filename } : void 0,
-			signal: options?.signal
+			body: {
+				filename: options.filename,
+				size,
+				contentType: options.contentType,
+				checksum: options.checksum,
+				lifecycle: options.persist ? "persisted" : "ephemeral"
+			},
+			raw: true,
+			signal: options.signal
+		})).json();
+		if (init.status === "deduplicated") {
+			options.onProgress?.({
+				loaded: size,
+				total: size
+			});
+			return init.data;
+		}
+		if (init.status === "presigned") {
+			await putWithRetry(init.upload.url, blob, options.signal);
+			options.onProgress?.({
+				loaded: size,
+				total: size
+			});
+			return request(`/assets/${init.data.id}/complete`, {
+				method: "POST",
+				body: {},
+				signal: options.signal
+			});
+		}
+		const internal = new AbortController();
+		const combinedSignal = options.signal ? AbortSignal.any([options.signal, internal.signal]) : internal.signal;
+		const { partSize, parts } = init.upload;
+		let loaded = 0;
+		let partError = null;
+		const completed = await mapLimit(parts, options.concurrency ?? 5, async (p) => {
+			const start = (p.partNumber - 1) * partSize;
+			const chunk = blob.slice(start, Math.min(start + partSize, size));
+			let etag;
+			try {
+				etag = await putWithRetry(p.url, chunk, combinedSignal);
+			} catch (e) {
+				internal.abort();
+				partError = e instanceof Error ? e : new Error(String(e));
+				throw partError;
+			}
+			if (etag === null) {
+				internal.abort();
+				const corsErr = /* @__PURE__ */ new Error("Multipart upload requires the ETag response header. Configure the R2 bucket CORS to expose 'ETag'.");
+				partError = corsErr;
+				throw corsErr;
+			}
+			loaded += chunk.size;
+			options.onProgress?.({
+				loaded,
+				total: size
+			});
+			return {
+				partNumber: p.partNumber,
+				etag
+			};
+		}, combinedSignal);
+		if (partError) throw partError;
+		completed.sort((a, b) => a.partNumber - b.partNumber);
+		return request(`/assets/${init.data.id}/complete`, {
+			method: "POST",
+			body: { parts: completed },
+			signal: options.signal
 		});
 	} };
 }
@@ -448,12 +565,32 @@ function createBatchesResource(request) {
 //#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
-		});
-	} };
+	return {
+		async list(params, options) {
+			return request("/assets", {
+				query: params,
+				signal: options?.signal
+			});
+		},
+		async get(id, options) {
+			return request(`/assets/${id}`, { signal: options?.signal });
+		},
+		async delete(id, options) {
+			return request(`/assets/${id}`, {
+				method: "DELETE",
+				signal: options?.signal
+			});
+		},
+		async download(id, options) {
+			return request(`/assets/${id}/download`, { signal: options?.signal });
+		},
+		async templates(params, options) {
+			return request("/assets/templates", {
+				query: params,
+				signal: options?.signal
+			});
+		}
+	};
 }
 //#endregion
 //#region src/resources/team.ts
@@ -645,4 +782,40 @@ function createClient(config = {}) {
 	};
 }
 //#endregion
-export { ApiError, createClient, isApiError };
+//#region src/types.ts
+/**
+* Primary playable/download URL for a completed job, or `undefined`.
+*
+* Returns `output.file.url` — the single download for a file job or the playlist
+* URL for a stream. A pure set (multiple files, no headline) or a data-only job
+* has no single primary URL: inspect `job.output.files` / `job.output.data`.
+*/
+function outputUrl(job) {
+	if (job.status !== "complete") return void 0;
+	return job.output.file?.url;
+}
+/**
+* Typed accessor for a completed job's structured `data`, or `null`.
+*
+* `output.data` is job-type-specific (probe result, detections, transcript) and
+* is `unknown` at the contract level — its shape is documented per job type, not
+* by the API schema. This helper applies the caller-supplied type `T` so you can
+* read `data` without sprinkling assertions at each call site. `T` is your claim
+* about the shape for the job type you submitted; validate it yourself (e.g. with
+* Zod) if the input is untrusted.
+*
+* Returns `null` for non-complete jobs and for jobs with no structured data
+* (pure file transforms).
+*
+* @example
+* type Metadata = { format: string; durationMs: number };
+* const meta = jobData<Metadata>(await client.jobs.wait(id));
+* if (meta) console.log(meta.durationMs);
+*/
+function jobData(job) {
+	if (job.status !== "complete") return null;
+	if (job.output.data == null) return null;
+	return job.output.data;
+}
+//#endregion
+export { ApiError, createClient, isApiError, jobData, outputUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rendobar/sdk",
-  "version": "2.1.2",
+  "version": "3.0.0",
   "type": "module",
   "description": "TypeScript client for the Rendobar media processing API",
   "main": "./dist/index.cjs",