@riducms/sdk 0.1.0

package/dist/client.js

@@ -0,0 +1,862 @@
+import { isPageEnvelope, } from "@riducms/protocol";
+import { RiduError } from "./error.js";
+export function createClient(options) {
+    return new FetchClient(options);
+}
+class FetchClient {
+    #baseURL;
+    #fetch;
+    #headers;
+    #credentials;
+    #dispatch;
+    constructor(options) {
+        const baseURL = new URL(options.baseURL);
+        this.#baseURL = baseURL.href.replace(/\/$/, "");
+        this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.#headers = options.headers;
+        this.#credentials = options.credentials ?? "include";
+        this.#dispatch = composeMiddleware(options.middleware ?? [], (request) => this.#fetch(request));
+    }
+    async schema(options) {
+        const body = await this.#request("/api/schema", { method: "GET" }, options);
+        if (!isRecord(body) || !isRecord(body.schema) || !Array.isArray(body.schema.collections)) {
+            throw invalidSuccessEnvelope("schema");
+        }
+        return body.schema;
+    }
+    async request(path, init = {}, options) {
+        return this.#response(path, init, options, false);
+    }
+    async requestPlugin(plugin, path, body, options) {
+        if (!/^[a-z][a-z0-9-]*$/.test(plugin))
+            throw new TypeError("invalid plugin key");
+        const segments = path.split("/");
+        if (path.length === 0 ||
+            path.trim() !== path ||
+            /[\s?#*]/u.test(path) ||
+            segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+            throw new TypeError("invalid plugin endpoint path");
+        }
+        const encodedPath = segments.map((segment) => encodeURIComponent(segment)).join("/");
+        return (await this.#request(`/api/plugins/${encodeURIComponent(plugin)}/${encodedPath}`, { method: "POST", body: JSON.stringify(body) }, options));
+    }
+    async preference(key, options) {
+        const body = await this.#request(`/api/preferences/${encodeURIComponent(key)}`, { method: "GET" }, options);
+        if (!isRecord(body) || !("value" in body))
+            throw invalidSuccessEnvelope("preference");
+        return body.value;
+    }
+    async setPreference(key, value, options) {
+        const body = await this.#request(`/api/preferences/${encodeURIComponent(key)}`, { method: "PUT", body: JSON.stringify({ value }) }, options);
+        if (!isRecord(body) || !("value" in body))
+            throw invalidSuccessEnvelope("preference");
+        return body.value;
+    }
+    async deletePreference(key, options) {
+        const body = await this.#request(`/api/preferences/${encodeURIComponent(key)}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || body.deleted !== true || typeof body.id !== "string") {
+            throw invalidSuccessEnvelope("delete preference");
+        }
+        return { id: body.id, deleted: true };
+    }
+    async resetPreferences(options) {
+        const body = await this.#request("/api/preferences", { method: "DELETE" }, options);
+        if (!isRecord(body) || body.success !== true) {
+            throw invalidSuccessEnvelope("preference reset");
+        }
+        return { success: true };
+    }
+    async collectionAccess(collection, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/access/collections/${encodeURIComponent(collection)}${suffix}`, {
+            method: "POST",
+            body: JSON.stringify({
+                ...(options?.id === undefined ? {} : { id: options.id }),
+                ...(options?.data === undefined ? {} : { data: options.data }),
+                ...(options?.trash === true ? { trash: true } : {}),
+            }),
+        }, options);
+        return accessCapabilitiesFromEnvelope(body);
+    }
+    async resolveFilteredSelection(collection, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/access/collections/${encodeURIComponent(collection)}/selection${suffix}`, {
+            method: "POST",
+            body: JSON.stringify({
+                ...(options?.where === undefined ? {} : { where: options.where }),
+                ...(options?.trash === true ? { trash: true } : {}),
+            }),
+        }, options);
+        return collectionSelectionFromEnvelope(body);
+    }
+    async globalAccess(slug, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/access/globals/${encodeURIComponent(slug)}${suffix}`, {
+            method: "POST",
+            body: JSON.stringify(options?.data === undefined ? {} : { data: options.data }),
+        }, options);
+        return accessCapabilitiesFromEnvelope(body);
+    }
+    async createPreviewToken(collection, id, options) {
+        const body = await this.#request(`/api/preview/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/token`, { method: "POST" }, options);
+        return previewTokenFromEnvelope(body);
+    }
+    async revokePreviewToken(token, options) {
+        const body = await this.#request("/api/preview/token/revoke", { method: "POST", body: JSON.stringify({ token }) }, options);
+        if (!isRecord(body) || body.success !== true) {
+            throw invalidSuccessEnvelope("preview token revocation");
+        }
+        return { success: true };
+    }
+    async preview(collection, id, token, options) {
+        const body = await this.#request(`/api/preview/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}`, { method: "GET" }, previewRequestOptions(options, token));
+        return documentFromEnvelope(body);
+    }
+    async createGlobalPreviewToken(slug, options) {
+        const body = await this.#request(`/api/preview/globals/${encodeURIComponent(slug)}/token`, { method: "POST" }, options);
+        return previewTokenFromEnvelope(body);
+    }
+    async previewGlobal(slug, token, options) {
+        const body = await this.#request(`/api/preview/globals/${encodeURIComponent(slug)}`, { method: "GET" }, previewRequestOptions(options, token));
+        return documentFromEnvelope(body);
+    }
+    async login(collection, credentials, options) {
+        const body = await this.#request(`/api/auth/${encodeURIComponent(collection)}/login`, { method: "POST", body: JSON.stringify(credentials) }, options);
+        return sessionFromEnvelope(body);
+    }
+    async session(options) {
+        const body = await this.#request("/api/auth/me", { method: "GET" }, options);
+        return sessionFromEnvelope(body);
+    }
+    async refreshSession(options) {
+        const body = await this.#request("/api/auth/refresh", { method: "POST" }, options);
+        return sessionFromEnvelope(body);
+    }
+    async logout(options) {
+        const body = await this.#request("/api/auth/logout", { method: "POST" }, options);
+        if (!isRecord(body) || body.loggedOut !== true) {
+            throw invalidSuccessEnvelope("logout");
+        }
+        return { loggedOut: true };
+    }
+    async logoutAll(options) {
+        const body = await this.#request("/api/auth/logout-all", { method: "POST" }, options);
+        if (!isRecord(body) || body.loggedOut !== true) {
+            throw invalidSuccessEnvelope("logout-all");
+        }
+        return { loggedOut: true };
+    }
+    async sessions(options) {
+        const body = await this.#request("/api/auth/sessions", { method: "GET" }, options);
+        if (!isRecord(body) ||
+            !Array.isArray(body.sessions) ||
+            !body.sessions.every(isAuthSessionInfo)) {
+            throw invalidSuccessEnvelope("sessions");
+        }
+        return body.sessions;
+    }
+    async revokeSession(id, options) {
+        const body = await this.#request(`/api/auth/sessions/${encodeURIComponent(id)}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || body.id !== id || body.deleted !== true) {
+            throw invalidSuccessEnvelope("session revocation");
+        }
+        return { id, deleted: true };
+    }
+    async requestPasswordReset(collection, email, options) {
+        return this.#authAction(collection, "forgot-password", { email }, options);
+    }
+    async resetPassword(collection, token, password, options) {
+        return this.#authAction(collection, "reset-password", { token, password }, options);
+    }
+    async authBootstrap(collection, options) {
+        const body = await this.#request(`/api/auth/${encodeURIComponent(collection)}/bootstrap`, { method: "GET" }, options);
+        if (!isRecord(body) || typeof body.available !== "boolean") {
+            throw invalidSuccessEnvelope("auth bootstrap");
+        }
+        return { available: body.available };
+    }
+    async createAuthUser(collection, data, password, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/auth/${encodeURIComponent(collection)}/create-user${suffix}`, { method: "POST", body: JSON.stringify({ data, password }) }, options);
+        return documentFromEnvelope(body);
+    }
+    async requestVerification(collection, email, options) {
+        return this.#authAction(collection, "request-verification", { email }, options);
+    }
+    async verifyEmail(collection, token, options) {
+        return this.#authAction(collection, "verify", { token }, options);
+    }
+    async changePassword(currentPassword, password, options) {
+        const body = await this.#request("/api/auth/change-password", { method: "POST", body: JSON.stringify({ currentPassword, password }) }, options);
+        if (!isRecord(body) || body.success !== true) {
+            throw invalidSuccessEnvelope("password change");
+        }
+        return { success: true };
+    }
+    async createAPIKey(input, options) {
+        const body = await this.#request("/api/auth/api-keys", { method: "POST", body: JSON.stringify(input) }, options);
+        if (!isRecord(body) || !isAPIKey(body.apiKey, true)) {
+            throw invalidSuccessEnvelope("API key");
+        }
+        return body.apiKey;
+    }
+    async apiKeys(options) {
+        const body = await this.#request("/api/auth/api-keys", { method: "GET" }, options);
+        if (!isRecord(body) ||
+            !Array.isArray(body.apiKeys) ||
+            !body.apiKeys.every((key) => isAPIKey(key, false))) {
+            throw invalidSuccessEnvelope("API keys");
+        }
+        return body.apiKeys;
+    }
+    async revokeAPIKey(id, options) {
+        const body = await this.#request(`/api/auth/api-keys/${encodeURIComponent(id)}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || body.id !== id || body.deleted !== true) {
+            throw invalidSuccessEnvelope("API key revocation");
+        }
+        return { id, deleted: true };
+    }
+    async forceUnlock(collection, id, options) {
+        const body = await this.#request(`/api/auth/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/unlock`, { method: "POST" }, options);
+        if (!isRecord(body) || body.success !== true) {
+            throw invalidSuccessEnvelope("account unlock");
+        }
+        return { success: true };
+    }
+    async documentLock(collection, id, options) {
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/lock`, { method: "GET" }, options);
+        return documentLockFromEnvelope(body);
+    }
+    async acquireDocumentLock(collection, id, takeover = false, options) {
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/lock`, { method: "POST", body: JSON.stringify({ takeover }) }, options);
+        return documentLockFromEnvelope(body);
+    }
+    async releaseDocumentLock(collection, id, options) {
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/lock`, { method: "DELETE" }, options);
+        if (!isRecord(body) || body.id !== id || body.deleted !== true) {
+            throw invalidSuccessEnvelope("document lock release");
+        }
+        return { id, deleted: true };
+    }
+    async #authAction(collection, action, input, options) {
+        const body = await this.#request(`/api/auth/${encodeURIComponent(collection)}/${action}`, { method: "POST", body: JSON.stringify(input) }, options);
+        if (!isRecord(body) || body.success !== true) {
+            throw invalidSuccessEnvelope("auth action");
+        }
+        return { success: true };
+    }
+    async list(collection, options) {
+        const query = new URLSearchParams();
+        if (options?.page !== undefined)
+            query.set("page", String(options.page));
+        if (options?.limit !== undefined)
+            query.set("limit", String(options.limit));
+        if (options?.depth !== undefined)
+            query.set("depth", String(options.depth));
+        if (options?.where !== undefined)
+            query.set("where", JSON.stringify(options.where));
+        if (options?.select !== undefined)
+            query.set("select", JSON.stringify(options.select));
+        if (options?.populate !== undefined)
+            query.set("populate", JSON.stringify(options.populate));
+        if (options?.trash === true)
+            query.set("trash", "true");
+        appendLocaleQuery(query, options);
+        for (const sort of options?.sort ?? [])
+            query.append("sort", sort);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}${suffix}`, { method: "GET" }, options);
+        if (!isPageEnvelope(body)) {
+            throw invalidSuccessEnvelope("page");
+        }
+        return body;
+    }
+    async count(collection, options) {
+        const query = new URLSearchParams();
+        if (options?.where !== undefined)
+            query.set("where", JSON.stringify(options.where));
+        if (options?.trash === true)
+            query.set("trash", "true");
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/count${suffix}`, { method: "GET" }, options);
+        if (!isRecord(body) || typeof body.totalDocs !== "number") {
+            throw invalidSuccessEnvelope("count");
+        }
+        return { totalDocs: body.totalDocs };
+    }
+    async find(collection, id, options) {
+        const query = new URLSearchParams();
+        if (options?.depth !== undefined)
+            query.set("depth", String(options.depth));
+        if (options?.select !== undefined)
+            query.set("select", JSON.stringify(options.select));
+        if (options?.populate !== undefined)
+            query.set("populate", JSON.stringify(options.populate));
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}${suffix}`, { method: "GET" }, options);
+        return documentFromEnvelope(body);
+    }
+    async create(collection, data, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        appendDraftQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}${suffix}`, { method: "POST", body: JSON.stringify(data) }, options);
+        return documentFromEnvelope(body);
+    }
+    async duplicate(collection, id, overrides = {}, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/duplicate${suffix}`, { method: "POST", body: JSON.stringify(overrides) }, options);
+        return documentFromEnvelope(body);
+    }
+    async copyLocale(collection, id, input, options) {
+        const revision = revisionHeaders(options);
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/copy-locale`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async update(collection, id, data, options) {
+        const revision = revisionHeaders(options);
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}${suffix}`, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async upload(collection, file, options) {
+        const form = new FormData();
+        form.set("file", file);
+        if (options?.data !== undefined)
+            form.set("data", JSON.stringify(options.data));
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request("/api/collections/" + encodeURIComponent(collection) + suffix, { method: "POST", body: form }, options);
+        return documentFromEnvelope(body);
+    }
+    async uploadFromURL(collection, url, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/remote-upload${suffix}`, { method: "POST", body: JSON.stringify({ url, data: options?.data ?? {} }) }, options);
+        return documentFromEnvelope(body);
+    }
+    async updateUploadImage(collection, id, input, options) {
+        const revision = revisionHeaders(options);
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/image`, {
+            method: "PATCH",
+            body: JSON.stringify(input),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async versions(collection, id, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request("/api/collections/" +
+            encodeURIComponent(collection) +
+            "/" +
+            encodeDocumentID(id) +
+            `/versions${suffix}`, { method: "GET" }, options);
+        if (!isRecord(body) || !Array.isArray(body.versions)) {
+            throw invalidSuccessEnvelope("versions");
+        }
+        return body.versions;
+    }
+    async version(collection, id, revision, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/versions/${revision}${suffix}`, { method: "GET" }, options);
+        if (!isRecord(body) || !isRecord(body.version)) {
+            throw invalidSuccessEnvelope("version");
+        }
+        return body.version;
+    }
+    async schedulePublish(collection, id, runAt, options) {
+        const headers = revisionHeaders(options);
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/schedule`, {
+            method: "POST",
+            body: JSON.stringify({ runAt: runAt instanceof Date ? runAt.toISOString() : runAt }),
+            ...(headers === undefined ? {} : { headers }),
+        }, options);
+        if (!isRecord(body) || !isScheduledPublish(body.scheduledPublish)) {
+            throw invalidSuccessEnvelope("scheduled publish");
+        }
+        return body.scheduledPublish;
+    }
+    async scheduledPublishes(collection, id, options) {
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/schedule`, { method: "GET" }, options);
+        if (!isRecord(body) ||
+            !Array.isArray(body.scheduledPublishes) ||
+            !body.scheduledPublishes.every(isScheduledPublish)) {
+            throw invalidSuccessEnvelope("scheduled publishes");
+        }
+        return body.scheduledPublishes;
+    }
+    async cancelScheduledPublish(collection, id, jobID, options) {
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/schedule/${encodeURIComponent(jobID)}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || body.id !== jobID || body.deleted !== true) {
+            throw invalidSuccessEnvelope("scheduled publish cancellation");
+        }
+        return { id: jobID, deleted: true };
+    }
+    async publish(collection, id, options) {
+        return this.#versionMutation(collection, id, "publish", options);
+    }
+    async publishChanges(collection, id, data, options) {
+        return this.#versionMutation(collection, id, "publish", options, data);
+    }
+    async unpublish(collection, id, options) {
+        return this.#versionMutation(collection, id, "unpublish", options);
+    }
+    async restore(collection, id, revision, options) {
+        const query = options?.draft === true ? "?draft=true" : "";
+        return this.#versionMutation(collection, id, "restore/" + revision + query, options);
+    }
+    async #versionMutation(collection, id, action, options, data) {
+        const revision = revisionHeaders(options);
+        const [actionPath, encodedQuery = ""] = action.split("?", 2);
+        const query = new URLSearchParams(encodedQuery);
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request("/api/collections/" +
+            encodeURIComponent(collection) +
+            "/" +
+            encodeDocumentID(id) +
+            "/" +
+            actionPath +
+            suffix, {
+            method: "POST",
+            ...(data === undefined ? {} : { body: JSON.stringify(data) }),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async delete(collection, id, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}${suffix}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || typeof body.id !== "string" || body.deleted !== true) {
+            throw invalidSuccessEnvelope("delete");
+        }
+        return { id: body.id, deleted: true };
+    }
+    async mutateJoin(collection, id, field, input, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/joins/${encodeURIComponent(field)}${suffix}`, { method: "PATCH", body: JSON.stringify(input) }, options);
+        if (!isRecord(body) ||
+            !isRecord(body.doc) ||
+            typeof body.added !== "number" ||
+            !Number.isInteger(body.added) ||
+            typeof body.removed !== "number" ||
+            !Number.isInteger(body.removed)) {
+            throw invalidSuccessEnvelope("join mutation");
+        }
+        return {
+            doc: body.doc,
+            added: body.added,
+            removed: body.removed,
+        };
+    }
+    async bulkUpdate(collection, ids, data, options) {
+        return this.#bulk(collection, "update", ids, data, options);
+    }
+    async bulkPublish(collection, ids, options) {
+        return this.#bulk(collection, "publish", ids, undefined, options);
+    }
+    async bulkUnpublish(collection, ids, options) {
+        return this.#bulk(collection, "unpublish", ids, undefined, options);
+    }
+    async bulkDelete(collection, ids, options) {
+        return this.#bulk(collection, "delete", ids, undefined, options);
+    }
+    async bulkRestoreDeleted(collection, ids, options) {
+        return this.#bulk(collection, "restoreDeleted", ids, undefined, options);
+    }
+    async bulkDeletePermanent(collection, ids, options) {
+        return this.#bulk(collection, "deletePermanent", ids, undefined, options);
+    }
+    async emptyTrash(collection, options) {
+        const query = new URLSearchParams();
+        query.set("trash", "true");
+        appendLocaleQuery(query, options);
+        const suffix = `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}${suffix}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || !Array.isArray(body.docs) || !body.docs.every(isRecord)) {
+            throw invalidSuccessEnvelope("empty trash");
+        }
+        return body.docs;
+    }
+    async #bulk(collection, action, ids, data, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/bulk${suffix}`, {
+            method: "POST",
+            body: JSON.stringify({ action, ids, ...(data === undefined ? {} : { data }) }),
+        }, options);
+        if (!isRecord(body) || !Array.isArray(body.docs) || !body.docs.every(isRecord)) {
+            throw invalidSuccessEnvelope("bulk operation");
+        }
+        return body.docs;
+    }
+    async restoreDeleted(collection, id, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/restore-deleted${suffix}`, { method: "POST" }, options);
+        return documentFromEnvelope(body);
+    }
+    async deletePermanent(collection, id, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/collections/${encodeURIComponent(collection)}/${encodeDocumentID(id)}/permanent${suffix}`, { method: "DELETE" }, options);
+        if (!isRecord(body) || typeof body.id !== "string" || body.deleted !== true) {
+            throw invalidSuccessEnvelope("permanent delete");
+        }
+        return { id: body.id, deleted: true };
+    }
+    async global(slug, options) {
+        const query = new URLSearchParams();
+        if (options?.depth !== undefined)
+            query.set("depth", String(options.depth));
+        if (options?.select !== undefined)
+            query.set("select", JSON.stringify(options.select));
+        if (options?.populate !== undefined)
+            query.set("populate", JSON.stringify(options.populate));
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/globals/${encodeURIComponent(slug)}${suffix}`, { method: "GET" }, options);
+        return documentFromEnvelope(body);
+    }
+    async updateGlobal(slug, data, options) {
+        const revision = revisionHeaders(options);
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/globals/${encodeURIComponent(slug)}${suffix}`, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async copyGlobalLocale(slug, input, options) {
+        const revision = revisionHeaders(options);
+        const body = await this.#request(`/api/globals/${encodeURIComponent(slug)}/copy-locale`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async globalVersions(slug, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/globals/${encodeURIComponent(slug)}/versions${suffix}`, { method: "GET" }, options);
+        if (!isRecord(body) || !Array.isArray(body.versions)) {
+            throw invalidSuccessEnvelope("global versions");
+        }
+        return body.versions;
+    }
+    async globalVersion(slug, revision, options) {
+        const query = new URLSearchParams();
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/globals/${encodeURIComponent(slug)}/versions/${revision}${suffix}`, { method: "GET" }, options);
+        if (!isRecord(body) || !isRecord(body.version)) {
+            throw invalidSuccessEnvelope("global version");
+        }
+        return body.version;
+    }
+    async publishGlobal(slug, options) {
+        return this.#globalVersionMutation(slug, "publish", options);
+    }
+    async publishGlobalChanges(slug, data, options) {
+        return this.#globalVersionMutation(slug, "publish", options, data);
+    }
+    async unpublishGlobal(slug, options) {
+        return this.#globalVersionMutation(slug, "unpublish", options);
+    }
+    async restoreGlobal(slug, revision, options) {
+        return this.#globalVersionMutation(slug, `restore/${revision}${options?.draft === true ? "?draft=true" : ""}`, options);
+    }
+    async #globalVersionMutation(slug, action, options, data) {
+        const revision = revisionHeaders(options);
+        const [actionPath, encodedQuery = ""] = action.split("?", 2);
+        const query = new URLSearchParams(encodedQuery);
+        appendLocaleQuery(query, options);
+        const suffix = query.size === 0 ? "" : `?${query}`;
+        const body = await this.#request(`/api/globals/${encodeURIComponent(slug)}/${actionPath}${suffix}`, {
+            method: "POST",
+            ...(data === undefined ? {} : { body: JSON.stringify(data) }),
+            ...(revision === undefined ? {} : { headers: revision }),
+        }, options);
+        return documentFromEnvelope(body);
+    }
+    async #request(path, init, options) {
+        const response = await this.#response(path, init, options, true);
+        if (!response.ok) {
+            throw await RiduError.fromResponse(response);
+        }
+        try {
+            return await response.json();
+        }
+        catch {
+            throw invalidSuccessEnvelope("JSON");
+        }
+    }
+    async #response(path, init, options, defaultJSONContentType) {
+        if (!path.startsWith("/") || path.startsWith("//") || path.includes("#")) {
+            throw new TypeError("request path must be an absolute-path reference");
+        }
+        const target = new URL(path, this.#baseURL);
+        if (target.origin !== new URL(this.#baseURL).origin || target.hash !== "") {
+            throw new TypeError("request path must stay on the configured origin and omit fragments");
+        }
+        const headers = new Headers(await resolveHeaders(this.#headers));
+        for (const [name, value] of new Headers(init.headers))
+            headers.set(name, value);
+        for (const [name, value] of new Headers(options?.headers))
+            headers.set(name, value);
+        if (defaultJSONContentType &&
+            init.body !== undefined &&
+            !(init.body instanceof FormData) &&
+            !headers.has("content-type")) {
+            headers.set("content-type", "application/json");
+        }
+        const request = new Request(target, {
+            ...init,
+            headers,
+            credentials: this.#credentials,
+            ...(options?.signal === undefined ? {} : { signal: options.signal }),
+            ...(options?.keepalive === undefined ? {} : { keepalive: options.keepalive }),
+        });
+        return this.#dispatch(request);
+    }
+}
+function revisionHeaders(options) {
+    return options?.revision === undefined ? undefined : { "If-Match": '"' + options.revision + '"' };
+}
+function encodeDocumentID(id) {
+    return encodeURIComponent(id);
+}
+function previewRequestOptions(options, token) {
+    const headers = new Headers(options?.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    return { ...options, headers };
+}
+function composeMiddleware(middleware, terminal) {
+    return middleware.reduceRight((next, current) => (request) => current(request, next), terminal);
+}
+async function resolveHeaders(headers) {
+    return typeof headers === "function" ? await headers() : headers;
+}
+function documentFromEnvelope(value) {
+    if (!isRecord(value) || !("doc" in value)) {
+        throw invalidSuccessEnvelope("document");
+    }
+    return value.doc;
+}
+function previewTokenFromEnvelope(value) {
+    if (!isRecord(value) ||
+        !isRecord(value.previewToken) ||
+        typeof value.previewToken.token !== "string" ||
+        (value.previewToken.resource !== "collection" && value.previewToken.resource !== "global") ||
+        typeof value.previewToken.slug !== "string" ||
+        typeof value.previewToken.documentId !== "string" ||
+        typeof value.previewToken.expiresAt !== "string") {
+        throw invalidSuccessEnvelope("preview token");
+    }
+    return value.previewToken;
+}
+function accessCapabilitiesFromEnvelope(value) {
+    if (!isRecord(value) || !isOperationCapabilities(value.operations) || !isRecord(value.fields)) {
+        throw invalidSuccessEnvelope("access capabilities");
+    }
+    const fields = {};
+    for (const [path, capability] of Object.entries(value.fields)) {
+        if (!isFieldCapabilities(capability))
+            throw invalidSuccessEnvelope("field capabilities");
+        fields[path] = capability;
+    }
+    return { operations: value.operations, fields };
+}
+function collectionSelectionFromEnvelope(value) {
+    if (!isRecord(value) ||
+        !Array.isArray(value.items) ||
+        value.items.length > 100 ||
+        typeof value.totalDocs !== "number" ||
+        !Number.isInteger(value.totalDocs) ||
+        value.totalDocs !== value.items.length) {
+        throw invalidSuccessEnvelope("filtered collection selection");
+    }
+    const seen = new Set();
+    let previousID;
+    const items = value.items.map((item) => {
+        if (!isRecord(item) ||
+            typeof item.id !== "string" ||
+            item.id.length === 0 ||
+            !isRecord(item.access)) {
+            throw invalidSuccessEnvelope("filtered collection selection item");
+        }
+        if (seen.has(item.id) || (previousID !== undefined && compareUTF8(previousID, item.id) >= 0)) {
+            throw invalidSuccessEnvelope("filtered collection selection IDs");
+        }
+        seen.add(item.id);
+        previousID = item.id;
+        return { id: item.id, access: accessCapabilitiesFromEnvelope(item.access) };
+    });
+    return { items, totalDocs: value.totalDocs };
+}
+function compareUTF8(left, right) {
+    const encoder = new TextEncoder();
+    const leftBytes = encoder.encode(left);
+    const rightBytes = encoder.encode(right);
+    const length = Math.min(leftBytes.length, rightBytes.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftBytes.length - rightBytes.length;
+}
+function documentLockFromEnvelope(value) {
+    if (!isRecord(value) ||
+        typeof value.owned !== "boolean" ||
+        typeof value.acquired !== "boolean" ||
+        typeof value.canTakeOver !== "boolean" ||
+        (value.lock !== null &&
+            (!isRecord(value.lock) ||
+                typeof value.lock.documentId !== "string" ||
+                typeof value.lock.ownerId !== "string" ||
+                typeof value.lock.ownerLabel !== "string" ||
+                typeof value.lock.createdAt !== "string" ||
+                typeof value.lock.updatedAt !== "string" ||
+                typeof value.lock.expiresAt !== "string"))) {
+        throw invalidSuccessEnvelope("document lock");
+    }
+    return value;
+}
+function isOperationCapabilities(value) {
+    return (isRecord(value) &&
+        [
+            "admin",
+            "create",
+            "read",
+            "readVersions",
+            "update",
+            "delete",
+            "duplicate",
+            "publish",
+            "unpublish",
+            "restoreDeleted",
+            "deletePermanent",
+            "selectAll",
+        ].every((key) => typeof value[key] === "boolean"));
+}
+function isFieldCapabilities(value) {
+    return (isRecord(value) &&
+        typeof value.read === "boolean" &&
+        typeof value.create === "boolean" &&
+        typeof value.update === "boolean");
+}
+function sessionFromEnvelope(value) {
+    if (!isRecord(value) ||
+        !isRecord(value.session) ||
+        !("user" in value.session) ||
+        typeof value.session.id !== "string" ||
+        typeof value.session.collection !== "string" ||
+        typeof value.session.expiresAt !== "string") {
+        throw invalidSuccessEnvelope("session");
+    }
+    return {
+        id: value.session.id,
+        collection: value.session.collection,
+        user: value.session.user,
+        expiresAt: value.session.expiresAt,
+    };
+}
+function isAuthSessionInfo(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.createdAt === "string" &&
+        typeof value.lastSeenAt === "string" &&
+        typeof value.expiresAt === "string" &&
+        (value.ipAddress === undefined || typeof value.ipAddress === "string") &&
+        (value.userAgent === undefined || typeof value.userAgent === "string") &&
+        typeof value.current === "boolean");
+}
+function isAPIKey(value, includeSecret) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.name === "string" &&
+        typeof value.createdAt === "string" &&
+        (!includeSecret || typeof value.key === "string") &&
+        (value.lastUsedAt === undefined || typeof value.lastUsedAt === "string") &&
+        (value.expiresAt === undefined || typeof value.expiresAt === "string"));
+}
+function isScheduledPublish(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        typeof value.documentId === "string" &&
+        typeof value.expectedRevision === "number" &&
+        typeof value.runAt === "string" &&
+        typeof value.attempts === "number" &&
+        (value.lastError === undefined || typeof value.lastError === "string") &&
+        typeof value.createdAt === "string");
+}
+function appendLocaleQuery(query, options) {
+    if (options?.locale !== undefined)
+        query.set("locale", options.locale);
+    if (options?.fallbackLocale === false) {
+        query.set("fallback-locale", "false");
+    }
+    else if (typeof options?.fallbackLocale === "string") {
+        query.set("fallback-locale", options.fallbackLocale);
+    }
+    else if (options?.fallbackLocale !== undefined) {
+        query.set("fallback-locale", options.fallbackLocale.join(","));
+    }
+}
+function appendDraftQuery(query, options) {
+    if (options?.draft !== undefined)
+        query.set("draft", String(options.draft));
+}
+function invalidSuccessEnvelope(kind) {
+    return new RiduError({
+        code: "internal",
+        status: 500,
+        message: `Server returned an invalid ${kind} response envelope`,
+        issues: [],
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}