mindoodb-app-sdk 0.0.19 → 0.0.26

package/dist/testing/index.js

@@ -1,4 +1,9 @@
 // src/testing/index.ts
+import * as Automerge from "@automerge/automerge";
+import {
+  evaluateExpression,
+  parseMindooDBFormulaBooleanExpression
+} from "mindoodb-view-language";
 var PROTOCOL = "mindoodb-app-bridge";
 function createBridgeErrorPayload(error, fallbackCode = "bridge-error") {
   if (error && typeof error === "object" && "message" in error) {
@@ -27,7 +32,11 @@ function applyDocumentUpdatePatch(current, patch) {
     applyMockTextPatch(next, textPatch.path, textPatch.edits);
   }
   for (const richTextPatch of patch.richText ?? []) {
-    setValueAtPath(next, richTextPatch.path, structuredClone(richTextPatch.spans));
+    const spans = richTextPatch.spansSequence?.at(-1) ?? richTextPatch.spans ?? [];
+    setValueAtPath(next, richTextPatch.path, structuredClone(spans));
+  }
+  for (const richTextStepPatch of patch.richTextSteps ?? []) {
+    applyMockRichTextSteps(next, richTextStepPatch.path, richTextStepPatch.steps);
   }
   return next;
 }
@@ -49,6 +58,19 @@ function applyMockJsonPatch(target, patch) {
     const list = readListAtPath(target, operation.path);
     list.splice(operation.index, 0, ...structuredClone(operation.values));
   }
+  for (const operation of patch.textSplice ?? []) {
+    applyMockTextPatch(target, operation.path, [{
+      index: operation.index,
+      deleteCount: operation.deleteCount,
+      ...operation.insert !== void 0 ? { insert: operation.insert } : {}
+    }]);
+  }
+  for (const operation of patch.textMark ?? []) {
+    applyMockTextMarks(target, operation.path, operation.index, operation.length, operation.marks, false);
+  }
+  for (const operation of patch.textUnmark ?? []) {
+    applyMockTextMarks(target, operation.path, operation.index, operation.length, Object.fromEntries(operation.names.map((name) => [name, null])), true);
+  }
 }
 function setValueAtPath(target, path, value) {
   if (path.length === 0) {
@@ -128,6 +150,21 @@ function applyMockTextPatch(target, path, edits) {
   }
   parent[leaf] = value;
 }
+function applyMockTextMarks(target, path, index, length, marks, remove) {
+  const parent = ensureParentAtPath(target, path);
+  const leaf = path[path.length - 1];
+  const marksKey = `${String(leaf)}__marks`;
+  const existing = Array.isArray(parent[marksKey]) ? parent[marksKey] : [];
+  parent[marksKey] = [
+    ...existing,
+    {
+      index,
+      length,
+      marks: structuredClone(marks),
+      remove
+    }
+  ];
+}
 function readRichTextSpansAtPath(target, path) {
   let value = target;
   for (const segment of path) {
@@ -136,8 +173,38 @@ function readRichTextSpansAtPath(target, path) {
     }
     value = value[segment];
   }
+  if (typeof value === "string") {
+    return value.length > 0 ? [{ type: "text", value }] : [];
+  }
   return Array.isArray(value) ? value : [];
 }
+function applyMockRichTextSteps(target, path, steps) {
+  if (path.length === 0) {
+    throw new Error("Rich-text steps path must contain at least one segment");
+  }
+  const parent = ensureParentAtPath(target, path);
+  const leaf = path[path.length - 1];
+  let text = materializeMockRichTextValue(parent[leaf]);
+  for (const step of steps) {
+    text = text.slice(0, step.index) + (step.insert ?? "") + text.slice(step.index + step.deleteCount);
+  }
+  parent[leaf] = text;
+}
+function materializeMockRichTextValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  return value.map((span) => {
+    if (!span || typeof span !== "object") {
+      return "";
+    }
+    const record = span;
+    return record.type === "text" && typeof record.value === "string" ? record.value : "";
+  }).join("");
+}
 function mergeLaunchContext(current, patch) {
   if (!patch) {
     return {
@@ -244,10 +311,12 @@ function createDefaultLaunchContext(patch) {
     uiPreferences: {
       iosMultitaskingOptimized: false
     },
+    locale: "en",
     user: {
       id: "user-1",
       username: "Test User"
     },
+    licensedProducts: [],
     launchParameters: {},
     databases: [],
     views: []
@@ -291,6 +360,22 @@ function createDefaultWritableAttachmentStream() {
     }
   };
 }
+function loadMockAutomergeDocument(document) {
+  if (document.automergeBinary) {
+    return Automerge.load(document.automergeBinary);
+  }
+  const initialDoc = Automerge.from({
+    ...structuredClone(document.data),
+    body: typeof document.data.body === "string" ? document.data.body : ""
+  });
+  document.automergeBinary = Automerge.save(initialDoc);
+  return initialDoc;
+}
+function persistMockAutomergeDocument(document, automergeDoc) {
+  document.automergeBinary = Automerge.save(automergeDoc);
+  document.data = structuredClone(automergeDoc);
+  document.heads = Automerge.getHeads(automergeDoc);
+}
 function getFieldValue(source, field) {
   return field.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
@@ -314,6 +399,138 @@ function decodeMockListCursor(cursor) {
   const offset = Number.parseInt(cursor, 10);
   return Number.isFinite(offset) && offset >= 0 ? offset : 0;
 }
+function mockExpressionToBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "false" && normalized !== "0" && normalized !== "no";
+  }
+  return Boolean(value);
+}
+function compareMockQueryValues(left, right) {
+  const leftNumber = typeof left === "number" ? left : Number(left);
+  const rightNumber = typeof right === "number" ? right : Number(right);
+  if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
+    return leftNumber - rightNumber;
+  }
+  return String(left ?? "").localeCompare(String(right ?? ""), void 0, {
+    sensitivity: "base"
+  });
+}
+function collectMockText(value, depth = 0) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || typeof value !== "object" || depth > 8) {
+    return "";
+  }
+  const parts = [];
+  for (const item of Array.isArray(value) ? value : Object.values(value)) {
+    const text = collectMockText(item, depth + 1);
+    if (text.length > 0) {
+      parts.push(text);
+    }
+  }
+  return parts.join(" ");
+}
+function mockTokenize(text) {
+  return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((token) => token.length > 0);
+}
+function computeMockTextScore(document, clause) {
+  const terms = mockTokenize(clause.query);
+  if (terms.length === 0) {
+    return void 0;
+  }
+  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue(document.data, field))).join(" ") : collectMockText(
+    Object.fromEntries(
+      Object.entries(document.data).filter(([key]) => !key.startsWith("_"))
+    )
+  );
+  const tokens = mockTokenize(haystack);
+  const prefix = clause.prefix ?? true;
+  const combineWith = clause.combineWith ?? "AND";
+  let matchedTerms = 0;
+  let score = 0;
+  for (const term of terms) {
+    const occurrences = tokens.filter(
+      (token) => prefix ? token.startsWith(term) : token === term
+    ).length;
+    if (occurrences > 0) {
+      matchedTerms++;
+      score += occurrences;
+    }
+  }
+  const matches = combineWith === "AND" ? matchedTerms === terms.length : matchedTerms > 0;
+  return matches ? score : void 0;
+}
+function runMockDocumentQuery(storedDocuments, databaseId, query) {
+  const filter = typeof query?.filter === "string" ? parseMindooDBFormulaBooleanExpression(query.filter) : query?.filter;
+  const sortBy = query?.sortBy && query.sortBy.length > 0 ? query.sortBy : query?.text ? [{ special: "textScore", direction: "descending" }] : [];
+  const matches = [];
+  for (const document of storedDocuments.values()) {
+    if (document.isDeleted) {
+      continue;
+    }
+    let textScore;
+    if (query?.text) {
+      textScore = computeMockTextScore(document, query.text);
+      if (textScore === void 0) {
+        continue;
+      }
+    }
+    const context = {
+      doc: document.data,
+      values: {},
+      origin: databaseId,
+      variables: {}
+    };
+    if (filter && !mockExpressionToBoolean(evaluateExpression(filter, context))) {
+      continue;
+    }
+    const sortValues = sortBy.map((key) => {
+      if (key.special === "textScore") {
+        return textScore ?? 0;
+      }
+      return key.expression ? evaluateExpression(key.expression, context) : getFieldValue(document.data, key.field ?? "");
+    });
+    matches.push({ document, sortValues, textScore });
+  }
+  if (sortBy.length > 0) {
+    matches.sort((left, right) => {
+      for (let i = 0; i < sortBy.length; i++) {
+        const result = compareMockQueryValues(
+          left.sortValues[i],
+          right.sortValues[i]
+        );
+        if (result !== 0) {
+          return sortBy[i].direction === "descending" ? -result : result;
+        }
+      }
+      return left.document.id.localeCompare(right.document.id);
+    });
+  } else {
+    matches.sort((left, right) => left.document.id.localeCompare(right.document.id));
+  }
+  const offset = Math.max(0, query?.offset ?? 0);
+  const limit = Math.max(1, query?.limit ?? 200);
+  const rows = matches.slice(offset, offset + limit).map(({ document, textScore }) => ({
+    docId: document.id,
+    fields: query?.fields ? Object.fromEntries(
+      query.fields.map((field) => [
+        field,
+        getFieldValue(document.data, field)
+      ])
+    ) : structuredClone(document.data),
+    lastModified: document.updatedAt ? Date.parse(document.updatedAt) || 0 : 0,
+    ...textScore === void 0 ? {} : { textScore }
+  }));
+  return { rows, total: matches.length, coverage: "full" };
+}
 function createDefaultViewNavigator() {
   const definition = {
     title: "Mock View",
@@ -344,6 +561,10 @@ function createDefaultViewNavigator() {
     async refresh() {
       return viewCursor;
     },
+    onDidUpdate(_listener) {
+      return () => {
+      };
+    },
     async getCurrentEntry() {
       return null;
     },
@@ -523,7 +744,56 @@ function createDatabaseHandle(definition) {
   let changeCounter = 0;
   const defaultViewFactory = async () => createDefaultViewNavigator();
   const storedDocuments = /* @__PURE__ */ new Map();
+  const liveQuerySubscriptions = /* @__PURE__ */ new Set();
+  const notifyLiveQueries = () => {
+    for (const subscription of liveQuerySubscriptions) {
+      const result = runMockDocumentQuery(
+        storedDocuments,
+        definition.info.id,
+        subscription.query
+      );
+      const resultJson = JSON.stringify(result);
+      if (resultJson !== subscription.lastResultJson) {
+        subscription.lastResultJson = resultJson;
+        subscription.onResult(result);
+      }
+    }
+  };
   const defaultDocuments = {
+    async query(query) {
+      return runMockDocumentQuery(storedDocuments, definition.info.id, query);
+    },
+    async liveQuery(query, onResult) {
+      const initial = runMockDocumentQuery(
+        storedDocuments,
+        definition.info.id,
+        query
+      );
+      const subscription = {
+        query,
+        onResult,
+        lastResultJson: JSON.stringify(initial)
+      };
+      liveQuerySubscriptions.add(subscription);
+      onResult(initial);
+      return {
+        refresh: async () => {
+          if (!liveQuerySubscriptions.has(subscription)) {
+            return;
+          }
+          const result = runMockDocumentQuery(
+            storedDocuments,
+            definition.info.id,
+            query
+          );
+          subscription.lastResultJson = JSON.stringify(result);
+          onResult(result);
+        },
+        dispose: async () => {
+          liveQuerySubscriptions.delete(subscription);
+        }
+      };
+    },
     async list(query) {
       const status = query?.status ?? "existing";
       const skip = Math.max(0, query?.skip ?? 0);
@@ -591,6 +861,53 @@ function createDatabaseHandle(definition) {
         spans: structuredClone(readRichTextSpansAtPath(document.data, path))
       };
     },
+    async getAutomergeSnapshot(docId, _options) {
+      const document = storedDocuments.get(docId);
+      if (!document || document.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      const automergeDoc = loadMockAutomergeDocument(document);
+      return {
+        binary: Automerge.save(automergeDoc),
+        heads: Automerge.getHeads(automergeDoc)
+      };
+    },
+    async applyAutomergeChanges(docId, patch) {
+      const document = storedDocuments.get(docId);
+      if (!document || document.isDeleted) {
+        throw new Error(`Document ${docId} was not found.`);
+      }
+      const currentDoc = loadMockAutomergeDocument(document);
+      const [mergedDoc] = Automerge.applyChanges(
+        currentDoc,
+        patch.changes.map((change) => new Uint8Array(change))
+      );
+      persistMockAutomergeDocument(document, mergedDoc);
+      document.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const mergedHeads = document.heads ? [...document.heads] : [];
+      let changesSince;
+      if (patch.replicaHeads?.length) {
+        const missingChanges = Automerge.getChangesSince(
+          mergedDoc,
+          patch.replicaHeads
+        );
+        changesSince = {
+          sinceHeads: [...patch.replicaHeads],
+          changes: missingChanges.map((change) => cloneBytes(new Uint8Array(change)))
+        };
+      }
+      return {
+        document: {
+          id: document.id,
+          data: structuredClone(document.data),
+          heads: mergedHeads,
+          attachments: document.attachments ? structuredClone(document.attachments) : [],
+          updatedAt: document.updatedAt
+        },
+        heads: mergedHeads,
+        changesSince
+      };
+    },
     async create(input) {
       const callerId = typeof input.id === "string" && input.id.length > 0 ? input.id : null;
       if (callerId) {
@@ -600,6 +917,7 @@ function createDatabaseHandle(definition) {
             existing.isDeleted = false;
             existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
             existing.heads = [`mock-head-${++changeCounter}`];
+            notifyLiveQueries();
           }
           return {
             id: existing.id,
@@ -631,10 +949,19 @@ function createDatabaseHandle(definition) {
         attachments: [],
         isDeleted: false
       });
+      notifyLiveQueries();
       return {
         ...created
       };
     },
+    async createMany(inputs) {
+      const ids = [];
+      for (const input of inputs) {
+        const created = await defaultDocuments.create(input);
+        ids.push(created.id);
+      }
+      return { ids };
+    },
     async update(docId, patch) {
       const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       const existing = storedDocuments.get(docId);
@@ -649,8 +976,10 @@ function createDatabaseHandle(definition) {
         ...updated,
         data: structuredClone(updated.data),
         attachments: updated.attachments ? structuredClone(updated.attachments) : [],
-        isDeleted: false
+        isDeleted: false,
+        automergeBinary: void 0
       });
+      notifyLiveQueries();
       return updated;
     },
     async delete(_docId) {
@@ -661,6 +990,13 @@ function createDatabaseHandle(definition) {
           isDeleted: true,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
+        notifyLiveQueries();
+      }
+      return { ok: true };
+    },
+    async deleteMany(docIds) {
+      for (const docId of docIds) {
+        await defaultDocuments.delete(docId);
       }
       return { ok: true };
     },
@@ -673,9 +1009,25 @@ function createDatabaseHandle(definition) {
           heads: [`mock-head-${++changeCounter}`],
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
+        notifyLiveQueries();
       }
       return { ok: true };
     },
+    async canCreate() {
+      return { allowed: true, reason: "allowed (test host)", tier: "tier1" };
+    },
+    async canChange(_docId) {
+      return { allowed: true, reason: "allowed (test host)", tier: "tier1" };
+    },
+    async canDelete(_docId) {
+      return { allowed: true, reason: "allowed (test host)", tier: "tier1" };
+    },
+    async canUndelete(_docId) {
+      return { allowed: true, reason: "allowed (test host)", tier: "tier1" };
+    },
+    async getDefaultCreateKeyId() {
+      return "default";
+    },
     async listHistory(_docId) {
       return [];
     },
@@ -743,6 +1095,8 @@ function createDatabaseHandle(definition) {
     }
   };
   const methods = definition.methods ?? {};
+  let fulltextSetup = definition.fulltextSetup ?? null;
+  let extractionSetup = definition.extractionSetup ?? null;
   return {
     async info() {
       return {
@@ -757,6 +1111,18 @@ function createDatabaseHandle(definition) {
     attachments: {
       ...defaultAttachments,
       ...methods.attachments
+    },
+    async getFulltextSetup() {
+      return fulltextSetup === null ? null : { ...fulltextSetup };
+    },
+    async setFulltextSetup(config) {
+      fulltextSetup = config === null ? null : { ...config };
+    },
+    async getExtractionSetup() {
+      return extractionSetup === null ? null : { ...extractionSetup };
+    },
+    async setExtractionSetup(config) {
+      extractionSetup = config === null ? null : { ...config };
     }
   };
 }
@@ -765,6 +1131,7 @@ function createMockSessionState(options = {}) {
   const themeListeners = /* @__PURE__ */ new Set();
   const viewportListeners = /* @__PURE__ */ new Set();
   const uiPreferencesListeners = /* @__PURE__ */ new Set();
+  const localeListeners = /* @__PURE__ */ new Set();
   const databaseHandles = /* @__PURE__ */ new Map();
   const databaseViewApis = /* @__PURE__ */ new Map();
   const sessionViews = /* @__PURE__ */ new Map();
@@ -818,6 +1185,9 @@ function createMockSessionState(options = {}) {
     async getLaunchContext() {
       return mergeLaunchContext(launchContext);
     },
+    async getLicensedProducts() {
+      return [...launchContext.licensedProducts ?? []];
+    },
     async listDatabases() {
       return databaseInfos.map((entry) => ({
         ...entry,
@@ -895,6 +1265,12 @@ function createMockSessionState(options = {}) {
         uiPreferencesListeners.delete(listener);
       };
     },
+    onLocaleChange(listener) {
+      localeListeners.add(listener);
+      return () => {
+        localeListeners.delete(listener);
+      };
+    },
     async disconnect() {
       await options.onDisconnect?.();
     }
@@ -926,6 +1302,9 @@ function createMockSessionState(options = {}) {
       }
       return database;
     },
+    getLicensedProducts() {
+      return [...launchContext.licensedProducts ?? []];
+    },
     createViewNavigator: session.createViewNavigator,
     openViewNavigator: session.openViewNavigator,
     bridge,
@@ -945,6 +1324,10 @@ function createMockSessionState(options = {}) {
       uiPreferencesListeners.forEach(
         (listener) => listener({ ...launchContext.uiPreferences })
       );
+    },
+    emitLocaleChange(locale) {
+      launchContext = mergeLaunchContext(launchContext, { locale });
+      localeListeners.forEach((listener) => listener(launchContext.locale));
     }
   };
 }
@@ -955,11 +1338,13 @@ function createMockMindooDBAppSession(options = {}) {
     session: state.session,
     getLaunchContext: state.getLaunchContext,
     setLaunchContext: state.setLaunchContext,
+    getLicensedProducts: state.getLicensedProducts,
     listDatabases: state.listDatabaseInfos,
     setDatabases: state.setDatabases,
     emitThemeChange: state.emitThemeChange,
     emitViewportChange: state.emitViewportChange,
-    emitUiPreferencesChange: state.emitUiPreferencesChange
+    emitUiPreferencesChange: state.emitUiPreferencesChange,
+    emitLocaleChange: state.emitLocaleChange
   };
 }
 function createMockMindooDBAppBridge(options = {}) {
@@ -975,8 +1360,10 @@ function createFakeBridgeHost(options = {}) {
   const viewSessions = /* @__PURE__ */ new Map();
   const readStreams = /* @__PURE__ */ new Map();
   const writeStreams = /* @__PURE__ */ new Map();
+  const liveQueries = /* @__PURE__ */ new Map();
   let viewCounter = 0;
   let streamCounter = 0;
+  let liveQueryCounter = 0;
   let previousWindowDescriptor = Object.getOwnPropertyDescriptor(
     globalThis,
     "window"
@@ -1121,6 +1508,8 @@ function createFakeBridgeHost(options = {}) {
     switch (request.method) {
       case "session.getLaunchContext":
         return state.getLaunchContext();
+      case "session.getLicensedProducts":
+        return state.getLicensedProducts();
       case "session.listDatabases":
         return state.listDatabaseInfos();
       case "session.openDatabase":
@@ -1162,6 +1551,62 @@ function createFakeBridgeHost(options = {}) {
         );
       case "documents.getHeadCursor":
         return await state.getDatabase(String(params.databaseId)).documents.getHeadCursor();
+      case "database.getFulltextSetup":
+        return {
+          config: await state.getDatabase(String(params.databaseId)).getFulltextSetup()
+        };
+      case "database.setFulltextSetup":
+        await state.getDatabase(String(params.databaseId)).setFulltextSetup(
+          params.config ?? null
+        );
+        return { ok: true };
+      case "database.getExtractionSetup":
+        return {
+          config: await state.getDatabase(String(params.databaseId)).getExtractionSetup()
+        };
+      case "database.setExtractionSetup":
+        await state.getDatabase(String(params.databaseId)).setExtractionSetup(
+          params.config ?? null
+        );
+        return { ok: true };
+      case "documents.query":
+        return await state.getDatabase(String(params.databaseId)).documents.query(
+          params.query
+        );
+      case "documents.liveQuery.subscribe": {
+        const subscriptionId = `live-query-${liveQueryCounter += 1}`;
+        let initialResult = null;
+        let initialDelivered = false;
+        const handle = await state.getDatabase(String(params.databaseId)).documents.liveQuery(
+          params.query,
+          (result) => {
+            if (!initialDelivered) {
+              initialDelivered = true;
+              initialResult = result;
+              return;
+            }
+            const payload = {
+              protocol: PROTOCOL,
+              kind: "query-result",
+              subscriptionId,
+              result
+            };
+            connectedPorts.forEach((port) => port.postMessage(payload));
+          }
+        );
+        liveQueries.set(subscriptionId, handle);
+        return { subscriptionId, result: initialResult };
+      }
+      case "documents.liveQuery.refresh": {
+        await liveQueries.get(String(params.subscriptionId))?.refresh();
+        return { ok: true };
+      }
+      case "documents.liveQuery.unsubscribe": {
+        const key = String(params.subscriptionId);
+        await liveQueries.get(key)?.dispose();
+        liveQueries.delete(key);
+        return { ok: true };
+      }
       case "documents.get":
         return await state.getDatabase(String(params.databaseId)).documents.get(String(params.docId));
       case "documents.richText.get":
@@ -1169,6 +1614,16 @@ function createFakeBridgeHost(options = {}) {
           String(params.docId),
           params.path
         );
+      case "documents.automerge.getSnapshot":
+        return await state.getDatabase(String(params.databaseId)).documents.getAutomergeSnapshot(
+          String(params.docId),
+          { revisionId: params.revisionId }
+        );
+      case "documents.automerge.applyChanges":
+        return await state.getDatabase(String(params.databaseId)).documents.applyAutomergeChanges(
+          String(params.docId),
+          params.patch
+        );
       case "documents.create":
         return await state.getDatabase(String(params.databaseId)).documents.create(
           params.input
@@ -1182,6 +1637,18 @@ function createFakeBridgeHost(options = {}) {
         return await state.getDatabase(String(params.databaseId)).documents.delete(String(params.docId));
       case "documents.undelete":
         return await state.getDatabase(String(params.databaseId)).documents.undelete(String(params.docId));
+      case "documents.canCreate":
+        return await state.getDatabase(String(params.databaseId)).documents.canCreate(
+          params.input
+        );
+      case "documents.canChange":
+        return await state.getDatabase(String(params.databaseId)).documents.canChange(String(params.docId));
+      case "documents.canDelete":
+        return await state.getDatabase(String(params.databaseId)).documents.canDelete(String(params.docId));
+      case "documents.canUndelete":
+        return await state.getDatabase(String(params.databaseId)).documents.canUndelete(String(params.docId));
+      case "documents.getDefaultCreateKeyId":
+        return await state.getDatabase(String(params.databaseId)).documents.getDefaultCreateKeyId();
       case "documents.history.list":
         return await state.getDatabase(String(params.databaseId)).documents.listHistory(String(params.docId));
       case "documents.history.getAtTimestamp":
@@ -1513,6 +1980,10 @@ function createFakeBridgeHost(options = {}) {
       viewSessions.clear();
       readStreams.clear();
       writeStreams.clear();
+      liveQueries.forEach((handle) => {
+        void handle.dispose();
+      });
+      liveQueries.clear();
     },
     emitThemeChange(theme) {
       state.emitThemeChange(theme);
@@ -1541,6 +2012,33 @@ function createFakeBridgeHost(options = {}) {
       };
       connectedPorts.forEach((port) => port.postMessage(payload));
     },
+    emitLocaleChange(locale) {
+      state.emitLocaleChange(locale);
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "locale-changed",
+        locale
+      };
+      connectedPorts.forEach((port) => port.postMessage(payload));
+    },
+    emitQueryResult(subscriptionId, result) {
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "query-result",
+        subscriptionId,
+        result
+      };
+      connectedPorts.forEach((port) => port.postMessage(payload));
+    },
+    emitViewChanged(navigatorId, stats) {
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "view-changed",
+        navigatorId,
+        stats
+      };
+      connectedPorts.forEach((port) => port.postMessage(payload));
+    },
     postPortMessage(message, transfer = []) {
       connectedPorts.forEach((port) => port.postMessage(message, transfer));
     },