@sanity-labs/client-fake-for-test 0.0.0

package/README.md

@@ -0,0 +1,125 @@
+# @sanity-labs/client-fake-for-test
+
+> [!NOTE]
+> In-memory fake of `@sanity/client` for tests. Drop-in for the data-plane methods (`fetch`, `getDocument`, `patch`, `createOrReplace`, `transaction`, …), backed by [groq-js](https://github.com/sanity-io/groq-js) and a closure-scoped document store. No network, no global state, fresh per test.
+
+```bash
+npm install -D @sanity-labs/client-fake-for-test
+```
+
+## What this is for
+
+Any code typed against `SanityClient` (or a narrow subset of its methods) that you want to test without:
+
+- Hitting the network — real datasets are slow, flaky, rate-limited, and shared across runs.
+- Mocking individual methods one-by-one — drifts away from the real client's surface shape, and breaks the moment you add a call.
+- Standing up a stub HTTP server (MSW, nock) — fine for HTTP-shaped tests, overkill for "did my patch chain do the right thing".
+
+Typical use cases:
+
+- **Server functions** that read or write Sanity content — Sanity Functions, route handlers, custom backends.
+- **Hooks and utilities** typed against `SanityClient`.
+- **Migration scripts** — exercise the patch chain against a synthetic document set, assert end state.
+- **Schema validators** and other tooling that walks documents via GROQ.
+- **Workflow / orchestration engines** that mutate Sanity state — see [`@sanity-labs/workflow-engine-explore`](https://github.com/sanity-labs/workflow-slop), the original consumer.
+
+## Quickstart
+
+```ts
+import { createTestClient } from "@sanity-labs/client-fake-for-test";
+
+const client = createTestClient({
+  documents: [
+    { _id: "article-1", _type: "article", title: "Hello", state: "draft" },
+    { _id: "article-2", _type: "article", title: "World", state: "approved" },
+  ],
+});
+
+// fetch — GROQ via groq-js against the in-memory store
+const approved = await client.fetch<{ _id: string }[]>(
+  `*[_type == "article" && state == $s]{_id}`,
+  { s: "approved" },
+);
+// → [{ _id: "article-2" }]
+
+// patch + commit
+await client.patch("article-1").set({ state: "approved" }).commit();
+
+// transaction — atomic batch
+await client.transaction()
+  .patch("article-1", (p) => p.set({ reviewedBy: "alice" }))
+  .patch("article-2", (p) => p.set({ reviewedBy: "alice" }))
+  .commit();
+
+// snapshot — read the raw store for assertions
+expect(client.snapshot().find((d) => d._id === "article-1")?.state).toBe("approved");
+```
+
+More patterns — passing the fake to code typed against `SanityClient`, asserting on writes, sharing a store across consumers, simulating ACL denials — in [docs/patterns.md](https://github.com/sanity-labs/client-fake-for-test/blob/main/docs/patterns.md).
+
+## Client surface — what's supported and what isn't
+
+`SanityClient` is large. This fake covers the data-plane methods most code reaches for, and intentionally leaves the rest out. Compatibility is structural — if your code is typed against the supported subset (or all of `SanityClient` and only touches these methods), the fake drops in unchanged.
+
+### Supported
+
+| Area | Method | Notes |
+| --- | --- | --- |
+| Read | `fetch<T>(query, params?)` | GROQ via groq-js against the in-memory store |
+| Read | `getDocument<T>(id)` | Returns `null` if missing (or hidden by ACL) |
+| Read | `getDocuments<T>(ids)` | Element-wise null for missing |
+| Write | `create(doc, { ifRevisionId? })` | Throws if `_id` already exists |
+| Write | `createOrReplace(doc, { ifRevisionId? })` | Upsert |
+| Write | `createIfNotExists(doc, { ifRevisionId? })` | No-op if `_id` exists |
+| Write | `delete(id, { ifRevisionId? })` | Returns `{ _id }` or `null` |
+| Patch | `patch(id)` chain → `.commit()` | Ops: `.set`, `.setIfMissing`, `.unset`, `.inc`, `.dec`, `.insert(position, anchor, items)`, `.ifRevisionId` |
+| Transaction | `transaction()` chain → `.commit()` | Mutations: `.create`, `.createOrReplace`, `.createIfNotExists`, `.delete`, `.patch(id, recipe)`. Atomic — any throw rolls back the whole batch |
+| Config | `config()` | Returns `{ projectId, dataset }` |
+| Config | `withConfig({ projectId?, dataset? })` | Sibling handle into the same multi-dataset registry |
+| HTTP | `request({ url? \| uri? })` | Present **only** when the client is created with `accessControl`. Serves `/users/me` + the configured ACL path. Absent otherwise. |
+
+### Test-only helpers (not on real `SanityClient`)
+
+Useful in test bodies, but a giveaway that the code under test isn't using the real client. Keep them in the test file, not in the code being tested.
+
+| Method | Use |
+| --- | --- |
+| `client.snapshot()` | Read-only `readonly SanityDocument[]` of the current dataset |
+| `client.seed(documents)` | Replace the current dataset's contents |
+| `client.add(documents)` | Merge documents in without resetting |
+| `client.reset()` | Drop everything in the current dataset |
+| `client.store()` | Direct access to the underlying `TestStore` |
+| `client.datasets()` | `{ projectId, dataset }[]` known to the registry |
+| `createTestClient({ datasets: { "p:d": [...] } })` | Seed multiple `(projectId, dataset)` stores up front |
+
+### Not supported (by design)
+
+The whole-client surface listed below throws / returns `undefined` / is simply absent. Code that depends on these needs a different test strategy (real client against an ephemeral dataset, MSW for HTTP intercepts, or a hand-rolled stub).
+
+| Area | Status | Workaround |
+| --- | --- | --- |
+| `listen(query, params, options)` — real-time | ❌ Absent | Test the subscription logic separately, mock the observable |
+| `mutate(mutations, options)` — bulk array form | ❌ Absent | Use `transaction()` chain instead |
+| `action(actions, options)` — releases / Content Lake actions | ❌ Absent | Stub the call site, or use MSW |
+| `clone()` | ❌ Absent | `withConfig({})` returns a sibling handle |
+| `getUrl(uri)` / `getDataUrl(...)` — URL builders | ❌ Absent | Hard-code in tests |
+| `request(...)` — generic HTTP | ⚠️ Only with `accessControl` | Use [MSW](https://mswjs.io) for arbitrary HTTP |
+| `agent.*` — Agent Actions | ❌ Absent | Stub the namespace |
+| `assets.*` — uploads, metadata | ❌ Absent | Seed asset docs manually |
+| `users.*` / `projects.*` / `datasets.*` / `releases.*` | ❌ Absent | Stub per call site |
+| `observable.*` — RxJS API | ❌ Absent | Wrap the Promise API with `from()` if needed |
+| Perspectives (`drafts.*` / `published.*` / `raw` config) | ❌ All docs visible | Treat IDs literally; no draft/published split |
+| Patch ops: `.diffMatchPatch`, `.merge`, `.append`, `.prepend`, `.replace` | ❌ Absent | `.insert("after", "field[-1]", items)` for append; `.insert("before", "field[0]", items)` for prepend |
+
+> [!IMPORTANT]
+> Unsupported methods aren't silently no-op'd — calling one throws (`...is not a function` for the absent ones, `accessControl required` for `request` without setup). If you type the test variable as `TestClient`, TypeScript catches misuse at compile time; if you cast through `SanityClient`, you'll see the error at runtime instead.
+
+## Design constraints
+
+- **Closure-scoped isolation.** `createTestClient({ documents })` returns a client whose store is local to that closure. Two clients in two tests do not see each other's writes. Pass the *same* client to two consumers if they need to share a store.
+- **Structural compatibility, not nominal.** Methods accept the same arg shapes as `@sanity/client`, so any code typed against `SanityClient` (or a narrow subset) can take a `TestClient` without an adapter.
+- **groq-js directly.** Same GROQ evaluator the real client supports server-side, against the in-memory document set. What groq-js supports, this supports. What it doesn't (some `&&` short-circuit edge cases, custom functions), this doesn't either.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,522 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+var groqJs = require("groq-js");
+class WriteAccessDeniedError extends Error {
+  documentId;
+  permission;
+  matchingGrants;
+  constructor(args) {
+    super(
+      `Sanity (test): permission denied \u2014 actor lacks "${args.permission}" on document "${args.documentId}" (${args.matchingGrants} grant${args.matchingGrants === 1 ? "" : "s"} matched the document but none included "${args.permission}").`
+    ), this.name = "WriteAccessDeniedError", this.documentId = args.documentId, this.permission = args.permission, this.matchingGrants = args.matchingGrants;
+  }
+}
+async function canAccess(args) {
+  return (await evaluateWriteAccess(args)).allowed;
+}
+const parsedFilters = /* @__PURE__ */ new Map();
+async function matchesFilter(args) {
+  const { document, filter, userId } = args;
+  parsedFilters.has(filter) || parsedFilters.set(filter, groqJs.parse(`*[${filter}]`));
+  const ast = parsedFilters.get(filter), data = await (await groqJs.evaluate(ast, {
+    dataset: [document],
+    identity: userId
+  })).get();
+  return Array.isArray(data) && data.length === 1;
+}
+async function evaluateWriteAccess(args) {
+  const { document, grants, permission, userId } = args;
+  let matching = 0;
+  for (const grant of grants)
+    if (await matchesFilter({
+      document,
+      filter: grant.filter,
+      userId
+    }) && (matching++, grant.permissions.includes(permission)))
+      return { allowed: !0, matchingGrants: matching };
+  return { allowed: !1, matchingGrants: matching };
+}
+async function enforceWriteAccess(args) {
+  const { document, grants, permission, userId } = args, { allowed, matchingGrants } = await evaluateWriteAccess({
+    document,
+    grants,
+    permission,
+    userId
+  });
+  if (!allowed)
+    throw typeof document._id != "string" ? new WriteAccessDeniedError({
+      documentId: "(unknown)",
+      permission,
+      matchingGrants
+    }) : new WriteAccessDeniedError({
+      documentId: document._id,
+      permission,
+      matchingGrants
+    });
+}
+function defaultAclPath(projectId, dataset) {
+  return `/projects/${projectId}/datasets/${dataset}/acl`;
+}
+function makeRequestImpl(accessControl, projectId, dataset) {
+  const aclPath = accessControl.aclPath ?? defaultAclPath(projectId, dataset);
+  return async (opts) => {
+    const path = opts.uri ?? opts.url;
+    if (path === "/users/me")
+      return accessControl.currentUser;
+    if (path === aclPath)
+      return accessControl.grants;
+    throw new Error(
+      `TestClient.request: no handler for path "${path}". The TestClient only serves "/users/me" and "${aclPath}". Configure additional endpoints via createTestClient({ accessControl }).`
+    );
+  };
+}
+function createPatch(documentId, executor) {
+  const ops = [];
+  let ifRev;
+  const handle = {
+    set: (props) => (ops.push({ kind: "set", props }), handle),
+    setIfMissing: (props) => (ops.push({ kind: "setIfMissing", props }), handle),
+    unset: (paths) => (ops.push({ kind: "unset", paths }), handle),
+    inc: (props) => (ops.push({ kind: "inc", props }), handle),
+    dec: (props) => (ops.push({ kind: "dec", props }), handle),
+    insert: (position, anchor, items) => (ops.push({ kind: "insert", position, anchor, items }), handle),
+    ifRevisionId: (rev) => (ifRev = rev, handle),
+    commit: () => executor.apply(documentId, ops, ifRev),
+    toJSON: () => ({
+      id: documentId,
+      ops: [...ops],
+      ...ifRev !== void 0 ? { ifRev } : {}
+    })
+  };
+  return handle;
+}
+function applyPatchOps(doc, ops) {
+  let next = structuredClone(doc);
+  for (const op of ops)
+    next = applyOne(next, op);
+  return next;
+}
+function applyOne(doc, op) {
+  switch (op.kind) {
+    case "set":
+      for (const [path, value] of Object.entries(op.props))
+        setAtPath(doc, path, value);
+      return doc;
+    case "setIfMissing":
+      for (const [path, value] of Object.entries(op.props))
+        getAtPath(doc, path) === void 0 && setAtPath(doc, path, value);
+      return doc;
+    case "unset":
+      for (const path of op.paths)
+        unsetAtPath(doc, path);
+      return doc;
+    case "inc":
+      for (const [path, delta] of Object.entries(op.props)) {
+        const current = getAtPath(doc, path);
+        setAtPath(doc, path, (typeof current == "number" ? current : 0) + delta);
+      }
+      return doc;
+    case "dec":
+      for (const [path, delta] of Object.entries(op.props)) {
+        const current = getAtPath(doc, path);
+        setAtPath(doc, path, (typeof current == "number" ? current : 0) - delta);
+      }
+      return doc;
+    case "insert":
+      return insertIntoArray(doc, op.position, op.anchor, op.items), doc;
+  }
+}
+function parsePath(path) {
+  const segments = [];
+  for (const raw of path.split(".")) {
+    const match = /^([A-Za-z_$][\w$]*)(?:\[(.+)\])?$/.exec(raw);
+    if (!match) throw new Error(`Unsupported patch path segment: ${raw}`);
+    const key = match[1], selectorRaw = match[2];
+    if (selectorRaw === void 0) {
+      segments.push({ key });
+      continue;
+    }
+    const indexMatch = /^(\d+)$/.exec(selectorRaw);
+    if (indexMatch) {
+      segments.push({ key, selector: { kind: "index", index: Number(indexMatch[1]) } });
+      continue;
+    }
+    const keyedMatch = /^([A-Za-z_$][\w$]*)\s*==\s*"([^"]*)"$/.exec(selectorRaw);
+    if (keyedMatch) {
+      segments.push({
+        key,
+        selector: { kind: "keyed", field: keyedMatch[1], value: keyedMatch[2] }
+      });
+      continue;
+    }
+    throw new Error(`Unsupported array selector in patch path: ${selectorRaw}`);
+  }
+  return segments;
+}
+function resolveSelector(array, selector) {
+  if (selector.kind === "index") return selector.index;
+  const idx = array.findIndex(
+    (entry) => typeof entry == "object" && entry !== null && entry[selector.field] === selector.value
+  );
+  if (idx === -1)
+    throw new Error(`No array entry matched ${selector.field}=="${selector.value}" in patch path`);
+  return idx;
+}
+function getAtPath(doc, path) {
+  const segments = parsePath(path);
+  let cursor = doc;
+  for (const seg of segments) {
+    if (cursor == null) return;
+    if (cursor = cursor[seg.key], seg.selector !== void 0) {
+      if (!Array.isArray(cursor)) return;
+      const idx = resolveSelector(cursor, seg.selector);
+      cursor = cursor[idx];
+    }
+  }
+  return cursor;
+}
+function setAtPath(doc, path, value) {
+  const segments = parsePath(path);
+  if (segments.length === 0) throw new Error("Empty patch path");
+  let cursor = doc;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    let next = cursor[seg.key];
+    if (next === void 0 && (next = seg.selector?.kind === "index" || seg.selector?.kind === "keyed" ? [] : {}, cursor[seg.key] = next), seg.selector !== void 0) {
+      if (!Array.isArray(next))
+        throw new Error(`Patch path crosses non-array at segment ${seg.key}`);
+      const idx = resolveSelector(next, seg.selector);
+      cursor = next[idx];
+    } else
+      cursor = next;
+  }
+  const last = segments[segments.length - 1];
+  if (last.selector !== void 0) {
+    const arr = cursor[last.key];
+    if (!Array.isArray(arr))
+      throw new Error(`Patch path crosses non-array at segment ${last.key}`);
+    const idx = resolveSelector(arr, last.selector);
+    arr[idx] = value;
+  } else
+    cursor[last.key] = value;
+}
+function unsetAtPath(doc, path) {
+  const segments = parsePath(path);
+  if (segments.length === 0) return;
+  let cursor = doc;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    let next = cursor[seg.key];
+    if (next == null) return;
+    if (seg.selector !== void 0) {
+      if (!Array.isArray(next)) return;
+      const idx = resolveSelector(next, seg.selector);
+      next = next[idx];
+    }
+    cursor = next;
+  }
+  const last = segments[segments.length - 1];
+  if (last.selector !== void 0) {
+    const arr = cursor[last.key];
+    if (!Array.isArray(arr)) return;
+    const idx = resolveSelector(arr, last.selector);
+    arr.splice(idx, 1);
+  } else
+    delete cursor[last.key];
+}
+function insertIntoArray(doc, position, anchor, items) {
+  const segments = parsePath(anchor);
+  if (segments.length === 0) throw new Error("Empty insert anchor");
+  const last = segments[segments.length - 1];
+  if (last.selector === void 0)
+    throw new Error(`Insert anchor must end with an array selector: ${anchor}`);
+  let cursor = doc;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i], next = cursor[seg.key];
+    if (next == null)
+      throw new Error(`Insert anchor traverses missing field: ${seg.key}`);
+    if (seg.selector !== void 0) {
+      if (!Array.isArray(next))
+        throw new Error(`Insert anchor traverses non-array at: ${seg.key}`);
+      cursor = next[resolveSelector(next, seg.selector)];
+    } else
+      cursor = next;
+  }
+  const arr = cursor[last.key];
+  if (!Array.isArray(arr))
+    throw new Error(`Insert anchor target is not an array: ${last.key}`);
+  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);
+    }
+  };
+  return initial && seed(initial), {
+    seed,
+    add: (documents) => {
+      for (const d of documents) {
+        const promoted = promote(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 createTransaction(executor) {
+  const mutations = [], handle = {
+    create: (doc) => (mutations.push({ kind: "create", doc }), handle),
+    createOrReplace: (doc) => (mutations.push({ kind: "createOrReplace", doc }), handle),
+    createIfNotExists: (doc) => (mutations.push({ kind: "createIfNotExists", doc }), handle),
+    delete: (id) => (mutations.push({ kind: "delete", id }), handle),
+    patch: (documentIdOrPatch, ops, ifRev) => {
+      if (typeof documentIdOrPatch == "string")
+        mutations.push({
+          kind: "patch",
+          documentId: documentIdOrPatch,
+          ops: ops ?? [],
+          ...ifRev !== void 0 ? { ifRev } : {}
+        });
+      else {
+        const json = documentIdOrPatch.toJSON();
+        mutations.push({
+          kind: "patch",
+          documentId: json.id,
+          ops: json.ops,
+          ...json.ifRev !== void 0 ? { ifRev: json.ifRev } : {}
+        });
+      }
+      return handle;
+    },
+    commit: (options) => executor.apply(mutations, options),
+    toJSON: () => [...mutations]
+  };
+  return handle;
+}
+const DEFAULT_PROJECT_ID = "test", DEFAULT_DATASET = "test", registryKey = (projectId, dataset) => `${projectId}:${dataset}`, parseRegistryKey = (key) => {
+  const [projectId, dataset] = key.split(":");
+  return { projectId, dataset };
+};
+function createTestClient(options = {}) {
+  const defaultProjectId = options.projectId ?? DEFAULT_PROJECT_ID, defaultDataset = options.dataset ?? DEFAULT_DATASET, registry = /* @__PURE__ */ new Map(), ensureStore = (projectId, dataset) => {
+    const key = registryKey(projectId, dataset);
+    let store = registry.get(key);
+    return store === void 0 && (store = createTestStore(), registry.set(key, store)), store;
+  };
+  if (options.documents && ensureStore(defaultProjectId, defaultDataset).seed(options.documents), options.datasets)
+    for (const [key, docs] of Object.entries(options.datasets)) {
+      const { projectId, dataset } = parseRegistryKey(key);
+      ensureStore(projectId, dataset).seed(docs);
+    }
+  return makeHandle(registry, defaultProjectId, defaultDataset, options.accessControl);
+}
+function makeHandle(registry, projectId, dataset, accessControl) {
+  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) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (typeof doc._id != "string" || doc._id.length === 0)
+      throw new Error("document is missing _id");
+    if (typeof doc._type != "string" || doc._type.length === 0)
+      throw new Error(`document ${doc._id} is missing _type`);
+    return {
+      ...doc,
+      _id: doc._id,
+      _type: doc._type,
+      _rev: cryptoRandomKey(),
+      _createdAt: doc._createdAt ?? now,
+      _updatedAt: now
+    };
+  }, checkRevision = (id, ifRevisionId) => {
+    if (ifRevisionId === void 0) return;
+    const existing = store.get(id);
+    if (existing === void 0)
+      throw new Error(`ifRevisionId check failed: document ${id} does not exist`);
+    if (existing._rev !== ifRevisionId)
+      throw new Error(
+        `ifRevisionId check failed: document ${id} has _rev=${existing._rev}, expected ${ifRevisionId}`
+      );
+  }, gate = async (document, permission) => {
+    accessControl !== void 0 && await enforceWriteAccess({
+      document,
+      grants: accessControl.grants,
+      permission,
+      userId: accessControl.currentUser.id
+    });
+  }, canRead = async (document) => accessControl === void 0 ? !0 : canAccess({
+    document,
+    grants: accessControl.grants,
+    permission: "read",
+    userId: accessControl.currentUser.id
+  }), applyPatch = async (documentId, ops, ifRev) => {
+    const existing = store.get(documentId);
+    if (existing === void 0)
+      throw new Error(`Cannot patch document ${documentId}: not found`);
+    checkRevision(documentId, ifRev), await gate(existing, "update");
+    const patched = applyPatchOps(existing, ops), now = (/* @__PURE__ */ new Date()).toISOString(), next = {
+      ...patched,
+      _rev: cryptoRandomKey(),
+      _updatedAt: now
+    };
+    return store.put(next), next;
+  }, applyTransaction = async (mutations, txnOptions) => {
+    const snapshot = /* @__PURE__ */ new Map(), touchedIds = [], operations = [], remember = (id) => {
+      snapshot.has(id) || snapshot.set(id, store.get(id));
+    };
+    try {
+      for (const mut of mutations)
+        switch (mut.kind) {
+          case "create": {
+            remember(mut.doc._id);
+            const promoted = promote(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" });
+            break;
+          }
+          case "createOrReplace": {
+            remember(mut.doc._id);
+            const promoted = promote(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" });
+            break;
+          }
+          case "createIfNotExists": {
+            if (remember(mut.doc._id), store.get(mut.doc._id) === void 0) {
+              const promoted = promote(mut.doc);
+              await gate(promoted, "create"), store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: "create" });
+            }
+            break;
+          }
+          case "delete": {
+            remember(mut.id);
+            const existing = store.get(mut.id);
+            existing !== void 0 && await gate(existing, "update"), store.remove(mut.id) && (touchedIds.push(mut.id), operations.push({ id: mut.id, operation: "delete" }));
+            break;
+          }
+          case "patch": {
+            remember(mut.documentId), await applyPatch(mut.documentId, mut.ops, mut.ifRev), touchedIds.push(mut.documentId), operations.push({ id: mut.documentId, operation: "update" });
+            break;
+          }
+        }
+    } catch (error) {
+      for (const [id, doc] of snapshot)
+        doc === void 0 ? store.remove(id) : store.put(doc);
+      throw error;
+    }
+    if (txnOptions?.returnDocuments) {
+      const docs = touchedIds.map((id) => store.get(id)).filter((d) => d !== void 0);
+      return txnOptions.returnFirst ? docs[0] : docs;
+    }
+    return {
+      transactionId: cryptoRandomKey(),
+      results: operations
+    };
+  }, visibleDocs = 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;
+  };
+  return {
+    fetch: async (query, params) => {
+      const tree = groqJs.parse(query, params ? { params } : void 0);
+      return await (await groqJs.evaluate(tree, {
+        dataset: await visibleDocs(),
+        ...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) {
+        const doc = store.get(id);
+        doc === void 0 ? result.push(null) : await canRead(doc) ? result.push(doc) : result.push(null);
+      }
+      return result;
+    },
+    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);
+      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);
+      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);
+      return await gate(promoted, "create"), store.put(promoted), promoted;
+    },
+    delete: async (id, opts) => {
+      checkRevision(id, opts?.ifRevisionId);
+      const existing = store.get(id);
+      return existing !== void 0 && await gate(existing, "update"), store.remove(id) ? { _id: id } : null;
+    },
+    patch: (documentId) => createPatch(documentId, { apply: applyPatch }),
+    transaction: () => createTransaction({ apply: applyTransaction }),
+    ...accessControl !== void 0 ? { request: makeRequestImpl(accessControl, projectId, dataset) } : {},
+    config: () => ({ projectId, dataset }),
+    withConfig: (config) => makeHandle(registry, config.projectId ?? projectId, config.dataset ?? dataset, accessControl),
+    seed: (documents) => store.seed(documents),
+    add: (documents) => store.add(documents),
+    reset: () => store.reset(),
+    snapshot: () => store.snapshot(),
+    store: () => store,
+    datasets: () => [...registry.keys()].map(parseRegistryKey)
+  };
+}
+exports.WriteAccessDeniedError = WriteAccessDeniedError;
+exports.applyPatchOps = applyPatchOps;
+exports.createPatch = createPatch;
+exports.createTestClient = createTestClient;
+exports.createTestStore = createTestStore;
+exports.createTransaction = createTransaction;
+exports.defaultAclPath = defaultAclPath;
+exports.evaluateWriteAccess = evaluateWriteAccess;
+//# sourceMappingURL=index.cjs.map