@sanity-labs/client-fake-for-test 0.1.0 → 0.2.0

package/dist/index.js

@@ -68,6 +68,53 @@ function makeRequestImpl(accessControl, projectId, dataset) {
     );
   };
 }
+function createTestStore(initial) {
+  const docs = /* @__PURE__ */ new Map(), promote2 = (doc) => {
+    if (typeof doc._id != "string" || doc._id.length === 0)
+      throw new Error(`document is missing _id: ${JSON.stringify(doc)}`);
+    if (typeof doc._type != "string" || doc._type.length === 0)
+      throw new Error(`document ${doc._id} is missing _type`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      ...doc,
+      _id: doc._id,
+      _type: doc._type,
+      _rev: doc._rev ?? cryptoRandomKey(),
+      _createdAt: doc._createdAt ?? now,
+      _updatedAt: doc._updatedAt ?? now
+    };
+  }, seed = (documents) => {
+    docs.clear();
+    for (const d of documents) {
+      const promoted = promote2(d);
+      docs.set(promoted._id, promoted);
+    }
+  };
+  return initial && seed(initial), {
+    seed,
+    add: (documents) => {
+      for (const d of documents) {
+        const promoted = promote2(d);
+        docs.set(promoted._id, promoted);
+      }
+    },
+    reset: () => docs.clear(),
+    all: () => [...docs.values()],
+    get: (id) => docs.get(id),
+    put: (doc) => {
+      docs.set(doc._id, doc);
+    },
+    remove: (id) => {
+      const doc = docs.get(id);
+      return doc && docs.delete(id), doc;
+    },
+    snapshot: () => [...docs.values()]
+  };
+}
+function cryptoRandomKey(length = 12) {
+  const bytes = new Uint8Array(length);
+  return globalThis.crypto.getRandomValues(bytes), [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, length);
+}
 function createPatch(documentId, executor) {
   const ops = [];
   let ifRev;
@@ -246,52 +293,301 @@ function insertIntoArray(doc, position, anchor, items) {
   const idx = resolveSelector(arr, last.selector);
   position === "replace" ? arr.splice(idx, 1, ...items) : position === "before" ? arr.splice(idx, 0, ...items) : arr.splice(idx + 1, 0, ...items);
 }
-function createTestStore(initial) {
-  const docs = /* @__PURE__ */ new Map(), promote = (doc) => {
-    if (typeof doc._id != "string" || doc._id.length === 0)
-      throw new Error(`document is missing _id: ${JSON.stringify(doc)}`);
-    if (typeof doc._type != "string" || doc._type.length === 0)
-      throw new Error(`document ${doc._id} is missing _type`);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return {
-      ...doc,
-      _id: doc._id,
-      _type: doc._type,
-      _rev: doc._rev ?? cryptoRandomKey(),
-      _createdAt: doc._createdAt ?? now,
-      _updatedAt: doc._updatedAt ?? now
-    };
-  }, seed = (documents) => {
-    docs.clear();
-    for (const d of documents) {
-      const promoted = promote(d);
-      docs.set(promoted._id, promoted);
-    }
+const RELEASE_DOC_PREFIX$1 = "_.releases.", VERSIONS_PREFIX$1 = "versions.", releaseDocId = (releaseId) => `${RELEASE_DOC_PREFIX$1}${releaseId}`, versionDocId = (releaseId, publishedId) => `${VERSIONS_PREFIX$1}${releaseId}.${publishedId}`;
+function parseVersionId(versionId) {
+  if (!versionId.startsWith(VERSIONS_PREFIX$1))
+    throw new Error(`Not a version id: ${versionId}`);
+  const rest = versionId.slice(VERSIONS_PREFIX$1.length), dot = rest.indexOf(".");
+  if (dot === -1)
+    throw new Error(`Not a version id: ${versionId}`);
+  return { releaseId: rest.slice(0, dot), publishedId: rest.slice(dot + 1) };
+}
+function getRelease(store, releaseId) {
+  const doc = store.get(releaseDocId(releaseId));
+  if (doc === void 0)
+    throw new Error(`Release not found: ${releaseId}`);
+  return doc;
+}
+function maybeRelease(store, releaseId) {
+  return store.get(releaseDocId(releaseId));
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function promote(doc) {
+  const now = nowIso();
+  return {
+    ...doc,
+    _id: doc._id,
+    _type: doc._type,
+    _rev: cryptoRandomKey(),
+    _createdAt: doc._createdAt ?? now,
+    _updatedAt: now
   };
-  return initial && seed(initial), {
-    seed,
-    add: (documents) => {
-      for (const d of documents) {
-        const promoted = promote(d);
-        docs.set(promoted._id, promoted);
+}
+function bumpRev(doc, patch) {
+  return {
+    ...doc,
+    ...patch,
+    _rev: cryptoRandomKey(),
+    _updatedAt: nowIso()
+  };
+}
+function requireActive(release) {
+  if (release.state !== "active")
+    throw new Error(
+      `Release ${release.name} is ${release.state}; only active releases accept version writes`
+    );
+}
+function applyAction(store, action) {
+  switch (action.actionType) {
+    case "sanity.action.release.create": {
+      if (maybeRelease(store, action.releaseId) !== void 0)
+        throw new Error(`Release ${action.releaseId} already exists`);
+      const now = nowIso(), metadata = {
+        releaseType: "undecided",
+        ...action.metadata
+      }, doc = {
+        _id: releaseDocId(action.releaseId),
+        _type: "system.release",
+        _rev: cryptoRandomKey(),
+        _createdAt: now,
+        _updatedAt: now,
+        name: action.releaseId,
+        state: "active",
+        metadata
+      };
+      return store.put(doc), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.edit": {
+      const release = getRelease(store, action.releaseId), patchOps = [];
+      action.patch.set !== void 0 && patchOps.push({ kind: "set", props: action.patch.set }), action.patch.unset !== void 0 && patchOps.push({ kind: "unset", paths: action.patch.unset });
+      const patched = applyPatchOps(release, patchOps);
+      return store.put(bumpRev(patched, {})), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.schedule": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "active")
+        throw new Error(`Cannot schedule release in state ${release.state}`);
+      return store.put(
+        bumpRev(release, {
+          state: "scheduled",
+          publishAt: action.publishAt
+        })
+      ), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.unschedule": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "scheduled")
+        throw new Error(`Cannot unschedule release in state ${release.state}`);
+      const next = { ...release, state: "active" };
+      return delete next.publishAt, store.put(bumpRev(next, {})), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.publish": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state === "published")
+        return { transactionId: cryptoRandomKey() };
+      if (release.state !== "active" && release.state !== "scheduled")
+        throw new Error(`Cannot publish release in state ${release.state}`);
+      const prefix = `${VERSIONS_PREFIX$1}${action.releaseId}.`, sources = store.all().filter((d) => d._id.startsWith(prefix));
+      for (const v of sources) {
+        const pubId = v._id.slice(prefix.length);
+        if (v._system?.delete === !0)
+          store.remove(pubId);
+        else {
+          const body = {
+            ...v,
+            _id: pubId
+          };
+          delete body._originalId, delete body._system;
+          const promoted = promote(body), existing = store.get(pubId);
+          existing !== void 0 && (promoted._createdAt = existing._createdAt), store.put(promoted);
+        }
+        store.remove(v._id);
       }
-    },
-    reset: () => docs.clear(),
-    all: () => [...docs.values()],
-    get: (id) => docs.get(id),
-    put: (doc) => {
-      docs.set(doc._id, doc);
-    },
-    remove: (id) => {
-      const doc = docs.get(id);
-      return doc && docs.delete(id), doc;
-    },
-    snapshot: () => [...docs.values()]
+      return store.put(bumpRev(release, { state: "published" })), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.archive": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "active" && release.state !== "scheduled")
+        throw new Error(`Cannot archive release in state ${release.state}`);
+      return store.put(bumpRev(release, { state: "archived" })), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.unarchive": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "archived")
+        throw new Error(`Cannot unarchive release in state ${release.state}`);
+      return store.put(bumpRev(release, { state: "active" })), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.delete": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "archived" && release.state !== "published")
+        throw new Error(
+          `Cannot delete release in state ${release.state}; archive or publish it first`
+        );
+      const prefix = `${VERSIONS_PREFIX$1}${action.releaseId}.`;
+      for (const v of store.all())
+        v._id.startsWith(prefix) && store.remove(v._id);
+      return store.remove(release._id), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.create": {
+      const releaseId = action.releaseId ?? (action.document._id !== void 0 ? parseVersionId(action.document._id).releaseId : void 0);
+      if (releaseId === void 0)
+        throw new Error("version.create needs releaseId or a document._id that encodes it");
+      const release = getRelease(store, releaseId);
+      requireActive(release);
+      const vid = versionDocId(releaseId, action.publishedId), doc = {
+        ...action.document,
+        _id: vid
+      }, existing = store.get(vid), promoted = promote(doc);
+      return existing !== void 0 && (promoted._createdAt = existing._createdAt), store.put(promoted), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.replace": {
+      const id = action.document._id;
+      if (typeof id != "string")
+        throw new Error("version.replace needs document._id");
+      const { releaseId } = parseVersionId(id), release = getRelease(store, releaseId);
+      requireActive(release);
+      const existing = store.get(id), promoted = promote(action.document);
+      return existing !== void 0 && (promoted._createdAt = existing._createdAt), store.put(promoted), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.discard": {
+      const { releaseId } = parseVersionId(action.versionId), release = getRelease(store, releaseId);
+      return requireActive(release), store.remove(action.versionId), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.unpublish": {
+      const { releaseId } = parseVersionId(action.versionId), release = getRelease(store, releaseId);
+      requireActive(release);
+      const doc = {
+        _id: action.versionId,
+        _type: "stub",
+        _system: { delete: !0 }
+      };
+      return store.put(promote(doc)), { transactionId: cryptoRandomKey() };
+    }
+  }
+}
+function applyActions(store, actions) {
+  const list = Array.isArray(actions) ? actions : [actions], snapshot = /* @__PURE__ */ new Map(), remember = (id) => {
+    snapshot.has(id) || snapshot.set(id, store.get(id));
   };
+  try {
+    let last = { transactionId: cryptoRandomKey() };
+    for (const a of list) {
+      switch (a.actionType) {
+        case "sanity.action.release.create":
+        case "sanity.action.release.edit":
+        case "sanity.action.release.schedule":
+        case "sanity.action.release.unschedule":
+        case "sanity.action.release.archive":
+        case "sanity.action.release.unarchive":
+        case "sanity.action.release.delete":
+          remember(`${RELEASE_DOC_PREFIX$1}${a.releaseId}`);
+          break;
+        case "sanity.action.release.publish": {
+          remember(`${RELEASE_DOC_PREFIX$1}${a.releaseId}`);
+          const prefix = `${VERSIONS_PREFIX$1}${a.releaseId}.`;
+          for (const d of store.all())
+            d._id.startsWith(prefix) && (remember(d._id), remember(d._id.slice(prefix.length)));
+          break;
+        }
+        case "sanity.action.document.version.create": {
+          const releaseId = a.releaseId ?? (typeof a.document._id == "string" ? parseVersionId(a.document._id).releaseId : void 0);
+          releaseId !== void 0 && remember(versionDocId(releaseId, a.publishedId));
+          break;
+        }
+        case "sanity.action.document.version.replace":
+          typeof a.document._id == "string" && remember(a.document._id);
+          break;
+        case "sanity.action.document.version.discard":
+        case "sanity.action.document.version.unpublish":
+          remember(a.versionId);
+          break;
+      }
+      last = applyAction(store, a);
+    }
+    return last;
+  } catch (err) {
+    for (const [id, doc] of snapshot)
+      doc === void 0 ? store.remove(id) : store.put(doc);
+    throw err;
+  }
 }
-function cryptoRandomKey(length = 12) {
-  const bytes = new Uint8Array(length);
-  return globalThis.crypto.getRandomValues(bytes), [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, length);
+const DRAFTS_PREFIX = "drafts.", VERSIONS_PREFIX = "versions.", RELEASE_DOC_PREFIX = "_.releases.";
+function publishedIdOf(id) {
+  if (id.startsWith(DRAFTS_PREFIX)) return id.slice(DRAFTS_PREFIX.length);
+  if (id.startsWith(VERSIONS_PREFIX)) {
+    const rest = id.slice(VERSIONS_PREFIX.length), dot = rest.indexOf(".");
+    return dot === -1 ? rest : rest.slice(dot + 1);
+  }
+  return id;
+}
+function releaseNameOf(id) {
+  if (!id.startsWith(VERSIONS_PREFIX)) return;
+  const rest = id.slice(VERSIONS_PREFIX.length), dot = rest.indexOf(".");
+  if (dot !== -1)
+    return rest.slice(0, dot);
+}
+const isDraftId = (id) => id.startsWith(DRAFTS_PREFIX), isVersionId = (id) => id.startsWith(VERSIONS_PREFIX), isSystemId = (id) => id.startsWith("_."), isReleaseDocId = (id) => id.startsWith(RELEASE_DOC_PREFIX);
+function applyPerspective(docs, perspective) {
+  if (perspective === "raw") return [...docs];
+  if (perspective === "published")
+    return docs.filter((d) => !isDraftId(d._id) && !isVersionId(d._id) && !isSystemId(d._id));
+  if (perspective === "drafts")
+    return mergeStack(docs, [], { includeDrafts: !0, includeReleaseDocs: !1 });
+  const stack = [];
+  let includeDrafts = !1;
+  for (const entry of perspective)
+    entry === "drafts" ? includeDrafts = !0 : stack.push(entry);
+  return mergeStack(docs, stack, { includeDrafts, includeReleaseDocs: !0 });
+}
+function mergeStack(docs, releaseStack, options) {
+  const groups = /* @__PURE__ */ new Map(), systemReleases = [];
+  for (const doc of docs) {
+    if (isReleaseDocId(doc._id)) {
+      options.includeReleaseDocs && systemReleases.push(doc);
+      continue;
+    }
+    if (isSystemId(doc._id)) continue;
+    const pubId = publishedIdOf(doc._id);
+    let group = groups.get(pubId);
+    if (group === void 0 && (group = { versions: /* @__PURE__ */ new Map() }, groups.set(pubId, group)), isDraftId(doc._id))
+      group.draft = doc;
+    else if (isVersionId(doc._id)) {
+      const releaseName = releaseNameOf(doc._id);
+      releaseName !== void 0 && group.versions.set(releaseName, doc);
+    } else
+      group.published = doc;
+  }
+  const out = [];
+  for (const [pubId, group] of groups) {
+    let chosen;
+    for (const releaseName of releaseStack) {
+      const v = group.versions.get(releaseName);
+      if (v !== void 0) {
+        if (isUnpublishStub(v)) {
+          chosen = void 0;
+          break;
+        }
+        chosen = v;
+        break;
+      }
+    }
+    chosen === void 0 && options.includeDrafts && group.draft !== void 0 && (chosen = group.draft), chosen === void 0 && group.published !== void 0 && (releaseStack.some((name) => {
+      const v = group.versions.get(name);
+      return v !== void 0 && isUnpublishStub(v);
+    }) || (chosen = group.published)), chosen !== void 0 && out.push(projectToPublishedId(chosen, pubId));
+  }
+  return [...out, ...systemReleases];
+}
+function isUnpublishStub(doc) {
+  return doc._system?.delete === !0;
+}
+function projectToPublishedId(doc, pubId) {
+  return doc._id === pubId ? doc : { ...doc, _id: pubId, _originalId: doc._id };
+}
+function resolveDocument(docs, id, perspective) {
+  return perspective === "raw" ? docs.find((d) => d._id === id) : applyPerspective(docs, perspective).find((d) => d._id === id);
 }
 function createTransaction(executor) {
   const mutations = [], handle = {
@@ -338,14 +634,20 @@ function createTestClient(options = {}) {
       const { projectId, dataset } = parseRegistryKey(key);
       ensureStore(projectId, dataset).seed(docs);
     }
-  return makeHandle(registry, defaultProjectId, defaultDataset, options.accessControl);
+  return makeHandle(
+    registry,
+    defaultProjectId,
+    defaultDataset,
+    options.accessControl,
+    options.perspective ?? "raw"
+  );
 }
-function makeHandle(registry, projectId, dataset, accessControl) {
+function makeHandle(registry, projectId, dataset, accessControl, perspective) {
   const store = (() => {
     const key = registryKey(projectId, dataset);
     let s = registry.get(key);
     return s === void 0 && (s = createTestStore(), registry.set(key, s)), s;
-  })(), promote = (doc) => {
+  })(), promote2 = (doc) => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (typeof doc._id != "string" || doc._id.length === 0)
       throw new Error("document is missing _id");
@@ -400,7 +702,7 @@ function makeHandle(registry, projectId, dataset, accessControl) {
         switch (mut.kind) {
           case "create": {
             remember(mut.doc._id);
-            const promoted = promote(mut.doc);
+            const promoted = promote2(mut.doc);
             if (store.get(promoted._id) !== void 0)
               throw new Error(`create failed: document ${promoted._id} already exists`);
             await gate(promoted, "create"), store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: "create" });
@@ -408,7 +710,7 @@ function makeHandle(registry, projectId, dataset, accessControl) {
           }
           case "createOrReplace": {
             remember(mut.doc._id);
-            const promoted = promote(mut.doc), existing = store.get(promoted._id);
+            const promoted = promote2(mut.doc), existing = store.get(promoted._id);
             await gate(existing ?? promoted, existing !== void 0 ? "update" : "create");
             const wasPresent = existing !== void 0;
             store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: wasPresent ? "update" : "create" });
@@ -416,7 +718,7 @@ function makeHandle(registry, projectId, dataset, accessControl) {
           }
           case "createIfNotExists": {
             if (remember(mut.doc._id), store.get(mut.doc._id) === void 0) {
-              const promoted = promote(mut.doc);
+              const promoted = promote2(mut.doc);
               await gate(promoted, "create"), store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: "create" });
             }
             break;
@@ -445,50 +747,63 @@ function makeHandle(registry, projectId, dataset, accessControl) {
       transactionId: cryptoRandomKey(),
       results: operations
     };
-  }, visibleDocs = async () => {
+  }, accessVisibleDocs = async () => {
     const all = store.all();
     if (accessControl === void 0) return all;
     const out = [];
     for (const doc of all)
       await canRead(doc) && out.push(doc);
     return out;
+  }, visibleDocs = async (override) => {
+    const accessible = await accessVisibleDocs();
+    return applyPerspective(accessible, override ?? perspective);
   };
   return {
-    fetch: async (query, params) => {
+    fetch: async (query, params, opts) => {
       const tree = parse(query, params ? { params } : void 0);
       return await (await evaluate(tree, {
-        dataset: await visibleDocs(),
+        dataset: await visibleDocs(opts?.perspective),
         ...params !== void 0 ? { params } : {}
       })).get();
     },
-    getDocument: async (id) => {
-      const doc = store.get(id);
-      return doc === void 0 || !await canRead(doc) ? null : doc;
-    },
-    getDocuments: async (ids) => {
-      const result = [];
-      for (const id of ids) {
+    getDocument: async (id, opts) => {
+      const effective = opts?.perspective ?? perspective;
+      if (effective === "raw") {
         const doc = store.get(id);
-        doc === void 0 ? result.push(null) : await canRead(doc) ? result.push(doc) : result.push(null);
+        return doc === void 0 || !await canRead(doc) ? null : doc;
       }
-      return result;
+      const view = await visibleDocs(effective);
+      return resolveDocument(view, id, effective) ?? null;
+    },
+    getDocuments: async (ids, opts) => {
+      const effective = opts?.perspective ?? perspective;
+      if (effective === "raw") {
+        const result = [];
+        for (const id of ids) {
+          const doc = store.get(id);
+          doc === void 0 ? result.push(null) : await canRead(doc) ? result.push(doc) : result.push(null);
+        }
+        return result;
+      }
+      const view = await visibleDocs(effective);
+      return ids.map((id) => resolveDocument(view, id, effective) ?? null);
     },
     create: async (doc, opts) => {
       if (checkRevision(doc._id, opts?.ifRevisionId), store.get(doc._id) !== void 0)
         throw new Error(`create failed: document ${doc._id} already exists`);
-      const promoted = promote(doc);
+      const promoted = promote2(doc);
       return await gate(promoted, "create"), store.put(promoted), promoted;
     },
     createOrReplace: async (doc, opts) => {
       checkRevision(doc._id, opts?.ifRevisionId);
-      const promoted = promote(doc), existing = store.get(doc._id);
+      const promoted = promote2(doc), existing = store.get(doc._id);
       return await gate(existing ?? promoted, existing !== void 0 ? "update" : "create"), store.put(promoted), promoted;
     },
     createIfNotExists: async (doc, opts) => {
       checkRevision(doc._id, opts?.ifRevisionId);
       const existing = store.get(doc._id);
       if (existing !== void 0) return existing;
-      const promoted = promote(doc);
+      const promoted = promote2(doc);
       return await gate(promoted, "create"), store.put(promoted), promoted;
     },
     delete: async (id, opts) => {
@@ -498,9 +813,57 @@ function makeHandle(registry, projectId, dataset, accessControl) {
     },
     patch: (documentId) => createPatch(documentId, { apply: applyPatch }),
     transaction: () => createTransaction({ apply: applyTransaction }),
+    action: async (action) => applyActions(store, action),
+    releases: {
+      create: async ({ releaseId, metadata }) => {
+        const result = applyActions(store, {
+          actionType: "sanity.action.release.create",
+          releaseId,
+          ...metadata !== void 0 ? { metadata } : {}
+        }), doc = store.get(`_.releases.${releaseId}`);
+        return {
+          ...result,
+          releaseId,
+          metadata: doc?.metadata ?? { releaseType: "undecided" }
+        };
+      },
+      edit: async ({ releaseId, patch }) => applyActions(store, { actionType: "sanity.action.release.edit", releaseId, patch }),
+      get: async ({ releaseId }) => store.get(`_.releases.${releaseId}`),
+      fetchDocuments: async ({ releaseId }) => {
+        const prefix = `versions.${releaseId}.`;
+        return store.all().filter((d) => d._id.startsWith(prefix));
+      },
+      schedule: async ({ releaseId, publishAt }) => applyActions(store, {
+        actionType: "sanity.action.release.schedule",
+        releaseId,
+        publishAt
+      }),
+      unschedule: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.unschedule", releaseId }),
+      publish: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.publish", releaseId }),
+      archive: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.archive", releaseId }),
+      unarchive: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.unarchive", releaseId }),
+      delete: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.delete", releaseId })
+    },
+    createVersion: async ({ releaseId, publishedId, document }) => applyActions(store, {
+      actionType: "sanity.action.document.version.create",
+      releaseId,
+      publishedId,
+      document
+    }),
+    unpublishVersion: async ({ releaseId, publishedId }) => applyActions(store, {
+      actionType: "sanity.action.document.version.unpublish",
+      versionId: `versions.${releaseId}.${publishedId}`,
+      publishedId
+    }),
     ...accessControl !== void 0 ? { request: makeRequestImpl(accessControl, projectId, dataset) } : {},
-    config: () => ({ projectId, dataset }),
-    withConfig: (config) => makeHandle(registry, config.projectId ?? projectId, config.dataset ?? dataset, accessControl),
+    config: () => ({ projectId, dataset, perspective }),
+    withConfig: (config) => makeHandle(
+      registry,
+      config.projectId ?? projectId,
+      config.dataset ?? dataset,
+      accessControl,
+      config.perspective ?? perspective
+    ),
     seed: (documents) => store.seed(documents),
     add: (documents) => store.add(documents),
     reset: () => store.reset(),
@@ -512,11 +875,18 @@ function makeHandle(registry, projectId, dataset, accessControl) {
 export {
   WriteAccessDeniedError,
   applyPatchOps,
+  applyPerspective,
   createPatch,
   createTestClient,
   createTestStore,
   createTransaction,
   defaultAclPath,
-  evaluateWriteAccess
+  evaluateWriteAccess,
+  isDraftId,
+  isReleaseDocId,
+  isSystemId,
+  isVersionId,
+  publishedIdOf,
+  releaseNameOf
 };
 //# sourceMappingURL=index.js.map