@sanity-labs/client-fake-for-test 0.7.0 → 0.7.1

package/dist/index.cjs

@@ -875,6 +875,15 @@ const RECORDED_METHODS = /* @__PURE__ */ new Set([
   "unpublishVersion",
   "request"
 ]), DEFAULT_PROJECT_ID = "test", DEFAULT_DATASET = "test";
+function serializeWrite(backend, run) {
+  const result = backend.writeChain.then(run);
+  return backend.writeChain = result.then(
+    () => {
+    },
+    () => {
+    }
+  ), result;
+}
 function requireIdentity(backend, token, site) {
   if (backend.identities.has(token)) return;
   const known = [...backend.identities.keys()];
@@ -899,7 +908,8 @@ function createTestClient(options = {}) {
     stubs: /* @__PURE__ */ new Map(),
     calls: [],
     concurrentEdits: /* @__PURE__ */ new Map(),
-    identities: new Map(Object.entries(options.identities ?? {}))
+    identities: new Map(Object.entries(options.identities ?? {})),
+    writeChain: Promise.resolve()
   }, registry = backend.registry;
   rejectAmbiguousIdentity("createTestClient()", options), options.token !== void 0 && requireIdentity(backend, options.token, "createTestClient()");
   const ensureStore = (projectId, dataset) => {
@@ -1128,7 +1138,7 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
       txnOptions?.returnDocuments ?? !1,
       txnOptions?.returnFirst ?? !1
     );
-  }, accessVisibleDocs = async () => {
+  }, runAction = (actions) => serializeWrite(backend, async () => applyActions(store, actions)), accessVisibleDocs = async () => {
     const all = store.all();
     if (activeAccess() === void 0) return all;
     const out = [];
@@ -1172,7 +1182,7 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
       const view = await visibleDocs(effective);
       return ids.map((id) => resolveDocument(view, id, effective) ?? null);
     },
-    create: async (doc, opts) => {
+    create: (doc, opts) => serializeWrite(backend, async () => {
       if (checkRevision(doc._id, opts?.ifRevisionId), store.get(doc._id) !== void 0)
         throw fakeError(
           `create() failed: a document with _id "${doc._id}" already exists in dataset "${projectId}:${dataset}". Use createOrReplace() to overwrite it, or createIfNotExists() to leave the existing one untouched.`
@@ -1186,8 +1196,8 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
         transactionId,
         opts
       );
-    },
-    createOrReplace: async (doc, opts) => {
+    }),
+    createOrReplace: (doc, opts) => serializeWrite(backend, async () => {
       checkRevision(doc._id, opts?.ifRevisionId);
       const promoted = promote2(doc), existing = store.get(doc._id);
       await gate(existing ?? promoted, existing !== void 0 ? "update" : "create"), await guardGate(existing !== void 0 ? "update" : "create", existing ?? null, promoted);
@@ -1200,8 +1210,8 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
         transactionId,
         opts
       );
-    },
-    createIfNotExists: async (doc, opts) => {
+    }),
+    createIfNotExists: (doc, opts) => serializeWrite(backend, async () => {
       checkRevision(doc._id, opts?.ifRevisionId);
       const existing = store.get(doc._id), transactionId = opts?.transactionId ?? cryptoRandomKey();
       if (existing !== void 0)
@@ -1218,8 +1228,8 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
         transactionId,
         opts
       );
-    },
-    delete: async (id, opts) => {
+    }),
+    delete: (id, opts) => serializeWrite(backend, async () => {
       checkRevision(id, opts?.ifRevisionId);
       const existing = store.get(id);
       existing !== void 0 && await gate(existing, "update"), existing !== void 0 && await guardGate("delete", existing, null);
@@ -1232,23 +1242,35 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
         opts.returnDocuments ?? !0,
         opts.returnFirst ?? !0
       );
-    },
+    }),
     patch: (documentId) => createPatch(documentId, {
-      apply: async (docId, ops, ifRev, options) => {
+      apply: (docId, ops, ifRev, options) => serializeWrite(backend, async () => {
         const doc = await applyPatch(docId, ops, ifRev);
         return record(
           cryptoRandomKey(),
-          [{ kind: "patch", documentId: docId, ops, ...ifRev !== void 0 ? { ifRev } : {} }],
+          [
+            {
+              kind: "patch",
+              documentId: docId,
+              ops,
+              ...ifRev !== void 0 ? { ifRev } : {}
+            }
+          ],
           options?.tag
         ), doc;
-      }
+      })
+    }),
+    transaction: () => createTransaction({
+      apply: (mutations, txnOptions) => serializeWrite(backend, () => applyTransaction(mutations, txnOptions))
     }),
-    transaction: () => createTransaction({ apply: applyTransaction }),
-    mutate: async (operations, options) => applyTransaction(toTxnMutations(operations), options),
-    action: async (action) => applyActions(store, action),
+    mutate: (operations, options) => serializeWrite(backend, () => applyTransaction(toTxnMutations(operations), options)),
+    // Synchronous writes still take the lock: an action landing while a
+    // guarded patch is parked in its gate would otherwise be clobbered
+    // when that patch resumes over its pre-action snapshot.
+    action: (action) => runAction(action),
     releases: {
       create: async ({ releaseId, metadata }) => {
-        const result = applyActions(store, {
+        const result = await runAction({
           actionType: "sanity.action.release.create",
           releaseId,
           ...metadata !== void 0 ? { metadata } : {}
@@ -1259,30 +1281,30 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
           metadata: doc?.metadata ?? { releaseType: "undecided" }
         };
       },
-      edit: async ({ releaseId, patch }) => applyActions(store, { actionType: "sanity.action.release.edit", releaseId, patch }),
+      edit: ({ releaseId, patch }) => runAction({ 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, {
+      schedule: ({ releaseId, publishAt }) => runAction({
         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 })
+      unschedule: ({ releaseId }) => runAction({ actionType: "sanity.action.release.unschedule", releaseId }),
+      publish: ({ releaseId }) => runAction({ actionType: "sanity.action.release.publish", releaseId }),
+      archive: ({ releaseId }) => runAction({ actionType: "sanity.action.release.archive", releaseId }),
+      unarchive: ({ releaseId }) => runAction({ actionType: "sanity.action.release.unarchive", releaseId }),
+      delete: ({ releaseId }) => runAction({ actionType: "sanity.action.release.delete", releaseId })
     },
-    createVersion: async ({ releaseId, publishedId, document }) => applyActions(store, {
+    createVersion: ({ releaseId, publishedId, document }) => runAction({
       actionType: "sanity.action.document.version.create",
       releaseId,
       publishedId,
       document
     }),
-    unpublishVersion: async ({ releaseId, publishedId }) => applyActions(store, {
+    unpublishVersion: ({ releaseId, publishedId }) => runAction({
       actionType: "sanity.action.document.version.unpublish",
       versionId: `versions.${releaseId}.${publishedId}`,
       publishedId