@rendobar/sdk 2.2.0 → 3.0.1

package/dist/index.cjs

@@ -303,13 +303,161 @@ function createBillingResource(request) {
 }
 //#endregion
 //#region src/resources/uploads.ts
+function toBlob(file) {
+	return file instanceof Blob ? file : new Blob([file]);
+}
+/**
+* Per-attempt upload time budget. fetch() exposes no upload progress, so a
+* stalled socket and a slow link are indistinguishable from the outside; a
+* hard per-attempt budget is the only portable stall cap. The ladder escalates
+* (healthy 500 KiB/s assumption first, then 100, then 50) so a genuinely slow
+* connection that times out on an early attempt still completes on a later,
+* more patient one — while a hung socket gets cut and retried on a fresh
+* connection instead of waiting on the OS TCP timeout.
+*
+* @internal exported for tests
+*/
+function attemptTimeoutMs(sizeBytes, attempt) {
+	const GRACE_MS = [
+		1e4,
+		3e4,
+		6e4
+	];
+	const RATE_BPS = [
+		500 * 1024,
+		100 * 1024,
+		50 * 1024
+	];
+	const i = Math.min(attempt, GRACE_MS.length - 1);
+	return GRACE_MS[i] + Math.ceil(sizeBytes / RATE_BPS[i] * 1e3);
+}
+/**
+* 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). Network/HTTP
+* failures and per-attempt timeouts trigger retries; a caller abort and a
+* missing ETag do not (the latter is a deterministic misconfiguration, not a
+* transient error).
+*
+* @internal exported for tests
+*/
+async function putWithRetry(url, body, signal, sizeBytes, attempts = 3, attemptTimeouts) {
+	let lastErr;
+	for (let i = 0; i < attempts; i++) {
+		if (signal?.aborted) throw new Error("Upload aborted");
+		const timeoutMs = attemptTimeouts?.[i] ?? attemptTimeoutMs(sizeBytes, i);
+		const timeout = AbortSignal.timeout(timeoutMs);
+		const attemptSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+		try {
+			const res = await fetch(url, {
+				method: "PUT",
+				body,
+				signal: attemptSignal
+			});
+			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",
+			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, size);
+			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, chunk.size);
+			} 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",
-			bodyRaw: file,
-			query: options?.filename ? { filename: options.filename } : void 0,
-			signal: options?.signal
+			body: { parts: completed },
+			signal: options.signal
 		});
 	} };
 }
@@ -449,12 +597,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