@calmlens/sdk 0.12.0 → 0.13.0

package/README.md

@@ -197,7 +197,7 @@ const image = await client.cdn.serve({
 });
 ```
 
-For several lenses, use `ensureLenses()` to perform all ensures in one request. Each lens keeps the same independent versioning rules.
+For several lenses, use `ensureLenses()` to ensure them together: new definitions go in one request, or in consecutive requests of up to 100 each, in order. Each lens keeps the same independent versioning rules.
 
 ```typescript
 const [normal, uhd] = await client.ensureLenses({ lenses: [normalLens, uhdLens] });
@@ -303,6 +303,19 @@ const asset = await client.assets.retry({ assetId: "asset-uuid" });
 // asset.status === "pending"
 ```
 
+##### assets.waitForDecision(options)
+
+Wait for an asset's moderation decision and get the decided asset: `approved`, `rejected` or `error`.
+The SDK checks the asset every few seconds and rejects with `sdk/timeout` if there's no decision within
+`timeoutMs` (default 60000). Pass `signal` to stop waiting early (`sdk/cancelled`). Use it after
+`assets.create`, or with an asset ID you stored earlier. Webhooks report decisions without polling.
+
+```typescript
+const queued = await client.assets.create({ name: "photo.jpg", content: { blob, type: "image/jpeg" } });
+const decided = await client.assets.waitForDecision({ assetId: queued.id, timeoutMs: 30_000 });
+if (decided.status === "rejected") hidePhoto(decided.id);
+```
+
 ##### folders.list()
 
 List all folders in the current project.

package/cjs/CalmLensConnection-DzRDCMOP.js

@@ -0,0 +1,233 @@
+const require_CalmLensVersion = require("./CalmLensVersion-DjhsJ1gj.js");
+const require_CalmLensUtils = require("./CalmLensUtils-vX5H_vMn.js");
+//#region src/client/CalmLensConnection.ts
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_MAX_RESPONSE_BYTES = 33554432;
+/**
+* Bytes as a fetch body. They're sent as they are rather than in a Blob: React Native can't
+* build a Blob from bytes, and every fetch accepts a Uint8Array.
+*/
+const toBodyBytes = (value) => value.buffer instanceof ArrayBuffer ? value : Uint8Array.from(value);
+const toRawUploadBody = (payload) => {
+	const data = require_CalmLensUtils.assetToData(payload);
+	if (data instanceof Response) {
+		if (!data.body) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Response upload data must have a body" });
+		return data.body;
+	}
+	if (data instanceof ArrayBuffer || data instanceof Blob) return data;
+	if ("getReader" in data) return data;
+	return toBodyBytes(data);
+};
+const setOptionalQueryValue = (params, key, value) => {
+	if (value !== void 0 && value !== null) params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+};
+const assertValidUploadMimeType = (mimeType) => {
+	if (require_CalmLensUtils.isRejectedUploadMimeType(mimeType)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+		message: require_CalmLensUtils.getRejectedUploadMimeTypeError(mimeType),
+		details: { mimeType }
+	});
+};
+const isImageMimeType = (mimeType) => mimeType.toLowerCase().startsWith("image/");
+const invalidPayload = (message) => new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
+/** Checks upload options before anything is sent. */
+const prepareSubmitAssetOptions = (options) => {
+	if (!options || typeof options !== "object") throw require_CalmLensVersion.invalidArgument("Asset options are required");
+	if (!("content" in options) && !("url" in options) && !("part" in options)) throw invalidPayload("Either file content, URL, or multipart part is required");
+	if (!options.name) throw invalidPayload("Asset name is required");
+	if (!("part" in options) && "isFinal" in options) throw invalidPayload("isFinal is only valid for multipart uploads");
+	if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.USE_UPLOAD_PART, { message: "Use uploadPart for multipart upload parts after the first part" });
+	if ("content" in options) {
+		assertValidUploadMimeType(options.content.type);
+		if (!("plainText" in options.content)) {
+			const validation = require_CalmLensUtils.validateAssetPayload(options.content);
+			if (!validation.ok) throw invalidPayload(validation.error);
+		}
+	}
+	if ("part" in options) {
+		assertValidUploadMimeType(options.part.type);
+		const partSizeInBytes = options.part.sizeInBytes ?? require_CalmLensUtils.getAssetPayloadByteLength(options.part);
+		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
+			if (partSizeInBytes > require_CalmLensUtils.MAX_IMAGE_UPLOAD_BYTES) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE, { message: "Multipart image uploads cannot exceed 20MB." });
+			if (options.part.isFinal && partSizeInBytes < require_CalmLensUtils.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL, { message: "Multipart image uploads must total at least 10MB." });
+		}
+		const validation = require_CalmLensUtils.validateAssetPayload(options.part, {
+			multipart: true,
+			isFinal: options.part.isFinal
+		});
+		if (!validation.ok) throw invalidPayload(validation.error);
+	}
+	return options;
+};
+const newIdempotencyKey = () => require_CalmLensUtils.randomUuid();
+/** Text content is small, so it keeps the API deadline; binary files may be arbitrarily large. */
+const isTextPayload = (payload) => "plainText" in payload;
+const isAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id && typeof data.status === "string";
+const isUploadedAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id;
+const expectUploadedAsset = (data) => {
+	if (!isUploadedAsset(data)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.INVALID_RESPONSE, {
+		message: "Expected an uploaded asset response",
+		status: 200
+	});
+	return data;
+};
+const expectAsset = (data) => {
+	if (!isAsset(data)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.INVALID_RESPONSE, {
+		message: "Expected an asset response",
+		status: 200
+	});
+	return data;
+};
+/** Fills in the default API base URL and drops trailing slashes. */
+const resolveConnectionOptions = (options) => ({
+	...options,
+	baseUrl: (options.baseUrl ?? `https://api.calmlens.com/v1`).replace(/\/+$/, "")
+});
+/** One client's transport, base URL and deadlines, and the requests both clients make. */
+var CalmLensConnection = class {
+	constructor(options, apiKey) {
+		this.options = options;
+		const resolveFetch = () => {
+			const fetchImpl = this.options.fetch ?? globalThis.fetch;
+			if (typeof fetchImpl !== "function") throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.NO_FETCH, { message: "No fetch implementation is available; pass one as the fetch option" });
+			return fetchImpl;
+		};
+		this.transport = new require_CalmLensUtils.CalmLensTransport({
+			apiKey,
+			fetch: ((input, init) => resolveFetch()(input, init)),
+			signal: options.signal,
+			maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+			maxResponseBytes: options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES
+		});
+	}
+	get timeoutMs() {
+		return this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	}
+	url(path, query) {
+		const search = query ? require_CalmLensUtils.stringifyQuery(query) : "";
+		return `${this.options.baseUrl}${path}${search ? `?${search}` : ""}`;
+	}
+	/** A JSON request whose deadline covers reading the response. */
+	json(method, path, { query, body, headers, idempotencyKey } = {}) {
+		return this.transport.json({
+			method,
+			url: this.url(path, query),
+			headers: body === void 0 ? headers : {
+				...headers,
+				"Content-Type": "application/json"
+			},
+			body: body === void 0 ? void 0 : JSON.stringify(body),
+			idempotencyKey,
+			timeoutMs: this.timeoutMs,
+			deadline: "body"
+		});
+	}
+	upload(url, payload, headers, idempotencyKey) {
+		return this.transport.json({
+			method: "POST",
+			url,
+			headers,
+			body: toRawUploadBody(payload),
+			idempotencyKey,
+			timeoutMs: isTextPayload(payload) ? this.timeoutMs : this.options.uploadTimeoutMs,
+			deadline: "body",
+			fetch: this.options.uploadFetch
+		});
+	}
+	/**
+	* Uploads file content or a first multipart part to `uploadsPath` (`.../assets`), as raw
+	* bytes with the options in the query.
+	*/
+	submitRawUpload(uploadsPath, options, queue, authHeaders = {}) {
+		const query = new URLSearchParams();
+		query.set("name", options.name);
+		query.set("queue", String(queue));
+		setOptionalQueryValue(query, "description", options.description);
+		setOptionalQueryValue(query, "processingOptions", options.processingOptions);
+		setOptionalQueryValue(query, "visibility", options.visibility);
+		setOptionalQueryValue(query, "metadata", options.metadata);
+		setOptionalQueryValue(query, "externalId", options.externalId);
+		setOptionalQueryValue(query, "externalUrl", options.externalUrl);
+		setOptionalQueryValue(query, "folderId", options.folderId);
+		setOptionalQueryValue(query, "uploadPresetId", options.uploadPresetId);
+		const isMultipart = "part" in options;
+		const payload = isMultipart ? options.part : options.content;
+		query.set("contentType", payload.type);
+		setOptionalQueryValue(query, "sizeInBytes", payload.sizeInBytes ?? require_CalmLensUtils.getAssetPayloadByteLength(payload));
+		if (isMultipart) {
+			const part = payload;
+			const multipartOptions = options;
+			query.set("partNumber", String(part.partNumber ?? 1));
+			query.set("isFinal", String(part.isFinal ?? false));
+			setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? multipartOptions.sizeInBytes);
+			setOptionalQueryValue(query, "totalSizeInBytes", multipartOptions.totalSizeInBytes);
+		}
+		return this.upload(this.url(`${uploadsPath}?${query}`), payload, {
+			...authHeaders,
+			"Content-Type": payload.type,
+			"X-CalmLens-Upload": isMultipart ? "part" : "content"
+		}, options.idempotencyKey ?? newIdempotencyKey());
+	}
+	/** Uploads the next part of a multipart upload to `partPath` (`.../assets/{id}/part`). */
+	uploadPart(partPath, { part, queue, idempotencyKey }, authHeaders = {}) {
+		if (!part) throw require_CalmLensVersion.invalidArgument("Part options are required");
+		const validation = require_CalmLensUtils.validateAssetPayload(part, {
+			multipart: true,
+			isFinal: part.isFinal
+		});
+		if (!validation.ok) throw invalidPayload(validation.error);
+		const query = new URLSearchParams({
+			partNumber: String(part.partNumber),
+			isFinal: String(part.isFinal ?? false)
+		});
+		if (queue !== void 0) query.set("queue", String(queue));
+		setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? require_CalmLensUtils.getAssetPayloadByteLength(part));
+		return this.upload(this.url(`${partPath}?${query}`), part, {
+			...authHeaders,
+			"X-CalmLens-Upload": "part"
+		}, idempotencyKey ?? newIdempotencyKey());
+	}
+};
+//#endregion
+Object.defineProperty(exports, "CalmLensConnection", {
+	enumerable: true,
+	get: function() {
+		return CalmLensConnection;
+	}
+});
+Object.defineProperty(exports, "expectAsset", {
+	enumerable: true,
+	get: function() {
+		return expectAsset;
+	}
+});
+Object.defineProperty(exports, "expectUploadedAsset", {
+	enumerable: true,
+	get: function() {
+		return expectUploadedAsset;
+	}
+});
+Object.defineProperty(exports, "invalidPayload", {
+	enumerable: true,
+	get: function() {
+		return invalidPayload;
+	}
+});
+Object.defineProperty(exports, "newIdempotencyKey", {
+	enumerable: true,
+	get: function() {
+		return newIdempotencyKey;
+	}
+});
+Object.defineProperty(exports, "prepareSubmitAssetOptions", {
+	enumerable: true,
+	get: function() {
+		return prepareSubmitAssetOptions;
+	}
+});
+Object.defineProperty(exports, "resolveConnectionOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveConnectionOptions;
+	}
+});