@craftainer/crud-sdk 0.0.0-stage → 0.1.0

package/dist/client-D0drumeA.mjs

@@ -0,0 +1,913 @@
+import { n as cacheScope } from "./auth-DwtNEKrw.mjs";
+//#region src/interfaces.ts
+/**
+* Folds `chain` (outermost first) around `terminal`, usually the network
+* `fetch`, into one `Next`. Each middleware's `next` is the rest of the
+* chain; an empty chain is `terminal`. A throwing middleware yields a
+* rejected promise.
+*/
+function composeMiddleware(chain, terminal) {
+	const dispatch = async (index, ctx) => {
+		const middleware = chain[index];
+		if (middleware === void 0) return terminal(ctx);
+		return middleware(ctx, (next) => dispatch(index + 1, next));
+	};
+	return (ctx) => dispatch(0, ctx);
+}
+//#endregion
+//#region src/errors.ts
+/**
+* Error hierarchy: client-side errors and RFC 9457 problem details (ADR-0004).
+* Mirrors the Python SDK class for class.
+*/
+/** Base class of every error this package throws on purpose. */
+var CrudError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+/** The call was refused before any request was sent. */
+var ClientError = class extends CrudError {};
+/** The resource does not support the operation (manifest capability or path missing). */
+var CapabilityError = class extends ClientError {};
+/** A filter, sort or paging argument is not valid for the resource. */
+var InvalidQueryError = class extends ClientError {};
+/** The discovery document or the manifest is missing, unusable or of an unknown version. */
+var ManifestError = class extends ClientError {};
+/** The manifest lists no such resource for this caller. */
+var UnknownResourceError = class extends ClientError {};
+/** A successful response whose body is not the JSON the client expects; `cause` holds the parse error. */
+var ResponseError = class extends CrudError {};
+/** The request never produced a response; `cause` holds the transport error. */
+var ConnectionFailed = class extends CrudError {};
+const NO_TYPE = "about:blank";
+/** An error response, as RFC 9457 problem details. */
+var ProblemError = class extends CrudError {
+	status;
+	title;
+	detail;
+	type;
+	instance;
+	errors;
+	headers;
+	response;
+	constructor(init) {
+		const errors = init.errors ?? [];
+		let message = `${init.status} ${init.title}`;
+		if (init.detail) message += `: ${init.detail}`;
+		else if (errors.length > 0) message += `: ${errors.map((e) => `${e.loc.join(".")}: ${e.msg}`).join("; ")}`;
+		super(message);
+		this.status = init.status;
+		this.title = init.title;
+		this.detail = init.detail;
+		this.type = init.type ?? NO_TYPE;
+		this.instance = init.instance;
+		this.errors = errors;
+		this.headers = init.headers ?? new Headers();
+		this.response = init.response;
+	}
+};
+/** 400. */
+var BadRequest = class extends ProblemError {};
+/** 401; `wwwAuthenticate` keeps the challenge. */
+var Unauthorized = class extends ProblemError {
+	get wwwAuthenticate() {
+		return this.headers.get("www-authenticate") ?? void 0;
+	}
+};
+/** 403. */
+var Forbidden = class extends ProblemError {};
+/** 404. */
+var NotFound = class extends ProblemError {};
+/** 412: a stale `If-Match`. */
+var PreconditionFailed = class extends ProblemError {};
+/** 422; `errors` holds normalized `{loc, msg, type}` entries. */
+var ValidationFailed = class extends ProblemError {};
+/** 423. */
+var Locked = class extends ProblemError {};
+/** 429; `retryAfter` is the `Retry-After` header in seconds, when it is a number. */
+var RateLimited = class extends ProblemError {
+	get retryAfter() {
+		const raw = this.headers.get("retry-after");
+		if (raw === null || raw.trim() === "") return;
+		const seconds = Number(raw);
+		return Number.isNaN(seconds) ? void 0 : seconds;
+	}
+};
+/** 5xx. */
+var ServerError = class extends ProblemError {};
+const BY_STATUS = /* @__PURE__ */ new Map([
+	[400, BadRequest],
+	[401, Unauthorized],
+	[403, Forbidden],
+	[404, NotFound],
+	[412, PreconditionFailed],
+	[422, ValidationFailed],
+	[423, Locked],
+	[429, RateLimited]
+]);
+const PHRASES = /* @__PURE__ */ new Map([
+	[100, "Continue"],
+	[101, "Switching Protocols"],
+	[102, "Processing"],
+	[103, "Early Hints"],
+	[200, "OK"],
+	[201, "Created"],
+	[202, "Accepted"],
+	[203, "Non-Authoritative Information"],
+	[204, "No Content"],
+	[205, "Reset Content"],
+	[206, "Partial Content"],
+	[207, "Multi-Status"],
+	[208, "Already Reported"],
+	[226, "IM Used"],
+	[300, "Multiple Choices"],
+	[301, "Moved Permanently"],
+	[302, "Found"],
+	[303, "See Other"],
+	[304, "Not Modified"],
+	[305, "Use Proxy"],
+	[307, "Temporary Redirect"],
+	[308, "Permanent Redirect"],
+	[400, "Bad Request"],
+	[401, "Unauthorized"],
+	[402, "Payment Required"],
+	[403, "Forbidden"],
+	[404, "Not Found"],
+	[405, "Method Not Allowed"],
+	[406, "Not Acceptable"],
+	[407, "Proxy Authentication Required"],
+	[408, "Request Timeout"],
+	[409, "Conflict"],
+	[410, "Gone"],
+	[411, "Length Required"],
+	[412, "Precondition Failed"],
+	[413, "Content Too Large"],
+	[414, "URI Too Long"],
+	[415, "Unsupported Media Type"],
+	[416, "Range Not Satisfiable"],
+	[417, "Expectation Failed"],
+	[418, "I'm a Teapot"],
+	[421, "Misdirected Request"],
+	[422, "Unprocessable Content"],
+	[423, "Locked"],
+	[424, "Failed Dependency"],
+	[425, "Too Early"],
+	[426, "Upgrade Required"],
+	[428, "Precondition Required"],
+	[429, "Too Many Requests"],
+	[431, "Request Header Fields Too Large"],
+	[451, "Unavailable For Legal Reasons"],
+	[500, "Internal Server Error"],
+	[501, "Not Implemented"],
+	[502, "Bad Gateway"],
+	[503, "Service Unavailable"],
+	[504, "Gateway Timeout"],
+	[505, "HTTP Version Not Supported"],
+	[506, "Variant Also Negotiates"],
+	[507, "Insufficient Storage"],
+	[508, "Loop Detected"],
+	[510, "Not Extended"],
+	[511, "Network Authentication Required"]
+]);
+const isObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizeErrors(items) {
+	return items.map((item) => {
+		if (isObject$1(item)) return {
+			loc: Array.isArray(item["loc"]) ? item["loc"] : [],
+			msg: String(item["msg"] ?? ""),
+			type: String(item["type"] ?? "")
+		};
+		return {
+			loc: [],
+			msg: String(item),
+			type: ""
+		};
+	});
+}
+/**
+* Builds the matching `ProblemError` subclass from an error response. A body
+* that is not a JSON object yields a synthesized problem from the status
+* phrase. Reads a clone, so `response.body` stays readable.
+*/
+async function problemFromResponse(response) {
+	const status = response.status;
+	const phrase = PHRASES.get(status) ?? "Error";
+	let parsed;
+	try {
+		parsed = JSON.parse(await response.clone().text());
+	} catch {
+		parsed = void 0;
+	}
+	const body = isObject$1(parsed) ? parsed : {};
+	const rawDetail = body["detail"];
+	const rawErrors = Array.isArray(rawDetail) ? rawDetail : body["errors"];
+	const Cls = BY_STATUS.get(status) ?? (status >= 500 ? ServerError : ProblemError);
+	const instance = body["instance"];
+	return new Cls({
+		status,
+		title: String(body["title"] || phrase),
+		detail: typeof rawDetail === "string" ? rawDetail : void 0,
+		type: String(body["type"] || NO_TYPE),
+		instance: typeof instance === "string" ? instance : void 0,
+		errors: Array.isArray(rawErrors) ? normalizeErrors(rawErrors) : [],
+		headers: response.headers,
+		response
+	});
+}
+//#endregion
+//#region src/manifest.ts
+/**
+* Typed models of the CRUD manifest (v1) and discovery via the api-catalog.
+* Members keep their wire names (`skip_param`, `max_age`, ...). Members this
+* version does not know are ignored, as the manifest spec requires.
+*/
+const PROFILE = "https://craftainer.github.io/schemas/crud-manifest/v1";
+const CATALOG_PATH = "/.well-known/api-catalog";
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function bad(where, key, what) {
+	throw new ManifestError(`${where}.${key}: ${what}`);
+}
+function str(obj, key, where) {
+	const value = obj[key];
+	return typeof value === "string" ? value : bad(where, key, "missing or not a string");
+}
+function bool(obj, key, where) {
+	const value = obj[key];
+	return typeof value === "boolean" ? value : bad(where, key, "missing or not a boolean");
+}
+function num(obj, key, where) {
+	const value = obj[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : bad(where, key, "missing or not a number");
+}
+function int(obj, key, where) {
+	const value = num(obj, key, where);
+	return Number.isInteger(value) ? value : bad(where, key, "not an integer");
+}
+function obj(parent, key, where) {
+	const value = parent[key];
+	return isObject(value) ? value : bad(where, key, "missing or not an object");
+}
+function list(parent, key, where) {
+	const value = parent[key];
+	return Array.isArray(value) ? value : bad(where, key, "missing or not a list");
+}
+function strs(parent, key, where) {
+	const items = list(parent, key, where);
+	return items.every((item) => typeof item === "string") ? items : bad(where, key, "expected a list of strings");
+}
+/** A member that may be absent or `null`. */
+function opt(parent, key, where, read) {
+	return parent[key] === void 0 || parent[key] === null ? null : read(parent, key, where);
+}
+function stringMap(parent, key, where) {
+	const out = {};
+	for (const [k, v] of Object.entries(obj(parent, key, where))) if (typeof v === "string") out[k] = v;
+	return out;
+}
+function objects(parent, key, where) {
+	return list(parent, key, where).map((item, i) => isObject(item) ? item : bad(`${where}.${key}`, `[${i}]`, "not an object"));
+}
+function parseField(o, w) {
+	return {
+		name: str(o, "name", w),
+		value_type: str(o, "value_type", w),
+		filter_ops: strs(o, "filter_ops", w),
+		sortable: bool(o, "sortable", w),
+		choices: opt(o, "choices", w, strs),
+		numeric: bool(o, "numeric", w),
+		categorical: bool(o, "categorical", w),
+		read_only: bool(o, "read_only", w),
+		required: bool(o, "required", w)
+	};
+}
+function parseEvents(o, w) {
+	return {
+		transport: str(o, "transport", w),
+		path: str(o, "path", w),
+		resource: str(o, "resource", w),
+		resume_param: str(o, "resume_param", w),
+		replay: str(o, "replay", w),
+		keepalive_seconds: num(o, "keepalive_seconds", w),
+		actions: strs(o, "actions", w)
+	};
+}
+function parseCapabilities(o, w) {
+	return {
+		bulk_update: bool(o, "bulk_update", w),
+		bulk_delete: bool(o, "bulk_delete", w),
+		clone: bool(o, "clone", w),
+		draft_publish: bool(o, "draft_publish", w),
+		archive_restore: bool(o, "archive_restore", w),
+		revisions: bool(o, "revisions", w),
+		events: opt(o, "events", w, (p, k, ww) => parseEvents(obj(p, k, ww), `${ww}.${k}`)),
+		stats: bool(o, "stats", w),
+		predict: bool(o, "predict", w),
+		conditional_requests: bool(o, "conditional_requests", w),
+		owner_scoped: bool(o, "owner_scoped", w),
+		schedulable: bool(o, "schedulable", w)
+	};
+}
+function parseResource(o, w) {
+	const schemas = obj(o, "schemas", w);
+	const pagination = obj(o, "pagination", w);
+	const auth = obj(o, "auth", w);
+	const cache = obj(o, "cache", w);
+	const sw = `${w}.schemas`;
+	return {
+		name: str(o, "name", w),
+		title: str(o, "title", w),
+		api_version: str(o, "api_version", w),
+		base_path: str(o, "base_path", w),
+		formats: stringMap(o, "formats", w),
+		id_field: str(o, "id_field", w),
+		schemas: {
+			read: obj(schemas, "read", sw),
+			create: obj(schemas, "create", sw),
+			update: obj(schemas, "update", sw),
+			draft: opt(schemas, "draft", sw, obj)
+		},
+		fields: objects(o, "fields", w).map((f, i) => parseField(f, `${w}.fields[${i}]`)),
+		pagination: {
+			style: str(pagination, "style", w),
+			skip_param: str(pagination, "skip_param", w),
+			limit_param: str(pagination, "limit_param", w),
+			sort_param: str(pagination, "sort_param", w),
+			default_limit: int(pagination, "default_limit", w),
+			max_limit: int(pagination, "max_limit", w),
+			total: bool(pagination, "total", w)
+		},
+		capabilities: parseCapabilities(obj(o, "capabilities", w), `${w}.capabilities`),
+		paths: stringMap(o, "paths", w),
+		bulk: { max_matched: int(obj(o, "bulk", w), "max_matched", `${w}.bulk`) },
+		auth: {
+			scheme: str(auth, "scheme", w),
+			oidc_discovery_url: opt(auth, "oidc_discovery_url", w, str),
+			public_read: bool(auth, "public_read", w),
+			read_roles: strs(auth, "read_roles", w),
+			write_roles: strs(auth, "write_roles", w),
+			delete_roles: strs(auth, "delete_roles", w)
+		},
+		cache: {
+			etag: bool(cache, "etag", w),
+			max_age: int(cache, "max_age", w),
+			stats_ttl: opt(cache, "stats_ttl", w, int),
+			stale_while_revalidate: int(cache, "stale_while_revalidate", w),
+			list_etag: opt(cache, "list_etag", w, str),
+			record_etag: opt(cache, "record_etag", w, str),
+			revalidate_only: bool(cache, "revalidate_only", w)
+		}
+	};
+}
+/** Parses a manifest document; unknown members are ignored, unknown versions refused. */
+function parseManifest(document) {
+	if (!isObject(document)) throw new ManifestError("the manifest is not a JSON object");
+	const version = str(document, "manifest_version", "manifest");
+	if (version !== "1") throw new ManifestError(`unsupported manifest_version "${version}"`);
+	const service = obj(document, "service", "manifest");
+	return {
+		manifest_version: version,
+		service: {
+			name: str(service, "name", "manifest.service"),
+			version: str(service, "version", "manifest.service")
+		},
+		resources: objects(document, "resources", "manifest").map((r, i) => parseResource(r, `resources[${i}]`))
+	};
+}
+/**
+* The resource called `name`: the one with `apiVersion` when given, else the
+* highest `api_version` (`v2` beats `v1`); `undefined` when there is none.
+*/
+function findResource(manifest, name, apiVersion) {
+	const rank = (r) => Number.parseInt(r.api_version.slice(1), 10) || 0;
+	let best;
+	for (const r of manifest.resources) if (r.name === name && (apiVersion === void 0 || r.api_version === apiVersion)) {
+		if (best === void 0 || rank(r) > rank(best)) best = r;
+	}
+	return best;
+}
+/** The absolute manifest URL: the first `describedby` link with the manifest profile. */
+function manifestUrlFromCatalog(linkset, catalogUrl) {
+	const entries = isObject(linkset) ? linkset["linkset"] : void 0;
+	for (const entry of Array.isArray(entries) ? entries : []) {
+		const links = isObject(entry) ? entry["describedby"] : void 0;
+		for (const link of Array.isArray(links) ? links : []) if (isObject(link) && link["profile"] === "https://craftainer.github.io/schemas/crud-manifest/v1" && typeof link["href"] === "string") {
+			const url = new URL(link["href"], catalogUrl);
+			if (url.origin !== new URL(catalogUrl).origin) throw new ManifestError(`the api-catalog points at another origin (${url.origin}); pass manifestUrl to use it`);
+			return url.href;
+		}
+	}
+	throw new ManifestError(`the api-catalog has no describedby link with profile ${PROFILE}`);
+}
+/**
+* Loads and parses the manifest, via api-catalog discovery from `baseUrl` or
+* a direct `manifestUrl`.
+*/
+async function loadManifest(getJson, baseUrl, manifestUrl) {
+	let url = manifestUrl;
+	if (url === void 0) {
+		const catalogUrl = new URL(CATALOG_PATH, baseUrl).href;
+		url = manifestUrlFromCatalog(await getJson(catalogUrl, true), catalogUrl);
+	}
+	return parseManifest(await getJson(url, false));
+}
+//#endregion
+//#region src/query.ts
+/**
+* Query-string builder with `crud_query` semantics, validated against the
+* manifest fields. Produces the same bytes as the Python SDK.
+*/
+const MAX_REGEX_LENGTH = 200;
+/** Percent-encodes everything but the RFC 3986 unreserved characters `A-Za-z0-9-._~`. */
+function quote(text) {
+	return encodeURIComponent(text).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+/** Joins already-stringified pairs, encoding keys and values. */
+function encodeParams(pairs) {
+	return pairs.map(([k, v]) => `${quote(k)}=${quote(v)}`).join("&");
+}
+function formatDatetime(value) {
+	if (Number.isNaN(value.getTime())) return;
+	const iso = value.toISOString();
+	if (iso.length !== 24) return;
+	const millis = iso.slice(20, 23).replace(/0+$/, "");
+	return millis === "" ? `${iso.slice(0, 19)}Z` : `${iso.slice(0, 19)}.${millis}Z`;
+}
+function formatDate(value) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return;
+	const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+	return Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== value ? void 0 : value;
+}
+function scalarText(kind, value) {
+	switch (kind) {
+		case "integer": return typeof value === "number" && Number.isSafeInteger(value) ? String(value) : void 0;
+		case "number": return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+		case "boolean": return typeof value === "boolean" ? String(value) : void 0;
+		case "date": return typeof value === "string" ? formatDate(value) : void 0;
+		case "datetime": return value instanceof Date ? formatDatetime(value) : void 0;
+		default: return typeof value === "string" ? value : void 0;
+	}
+}
+/**
+* Wire form of one value for `field`; throws `InvalidQueryError` on a type
+* mismatch. Dates are `YYYY-MM-DD` strings, datetimes `Date`s (UTC, with
+* millisecond precision, trailing zeros trimmed).
+*/
+function formatScalar(field, value) {
+	const text = scalarText(field.value_type, value);
+	if (text === void 0) throw new InvalidQueryError(`field "${field.name}" (${field.value_type}) cannot take ${String(value)}`);
+	if (field.value_type === "enum" && field.choices !== null && !field.choices.includes(text)) throw new InvalidQueryError(`field "${field.name}" accepts only ${JSON.stringify(field.choices)}, not "${text}"`);
+	return text;
+}
+function filterPair(field, op, value) {
+	const key = op === "eq" ? field.name : `${field.name}__${op}`;
+	if (op === "in") {
+		if (!Array.isArray(value) || value.length === 0) throw new InvalidQueryError(`"${key}" takes a non-empty array`);
+		const parts = value.map((item) => formatScalar(field, item));
+		if (parts.some((part) => part.includes(","))) throw new InvalidQueryError(`"${key}": a value contains a comma, which separates the list`);
+		return [key, parts.map(quote).join(",")];
+	}
+	const text = formatScalar(field, value);
+	if (op === "regex" && [...text].length > MAX_REGEX_LENGTH) throw new InvalidQueryError(`"${key}": a regex is limited to ${MAX_REGEX_LENGTH} characters`);
+	return [key, quote(text)];
+}
+const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function filterPairs(fields, filters) {
+	const parsed = /* @__PURE__ */ new Map();
+	for (const [rawKey, value] of Object.entries(filters)) {
+		const at = rawKey.lastIndexOf("__");
+		const name = at < 0 ? rawKey : rawKey.slice(0, at);
+		const op = at < 0 ? "eq" : rawKey.slice(at + 2);
+		const field = fields.get(name);
+		if (field === void 0) throw new InvalidQueryError(`unknown filter field "${name}"`);
+		if (!field.filter_ops.includes(op)) throw new InvalidQueryError(`field "${name}" does not support the "${op}" operator`);
+		if (name === "id" && op === "eq") throw new InvalidQueryError("filter on id with recordId, not an equality filter");
+		const id = `${name}\u0000${op}`;
+		if (parsed.has(id)) throw new InvalidQueryError(`filter "${name}" "${op}" given twice`);
+		parsed.set(id, {
+			name,
+			op,
+			pair: filterPair(field, op, value)
+		});
+	}
+	return [...parsed.values()].sort((a, b) => compare(a.name, b.name) || compare(a.op, b.op)).map((entry) => entry.pair);
+}
+function sortValue(fields, sort) {
+	const out = (typeof sort === "string" ? sort.split(",") : sort).map((part) => {
+		const name = part.startsWith("-") ? part.slice(1) : part;
+		const field = fields.get(name);
+		if (field === void 0 || !field.sortable) throw new InvalidQueryError(`cannot sort by "${name}"`);
+		return quote(part);
+	});
+	if (out.length === 0) throw new InvalidQueryError("sort is empty");
+	return out.join(",");
+}
+function intArg(name, value, minimum) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum) throw new InvalidQueryError(`${name} must be an integer >= ${minimum}`);
+	return String(value);
+}
+/**
+* The query string (no leading `?`) for a list, get or bulk call. Order of
+* parameters: `id`, filters sorted by (field, operator), sort, skip, limit,
+* `include_archived`, `include_unpublished`. The sort/skip/limit names are
+* `sortParam`/`skipParam`/`limitParam` (the manifest's `pagination`); the
+* `id` parameter is always `id`. Flags are emitted whenever they are not
+* `undefined`.
+*/
+function buildQuery(fields, params = {}) {
+	const byName = new Map(fields.map((f) => [f.name, f]));
+	const parts = [];
+	if (params.recordId !== void 0) parts.push(`id=${intArg("recordId", params.recordId, 0)}`);
+	for (const [key, value] of filterPairs(byName, params.filters ?? {})) parts.push(`${quote(key)}=${value}`);
+	if (params.sort !== void 0) parts.push(`${quote(params.sortParam ?? "sort")}=${sortValue(byName, params.sort)}`);
+	if (params.skip !== void 0) parts.push(`${quote(params.skipParam ?? "skip")}=${intArg("skip", params.skip, 0)}`);
+	if (params.limit !== void 0) {
+		const text = intArg("limit", params.limit, 1);
+		if (params.maxLimit !== void 0 && params.limit > params.maxLimit) throw new InvalidQueryError(`limit ${params.limit} exceeds the server maximum ${params.maxLimit}`);
+		parts.push(`${quote(params.limitParam ?? "limit")}=${text}`);
+	}
+	if (params.includeArchived !== void 0) parts.push(`include_archived=${params.includeArchived}`);
+	if (params.includeUnpublished !== void 0) parts.push(`include_unpublished=${params.includeUnpublished}`);
+	return parts.join("&");
+}
+//#endregion
+//#region src/client.ts
+/** Fetch client: manifest-driven resource handles over a middleware chain. */
+const joinUrl = (base, path) => new URL(path, base).href;
+/** Builds the requests of one resource. */
+var Plan = class {
+	#baseUrl;
+	resource;
+	constructor(baseUrl, resource) {
+		this.#baseUrl = baseUrl;
+		this.resource = resource;
+	}
+	#call(method, op, path, query = "", extra = {}) {
+		return {
+			method,
+			url: joinUrl(this.#baseUrl, path) + (query === "" ? "" : `?${query}`),
+			op,
+			resource: this.resource.name,
+			recordId: extra.recordId,
+			apiVersion: this.resource.api_version,
+			...extra.json === void 0 ? {} : { json: extra.json },
+			...extra.ifMatch === void 0 ? {} : { headers: { "If-Match": extra.ifMatch } }
+		};
+	}
+	#query(params = {}) {
+		const paging = this.resource.pagination;
+		return buildQuery(this.resource.fields, {
+			maxLimit: paging.max_limit,
+			skipParam: paging.skip_param,
+			limitParam: paging.limit_param,
+			sortParam: paging.sort_param,
+			...params
+		});
+	}
+	#subPath(key, supported) {
+		const path = this.resource.paths[key];
+		if (!supported || path === void 0) throw new CapabilityError(`resource "${this.resource.name}" does not support ${key}`);
+		return path;
+	}
+	#need(supported, what) {
+		if (!supported) throw new CapabilityError(`resource "${this.resource.name}" does not support ${what}`);
+	}
+	#bulkFilters(filters) {
+		if (Object.keys(filters).length === 0) throw new InvalidQueryError("a bulk operation needs at least one filter");
+		return this.#query({ filters });
+	}
+	get #base() {
+		return this.resource.base_path;
+	}
+	eventsUrl() {
+		const events = this.resource.capabilities.events;
+		if (events === null) throw new CapabilityError(`resource "${this.resource.name}" does not support events`);
+		return joinUrl(this.#baseUrl, events.path);
+	}
+	list(o) {
+		const query = this.#query({
+			filters: o.filters,
+			sort: o.sort,
+			skip: o.skip,
+			limit: o.limit,
+			includeArchived: o.includeArchived,
+			includeUnpublished: o.includeUnpublished
+		});
+		return this.#call("GET", "list", this.#base, query);
+	}
+	get(id) {
+		return this.#call("GET", "record", this.#base, this.#query({ recordId: id }), { recordId: id });
+	}
+	create(data) {
+		return this.#call("POST", "create", this.#base, "", { json: data });
+	}
+	update(id, data, ifMatch) {
+		return this.#call("PATCH", "update", this.#base, this.#query({ recordId: id }), {
+			recordId: id,
+			json: data,
+			ifMatch
+		});
+	}
+	updateMany(filters, data) {
+		this.#need(this.resource.capabilities.bulk_update, "bulk_update");
+		return this.#call("PATCH", "bulk_update", this.#base, this.#bulkFilters(filters), { json: data });
+	}
+	delete(id, ifMatch) {
+		return this.#call("DELETE", "delete", this.#base, this.#query({ recordId: id }), {
+			recordId: id,
+			ifMatch
+		});
+	}
+	deleteMany(filters) {
+		this.#need(this.resource.capabilities.bulk_delete, "bulk_delete");
+		return this.#call("DELETE", "bulk_delete", this.#base, this.#bulkFilters(filters));
+	}
+	restore(id, filters) {
+		const path = this.#subPath("restore", this.resource.capabilities.archive_restore);
+		if (id === void 0 === (filters === void 0)) throw new InvalidQueryError("restore takes exactly one of id and filters");
+		const query = filters === void 0 ? this.#query({ recordId: id }) : this.#bulkFilters(filters);
+		return this.#call("POST", "restore", path, query, { recordId: id });
+	}
+	stats(o) {
+		const path = this.#subPath("stats", this.resource.capabilities.stats);
+		const pairs = o.bucket === void 0 ? [] : [["bucket", o.bucket]];
+		if (o.includeArchived !== void 0) pairs.push(["include_archived", String(o.includeArchived)]);
+		if (o.includeUnpublished !== void 0) pairs.push(["include_unpublished", String(o.includeUnpublished)]);
+		return this.#call("GET", "stats", path, encodeParams(pairs));
+	}
+	predict(o) {
+		const path = this.#subPath("predict", this.resource.capabilities.predict);
+		const pairs = [];
+		if (o.field !== void 0) {
+			const spec = this.resource.fields.find((f) => f.name === o.field);
+			if (spec === void 0 || !spec.numeric) throw new InvalidQueryError(`cannot predict "${o.field}": not a numeric field`);
+			pairs.push(["field", o.field]);
+		}
+		if (o.periods !== void 0) {
+			if (!Number.isSafeInteger(o.periods) || o.periods < 1) throw new InvalidQueryError("periods must be an integer >= 1");
+			pairs.push(["periods", String(o.periods)]);
+		}
+		if (o.bucket !== void 0) pairs.push(["bucket", o.bucket]);
+		return this.#call("GET", "predict", path, encodeParams(pairs));
+	}
+	clone(id) {
+		const path = this.#subPath("clone", this.resource.capabilities.clone);
+		return this.#call("POST", "clone", path, this.#query({ recordId: id }), { recordId: id });
+	}
+	draft(data) {
+		const path = this.#subPath("draft", this.resource.capabilities.draft_publish);
+		return this.#call("POST", "draft", path, "", { json: data });
+	}
+	publish(id) {
+		const path = this.#subPath("publish", this.resource.capabilities.draft_publish);
+		return this.#call("POST", "publish", path, this.#query({ recordId: id }), { recordId: id });
+	}
+	filters() {
+		return this.#call("GET", "filters", this.#subPath("filters", true));
+	}
+	revisions(id) {
+		const path = this.#subPath("revisions", this.resource.capabilities.revisions);
+		return this.#call("GET", "revisions", path, this.#query({ recordId: id }), { recordId: id });
+	}
+};
+/**
+* Operations on one resource. The type parameters are the record views;
+* `crud-sdk-codegen` writes interfaces to pass for them (they are not
+* checked against the manifest at runtime).
+*/
+var ResourceClient = class {
+	/** The manifest entry this handle is bound to. */
+	resource;
+	#plan;
+	#transport;
+	/** Use `CrudClient.resource`. */
+	constructor(baseUrl, resource, transport) {
+		this.resource = resource;
+		this.#plan = new Plan(baseUrl, resource);
+		this.#transport = transport;
+	}
+	async #one(call, options) {
+		return await this.#transport.json(call, options.signal);
+	}
+	/** One page of records. */
+	async list(options = {}) {
+		return this.#one(this.#plan.list(options), options);
+	}
+	/** Every record, paging with `skip += limit` until a page shorter than `limit`. */
+	async *iterAll(options = {}) {
+		const size = options.limit ?? this.resource.pagination.default_limit;
+		let skip = options.skip ?? 0;
+		for (;;) {
+			const page = await this.list({
+				...options,
+				skip,
+				limit: size
+			});
+			yield* page;
+			if (page.length < size) return;
+			skip += size;
+		}
+	}
+	/** One record. */
+	async get(id, options = {}) {
+		return this.#one(this.#plan.get(id), options);
+	}
+	/** Creates a record. */
+	async create(data, options = {}) {
+		return this.#one(this.#plan.create(data), options);
+	}
+	/** Patches one record; `ifMatch` is an ETag (`412` when stale). */
+	async update(id, data, options = {}) {
+		return this.#one(this.#plan.update(id, data, options.ifMatch), options);
+	}
+	/** Patches every record matching `filters`. */
+	async updateMany(filters, data, options = {}) {
+		return this.#one(this.#plan.updateMany(filters, data), options);
+	}
+	/** Deletes one record; `ifMatch` as for `update`. */
+	async delete(id, options = {}) {
+		await this.#transport.none(this.#plan.delete(id, options.ifMatch), options.signal);
+	}
+	/** Deletes every record matching `filters`. */
+	async deleteMany(filters, options = {}) {
+		return this.#one(this.#plan.deleteMany(filters), options);
+	}
+	/** Restores archived records, by `id` or by `filters`. */
+	async restore(options) {
+		return this.#one(this.#plan.restore(options.id, options.filters), options);
+	}
+	/** Aggregates over the resource. */
+	async stats(options = {}) {
+		return this.#one(this.#plan.stats(options), options);
+	}
+	/** A forecast. */
+	async predict(options = {}) {
+		return this.#one(this.#plan.predict(options), options);
+	}
+	/** Copies a record; returns the copy. */
+	async clone(id, options = {}) {
+		return this.#one(this.#plan.clone(id), options);
+	}
+	/** Creates a draft (needs `draft_publish`). */
+	async createDraft(data, options = {}) {
+		return this.#one(this.#plan.draft(data), options);
+	}
+	/** Publishes a draft (needs `draft_publish`). */
+	async publish(id, options = {}) {
+		return this.#one(this.#plan.publish(id), options);
+	}
+	/** The server's filter metadata (`kind` instead of `value_type`). */
+	async filters(options = {}) {
+		return this.#one(this.#plan.filters(), options);
+	}
+	/** Revisions of one record, newest first. */
+	async revisions(id, options = {}) {
+		return this.#one(this.#plan.revisions(id), options);
+	}
+	/** Absolute URL of the resource's SSE stream. */
+	eventsUrl() {
+		return this.#plan.eventsUrl();
+	}
+};
+/** Discovers the manifest and hands out {@link ResourceClient}s. */
+var CrudClient = class {
+	baseUrl;
+	#fetch;
+	#tokenProvider;
+	#middleware;
+	#manifestUrl;
+	#manifests = /* @__PURE__ */ new Map();
+	#transport;
+	constructor(options) {
+		this.baseUrl = options.baseUrl;
+		this.#fetch = options.fetch;
+		this.#tokenProvider = options.tokenProvider;
+		this.#middleware = [...options.middleware ?? []];
+		this.#manifestUrl = options.manifestUrl;
+		this.#transport = {
+			json: async (call, signal) => {
+				const response = await this.#send(call, signal);
+				if (response.status === 204) return;
+				try {
+					return await response.json();
+				} catch (error) {
+					throw new ResponseError(`${call.method} ${call.url}: the ${response.status} response body is not valid JSON`, { cause: error });
+				}
+			},
+			none: async (call, signal) => {
+				await (await this.#send(call, signal)).body?.cancel();
+			}
+		};
+	}
+	/** Adds middleware after the existing ones (innermost); it sees every later request. */
+	use(middleware) {
+		this.#middleware.push(middleware);
+		return this;
+	}
+	async #token(refresh) {
+		return await this.#tokenProvider?.({ refresh }) || null;
+	}
+	/** The current bearer token, or `null` when anonymous. */
+	token(refresh = false) {
+		return this.#token(refresh);
+	}
+	/** The cache scope of the current caller (`"anon"` or a hash of the token). */
+	async scope() {
+		return cacheScope(await this.#token(false));
+	}
+	async #dispatch(call, token, signal) {
+		const headers = new Headers({
+			Accept: "application/json",
+			...call.headers
+		});
+		if (token !== null) headers.set("Authorization", `Bearer ${token}`);
+		const init = {
+			method: call.method,
+			headers,
+			signal: signal ?? null
+		};
+		if (call.json !== void 0) {
+			headers.set("Content-Type", "application/json");
+			init.body = JSON.stringify(call.json);
+		}
+		const request = new Request(call.url, init);
+		const terminal = async (ctx) => {
+			try {
+				return await (this.#fetch ?? globalThis.fetch)(ctx.request);
+			} catch (error) {
+				if (ctx.request.signal.aborted) throw error;
+				throw new ConnectionFailed(error instanceof Error ? error.message : String(error), { cause: error });
+			}
+		};
+		return composeMiddleware(this.#middleware, terminal)({
+			request,
+			resource: call.resource,
+			op: call.op,
+			recordId: call.recordId,
+			scope: await cacheScope(token),
+			apiVersion: call.apiVersion,
+			signal
+		});
+	}
+	/** Sends `call`, retrying once with a refreshed token after a `401`; throws on `>= 400`. */
+	async #send(call, signal) {
+		const token = await this.#token(false);
+		let response = await this.#dispatch(call, token, signal);
+		if (response.status === 401 && this.#tokenProvider !== void 0) {
+			const fresh = await this.#token(true);
+			if (fresh !== null && fresh !== token) {
+				await response.body?.cancel();
+				response = await this.#dispatch(call, fresh, signal);
+			}
+		}
+		if (response.status >= 400) throw await problemFromResponse(response);
+		return response;
+	}
+	async #getJson(url, catalog) {
+		const call = {
+			method: "GET",
+			url,
+			op: "manifest",
+			resource: void 0,
+			recordId: void 0,
+			apiVersion: null,
+			...catalog ? { headers: { "Cache-Control": "no-store" } } : {}
+		};
+		const response = await this.#send(call, void 0);
+		try {
+			return await response.json();
+		} catch (error) {
+			throw new ManifestError(`${url} is not JSON`, { cause: error });
+		}
+	}
+	/** The manifest for this caller, loaded once per caller scope (`refresh: true` reloads). */
+	async manifest(options = {}) {
+		const scope = await this.scope();
+		let loading = this.#manifests.get(scope);
+		if (loading === void 0 || options.refresh === true) {
+			const started = loadManifest((url, catalog) => this.#getJson(url, catalog), this.baseUrl, this.#manifestUrl);
+			loading = started;
+			if (!this.#manifests.has(scope)) this.#manifests.clear();
+			this.#manifests.set(scope, started);
+			started.catch(() => {
+				if (this.#manifests.get(scope) === started) this.#manifests.delete(scope);
+			});
+		}
+		return loading;
+	}
+	/** A handle for `name` (the highest `api_version` unless given). */
+	async resource(name, apiVersion) {
+		const resource = findResource(await this.manifest(), name, apiVersion);
+		if (resource === void 0) throw new UnknownResourceError(`the manifest has no resource "${name}"${apiVersion === void 0 ? "" : ` ${apiVersion}`} for this caller`);
+		return new ResourceClient(this.baseUrl, resource, this.#transport);
+	}
+};
+/** Creates a client; the manifest loads on first use. */
+function createClient(options) {
+	return new CrudClient(options);
+}
+//#endregion
+export { UnknownResourceError as A, NotFound as C, ResponseError as D, RateLimited as E, problemFromResponse as M, composeMiddleware as N, ServerError as O, ManifestError as S, ProblemError as T, ConnectionFailed as _, encodeParams as a, InvalidQueryError as b, CATALOG_PATH as c, loadManifest as d, manifestUrlFromCatalog as f, ClientError as g, CapabilityError as h, buildQuery as i, ValidationFailed as j, Unauthorized as k, PROFILE as l, BadRequest as m, ResourceClient as n, formatScalar as o, parseManifest as p, createClient as r, quote as s, CrudClient as t, findResource as u, CrudError as v, PreconditionFailed as w, Locked as x, Forbidden as y };
+
+//# sourceMappingURL=client-D0drumeA.mjs.map