mindoodb-app-sdk 0.0.46 → 0.0.48

package/dist/testing/index.js

@@ -1,11 +1,12 @@
 import {
   releaseMindooDBAppBridgeSessions
-} from "../chunk-XPPTUWW6.js";
+} from "../chunk-TPYDERAK.js";
 
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
 import {
   evaluateExpression as evaluateExpression2,
+  formatMindooDBFormulaExpression,
   parseMindooDBFormulaBooleanExpression
 } from "mindoodb-view-language";
 
@@ -27,14 +28,16 @@ function toFormulaBoolean(value) {
   }
   return Boolean(value);
 }
-function matchesFilter(mindoodb, definition, doc, origin, createdAt, lastModifiedAt, witnessed, awaitingWitness) {
+function matchesFilter(mindoodb, definition, document) {
   void mindoodb;
   if (!definition.filter) return true;
+  const { data: doc, origin, docId, createdAt, lastModifiedAt, witnessed, awaitingWitness } = document;
   return toFormulaBoolean(
     evaluateExpression(definition.filter.expression, {
       doc,
       values: doc,
       origin,
+      docId,
       createdAt,
       lastModifiedAt,
       witnessed,
@@ -43,7 +46,8 @@ function matchesFilter(mindoodb, definition, doc, origin, createdAt, lastModifie
     })
   );
 }
-function computeColumnValues(definition, doc, origin, createdAt, lastModifiedAt, witnessed, awaitingWitness) {
+function computeColumnValues(definition, document) {
+  const { data: doc, origin, docId, createdAt, lastModifiedAt, witnessed, awaitingWitness } = document;
   const values = {};
   for (const [key, value] of Object.entries(doc)) {
     if (!key.startsWith("_")) values[key] = value;
@@ -54,6 +58,7 @@ function computeColumnValues(definition, doc, origin, createdAt, lastModifiedAt,
       doc,
       values,
       origin,
+      docId,
       createdAt,
       lastModifiedAt,
       witnessed,
@@ -167,31 +172,11 @@ async function buildVirtualView(mindoodb, definition, documents, categorizationS
   const view = await builder.build();
   const changes = /* @__PURE__ */ new Map();
   for (const document of documents) {
-    if (!matchesFilter(
-      mindoodb,
-      definition,
-      document.data,
-      document.origin,
-      document.createdAt,
-      document.lastModifiedAt,
-      document.witnessed,
-      document.awaitingWitness
-    )) {
+    if (!matchesFilter(mindoodb, definition, document)) {
       continue;
     }
     const change = changes.get(document.origin) ?? new mindoodb.VirtualViewDataChange(document.origin);
-    change.addEntry(
-      document.docId,
-      computeColumnValues(
-        definition,
-        document.data,
-        document.origin,
-        document.createdAt,
-        document.lastModifiedAt,
-        document.witnessed,
-        document.awaitingWitness
-      )
-    );
+    change.addEntry(document.docId, computeColumnValues(definition, document));
     changes.set(document.origin, change);
   }
   for (const change of changes.values()) {
@@ -679,6 +664,7 @@ function mergeLaunchContext(current, patch) {
       viewport: current.viewport ? { ...current.viewport } : null,
       uiPreferences: { ...current.uiPreferences },
       user: { ...current.user },
+      appPermissions: [...current.appPermissions ?? []],
       launchParameters: { ...current.launchParameters },
       databases: current.databases.map((database) => ({
         ...database,
@@ -712,6 +698,7 @@ function mergeLaunchContext(current, patch) {
     viewport: patch.viewport === void 0 ? current.viewport ? { ...current.viewport } : null : patch.viewport ? { ...patch.viewport } : null,
     uiPreferences: patch.uiPreferences ? { ...current.uiPreferences, ...patch.uiPreferences } : { ...current.uiPreferences },
     user: patch.user ? { ...current.user, ...patch.user } : { ...current.user },
+    appPermissions: [...patch.appPermissions ?? current.appPermissions ?? []],
     launchParameters: patch.launchParameters ? { ...current.launchParameters, ...patch.launchParameters } : { ...current.launchParameters },
     databases: patch.databases ? patch.databases.map((database) => ({
       ...database,
@@ -785,6 +772,7 @@ function createDefaultLaunchContext(patch) {
       username: "Test User"
     },
     licensedProducts: [],
+    appPermissions: [],
     launchParameters: {},
     databases: [],
     views: []
@@ -948,7 +936,7 @@ function computeMockTextScore(document, clause) {
   const matches = combineWith === "AND" ? matchedTerms === terms.length : matchedTerms > 0;
   return matches ? score : void 0;
 }
-function runMockDocumentQuery(storedDocuments, databaseId, query) {
+function runMockDocumentQuery(storedDocuments, databaseId, query, resolveDatabase) {
   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 = [];
@@ -967,6 +955,7 @@ function runMockDocumentQuery(storedDocuments, databaseId, query) {
       doc: document.data,
       values: {},
       origin: databaseId,
+      docId: document.id,
       variables: {}
     };
     if (filter && !mockExpressionToBoolean(evaluateExpression2(filter, context))) {
@@ -998,19 +987,343 @@ function runMockDocumentQuery(storedDocuments, databaseId, query) {
   }
   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 }) => ({
+  const page = matches.slice(offset, offset + limit);
+  const rows = page.map(({ document, textScore }) => ({
     docId: document.id,
-    fields: query?.fields ? Object.fromEntries(
-      query.fields.map((field) => [
-        field,
-        getFieldValue2(document.data, field)
-      ])
-    ) : structuredClone(document.data),
-    lastModified: document.updatedAt ? Date.parse(document.updatedAt) || 0 : 0,
+    fields: projectMockFields(document.data, query?.fields),
+    lastModified: mockLastModified(document),
     ...textScore === void 0 ? {} : { textScore }
   }));
+  if (query?.include) {
+    hydrateMockIncludes({
+      includes: query.include,
+      parents: page.map(({ document }, index) => ({
+        row: rows[index],
+        docId: document.id,
+        data: document.data
+      })),
+      parentDatabaseId: databaseId,
+      parentDocuments: storedDocuments,
+      resolveDatabase,
+      depth: 1,
+      slotPath: ""
+    });
+  }
   return { rows, total: matches.length, coverage: "full" };
 }
+function projectMockFields(data, fields) {
+  return fields ? Object.fromEntries(fields.map((field) => [field, getFieldValue2(data, field)])) : structuredClone(data);
+}
+function mockLastModified(document) {
+  return document.updatedAt ? Date.parse(document.updatedAt) || 0 : 0;
+}
+var MOCK_MAX_INCLUDE_DEPTH = 3;
+var MOCK_DEFAULT_INCLUDE_LIMIT = 200;
+function mockIncludeFilter(include) {
+  return typeof include.filter === "string" ? parseMindooDBFormulaBooleanExpression(include.filter) : include.filter;
+}
+function flattenMockConjuncts(expression) {
+  return expression.kind === "operation" && expression.op === "and" ? expression.args.flatMap((arg) => flattenMockConjuncts(arg)) : [expression];
+}
+function mockReferencesParent(expression) {
+  if (expression.kind === "parent") {
+    return true;
+  }
+  if (expression.kind === "operation") {
+    return expression.op === "parentDocId" || expression.args.some((arg) => mockReferencesParent(arg));
+  }
+  if (expression.kind === "if") {
+    return [expression.condition, expression.whenTrue, expression.whenFalse].some(
+      (part) => mockReferencesParent(part)
+    );
+  }
+  if (expression.kind === "let") {
+    return Object.values(expression.bindings).some((value) => mockReferencesParent(value)) || mockReferencesParent(expression.result);
+  }
+  return false;
+}
+function mockChildJoinSide(expression) {
+  if (expression.kind === "field") {
+    return { kind: "field", path: expression.path };
+  }
+  if (expression.kind === "operation" && expression.op === "docId") {
+    return { kind: "docId" };
+  }
+  return null;
+}
+function mockParentJoinSide(expression) {
+  if (expression.kind === "parent") {
+    return { kind: "field", path: expression.path };
+  }
+  if (expression.kind === "operation" && expression.op === "parentDocId") {
+    return { kind: "docId" };
+  }
+  return null;
+}
+function combineMockConjuncts(conjuncts) {
+  if (conjuncts.length === 0) {
+    return null;
+  }
+  if (conjuncts.length === 1) {
+    return conjuncts[0];
+  }
+  return {
+    kind: "operation",
+    op: "and",
+    args: conjuncts
+  };
+}
+function planMockInclude(label, include, filter) {
+  if (include.localKey !== void 0) {
+    if (filter && mockReferencesParent(filter)) {
+      throw new Error(
+        `Include "${label}" combines localKey with a filter that also references the parent document. Use either localKey or a parent join condition, not both.`
+      );
+    }
+    return {
+      child: { kind: "docId" },
+      parent: { kind: "field", path: include.localKey },
+      residualFilter: filter ?? null
+    };
+  }
+  const conjuncts = flattenMockConjuncts(filter);
+  const parentConjuncts = conjuncts.filter((conjunct) => mockReferencesParent(conjunct));
+  const parentFree = conjuncts.filter((conjunct) => !mockReferencesParent(conjunct));
+  if (parentConjuncts.length === 0) {
+    throw new Error(
+      `Include "${label}" cannot be joined because it does not reference the parent document. Add the join condition v.eq(v.field("<child field>"), v.parentDocId()) (or use localKey).`
+    );
+  }
+  if (parentConjuncts.length > 1) {
+    throw new Error(
+      `Include "${label}" cannot be joined because it references the parent document in ${parentConjuncts.length} separate conditions. Exactly one parent equality can be used as the join key.`
+    );
+  }
+  const join = parentConjuncts[0];
+  if (join.kind !== "operation" || join.op !== "eq" || join.args.length !== 2) {
+    throw new Error(
+      `Include "${label}" cannot be joined because the condition referencing the parent is not an equality: ${formatMindooDBFormulaExpression(join)}. Only v.eq(v.field("<child field>"), v.parentDocId()) and friends can be used as the join key.`
+    );
+  }
+  const [left, right] = join.args;
+  const sides = mockJoinSides(left, right) ?? mockJoinSides(right, left) ?? null;
+  if (!sides) {
+    throw new Error(
+      `Include "${label}" cannot be joined because the join equality compares ${formatMindooDBFormulaExpression(join)}. One side must read the related document (v.field(...) or v.docId()), the other the parent (v.parent(...) or v.parentDocId()).`
+    );
+  }
+  return { ...sides, residualFilter: combineMockConjuncts(parentFree) };
+}
+function mockJoinSides(childCandidate, parentCandidate) {
+  const child = mockChildJoinSide(childCandidate);
+  const parent = mockParentJoinSide(parentCandidate);
+  return child && parent ? { child, parent } : null;
+}
+function mockJoinValues(value) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  return (Array.isArray(value) ? value : [value]).filter(
+    (item) => item !== void 0 && item !== null
+  );
+}
+function validateMockInclude(slot, label, include, depth) {
+  if (slot.trim() === "") {
+    throw new Error("Include slot names must not be empty.");
+  }
+  if (depth > MOCK_MAX_INCLUDE_DEPTH) {
+    throw new Error(
+      `Include "${label}" nests ${depth} levels deep, more than the maximum of ${MOCK_MAX_INCLUDE_DEPTH}.`
+    );
+  }
+  if (include.cardinality !== "one" && include.cardinality !== "many") {
+    throw new Error(
+      `Include "${label}" needs an explicit cardinality of "one" or "many" (got ${JSON.stringify(include.cardinality)}).`
+    );
+  }
+  if (include.localKey === void 0 && include.filter === void 0) {
+    throw new Error(
+      `Include "${label}" needs a localKey or a filter to relate documents to the parent row.`
+    );
+  }
+  if (include.localKey !== void 0 && include.localKey.trim() === "") {
+    throw new Error(`Include "${label}" has an empty localKey.`);
+  }
+  if (include.cardinality === "one") {
+    if (include.sortBy !== void 0) {
+      throw new Error(
+        `Include "${label}" has cardinality "one", which resolves to a single row \u2014 sortBy is meaningless there.`
+      );
+    }
+    if (include.limit !== void 0) {
+      throw new Error(
+        `Include "${label}" has cardinality "one", which resolves to a single row \u2014 limit is meaningless there.`
+      );
+    }
+  }
+  if (include.limit !== void 0 && (!Number.isFinite(include.limit) || include.limit < 0)) {
+    throw new Error(`Include "${label}" has an invalid limit (${include.limit}).`);
+  }
+  for (const sortKey of include.sortBy ?? []) {
+    if (sortKey.special === "textScore") {
+      throw new Error(
+        `Include "${label}" sorts by textScore, but includes have no text clause to score against.`
+      );
+    }
+  }
+}
+function hydrateMockIncludes(params) {
+  const { includes, parents, parentDocuments, resolveDatabase, depth, slotPath } = params;
+  for (const [slot, include] of Object.entries(includes)) {
+    const label = slotPath ? `${slotPath}.${slot}` : slot;
+    validateMockInclude(slot, label, include, depth);
+    const filter = mockIncludeFilter(include);
+    const plan = planMockInclude(label, include, filter);
+    const childDatabaseId = include.databaseId ?? params.parentDatabaseId;
+    let childDocuments = parentDocuments;
+    if (include.databaseId !== void 0) {
+      const resolved = resolveDatabase?.(include.databaseId);
+      if (!resolved) {
+        throw new Error(
+          `Include "${label}" refers to the database "${include.databaseId}", which this app is not mapped to.`
+        );
+      }
+      childDocuments = resolved;
+    }
+    if (parents.length === 0) {
+      continue;
+    }
+    const parentsByKey = /* @__PURE__ */ new Map();
+    for (const parent of parents) {
+      const parentValue = plan.parent.kind === "docId" ? parent.docId : getFieldValue2(parent.data, plan.parent.path);
+      for (const key of mockJoinValues(parentValue)) {
+        const bucket = parentsByKey.get(key);
+        if (bucket) {
+          bucket.push(parent);
+        } else {
+          parentsByKey.set(key, [parent]);
+        }
+      }
+    }
+    const sortBy = include.sortBy ?? [];
+    const childrenByKey = /* @__PURE__ */ new Map();
+    if (parentsByKey.size > 0) {
+      for (const document of childDocuments.values()) {
+        if (document.isDeleted || document.inaccessible) {
+          continue;
+        }
+        const childValue = plan.child.kind === "docId" ? document.id : getFieldValue2(document.data, plan.child.path);
+        const matchedKeys = mockJoinValues(childValue).filter((key) => parentsByKey.has(key));
+        if (matchedKeys.length === 0) {
+          continue;
+        }
+        const context = {
+          doc: document.data,
+          values: {},
+          origin: childDatabaseId,
+          docId: document.id,
+          variables: {}
+        };
+        if (plan.residualFilter && !mockExpressionToBoolean(evaluateExpression2(plan.residualFilter, context))) {
+          continue;
+        }
+        const candidate = {
+          docId: document.id,
+          data: document.data,
+          row: {
+            docId: document.id,
+            fields: projectMockFields(document.data, include.fields),
+            lastModified: mockLastModified(document)
+          },
+          sortValues: sortBy.map(
+            (key) => key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document.data, key.field ?? "")
+          )
+        };
+        for (const key of matchedKeys) {
+          const bucket = childrenByKey.get(key);
+          if (bucket) {
+            bucket.push(candidate);
+          } else {
+            childrenByKey.set(key, [candidate]);
+          }
+        }
+      }
+    }
+    const childParents = attachMockIncludeSlot(
+      slot,
+      label,
+      include,
+      plan,
+      parents,
+      childrenByKey,
+      sortBy
+    );
+    if (include.include && childParents.length > 0) {
+      hydrateMockIncludes({
+        includes: include.include,
+        parents: childParents,
+        parentDatabaseId: childDatabaseId,
+        parentDocuments: childDocuments,
+        resolveDatabase,
+        depth: depth + 1,
+        slotPath: label
+      });
+    }
+  }
+}
+function attachMockIncludeSlot(slot, label, include, plan, parents, childrenByKey, sortBy) {
+  const limit = include.limit ?? MOCK_DEFAULT_INCLUDE_LIMIT;
+  const nextParents = [];
+  for (const parent of parents) {
+    const parentValue = plan.parent.kind === "docId" ? parent.docId : getFieldValue2(parent.data, plan.parent.path);
+    const seen = /* @__PURE__ */ new Set();
+    const matches = [];
+    for (const key of mockJoinValues(parentValue)) {
+      for (const candidate of childrenByKey.get(key) ?? []) {
+        if (seen.has(candidate.docId)) {
+          continue;
+        }
+        seen.add(candidate.docId);
+        matches.push(candidate);
+      }
+    }
+    const slots = parent.row.includes ??= {};
+    if (include.cardinality === "one") {
+      if (matches.length > 1) {
+        const sample = matches.slice(0, 3).map((match2) => match2.docId).join(", ");
+        throw new Error(
+          `Include "${label}" has cardinality "one", but document "${parent.docId}" matched ${matches.length} related documents (${sample}${matches.length > 3 ? ", \u2026" : ""}). Use cardinality "many" if several matches are expected.`
+        );
+      }
+      if (matches.length === 0) {
+        slots[slot] = null;
+        continue;
+      }
+      const match = matches[0];
+      const row = structuredClone(match.row);
+      slots[slot] = row;
+      nextParents.push({ row, docId: match.docId, data: match.data });
+      continue;
+    }
+    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.docId.localeCompare(right.docId);
+    });
+    const rows = [];
+    for (const candidate of matches.slice(0, limit)) {
+      const row = structuredClone(candidate.row);
+      rows.push(row);
+      nextParents.push({ row, docId: candidate.docId, data: candidate.data });
+    }
+    slots[slot] = rows;
+  }
+  return nextParents;
+}
 function createDefaultViewNavigator() {
   const definition = {
     title: "Mock View",
@@ -1227,7 +1540,7 @@ async function mockSha256Hex(value) {
   const digest = await subtle.digest("SHA-256", new TextEncoder().encode(value));
   return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function createDatabaseHandle(definition) {
+function createDatabaseHandle(definition, peers) {
   let createCounter = 0;
   let changeCounter = 0;
   const defaultViewFactory = async () => createDefaultViewNavigator();
@@ -1247,12 +1560,13 @@ function createDatabaseHandle(definition) {
     });
   }
   const liveQuerySubscriptions = /* @__PURE__ */ new Set();
-  const notifyLiveQueries = () => {
+  const refreshLiveQueries = () => {
     for (const subscription of liveQuerySubscriptions) {
       const result = runMockDocumentQuery(
         storedDocuments,
         definition.info.id,
-        subscription.query
+        subscription.query,
+        peers.getDocuments
       );
       const resultJson = JSON.stringify(result);
       if (resultJson !== subscription.lastResultJson) {
@@ -1261,6 +1575,9 @@ function createDatabaseHandle(definition) {
       }
     }
   };
+  const notifyLiveQueries = () => {
+    peers.refreshAllLiveQueries();
+  };
   function mockEncryptForMap(names) {
     const encryptFor = {};
     for (const name of names) {
@@ -1301,13 +1618,19 @@ function createDatabaseHandle(definition) {
   }
   const defaultDocuments = {
     async query(query) {
-      return runMockDocumentQuery(storedDocuments, definition.info.id, query);
+      return runMockDocumentQuery(
+        storedDocuments,
+        definition.info.id,
+        query,
+        peers.getDocuments
+      );
     },
     async liveQuery(query, onResult) {
       const initial = runMockDocumentQuery(
         storedDocuments,
         definition.info.id,
-        query
+        query,
+        peers.getDocuments
       );
       const subscription = {
         query,
@@ -1324,7 +1647,8 @@ function createDatabaseHandle(definition) {
           const result = runMockDocumentQuery(
             storedDocuments,
             definition.info.id,
-            query
+            query,
+            peers.getDocuments
           );
           subscription.lastResultJson = JSON.stringify(result);
           onResult(result);
@@ -1842,7 +2166,9 @@ function createDatabaseHandle(definition) {
       docId: document.id,
       data: structuredClone(document.data),
       createdAt: document.updatedAt ?? null
-    }))
+    })),
+    documents: storedDocuments,
+    notifyLiveQueries: refreshLiveQueries
   };
 }
 function createMockSessionState(options = {}) {
@@ -1854,6 +2180,16 @@ function createMockSessionState(options = {}) {
   const beforeCloseListeners = /* @__PURE__ */ new Set();
   const databaseHandles = /* @__PURE__ */ new Map();
   const databaseViewDocumentLists = /* @__PURE__ */ new Map();
+  const databaseDocumentStores = /* @__PURE__ */ new Map();
+  const databaseLiveQueryRefreshers = /* @__PURE__ */ new Map();
+  const databasePeers = {
+    getDocuments: (databaseId) => databaseDocumentStores.get(databaseId),
+    refreshAllLiveQueries: () => {
+      for (const refresh of databaseLiveQueryRefreshers.values()) {
+        refresh();
+      }
+    }
+  };
   const databaseViewApis = /* @__PURE__ */ new Map();
   const sessionViews = /* @__PURE__ */ new Map();
   let activeMenuResolve = null;
@@ -1861,6 +2197,7 @@ function createMockSessionState(options = {}) {
   let dragProfile = null;
   let databaseInfos = [];
   const openSealedChannels = /* @__PURE__ */ new Map();
+  const proposedApps = [];
   const appStorage = new Map(Object.entries(options.storage ?? {}));
   const requireCapability = (databaseId, capability) => {
     const info = databaseInfos.find((entry) => entry.id === databaseId);
@@ -1927,14 +2264,18 @@ function createMockSessionState(options = {}) {
     databaseHandles.clear();
     databaseViewDocumentLists.clear();
     databaseViewApis.clear();
+    databaseDocumentStores.clear();
+    databaseLiveQueryRefreshers.clear();
     databaseInfos = definitions.map((definition) => ({
       ...definition.info,
       capabilities: [...definition.info.capabilities]
     }));
     for (const definition of definitions) {
-      const created = createDatabaseHandle(definition);
+      const created = createDatabaseHandle(definition, databasePeers);
       databaseHandles.set(definition.info.id, created.handle);
       databaseViewDocumentLists.set(definition.info.id, created.listViewDocuments);
+      databaseDocumentStores.set(definition.info.id, created.documents);
+      databaseLiveQueryRefreshers.set(definition.info.id, created.notifyLiveQueries);
       databaseViewApis.set(definition.info.id, {
         async create(input) {
           const documents = input.databaseIds.flatMap((databaseId) => {
@@ -1996,6 +2337,11 @@ function createMockSessionState(options = {}) {
     async getLicensedProducts() {
       return [...launchContext.licensedProducts ?? []];
     },
+    async proposeApp(input) {
+      proposedApps.push({ ...input });
+      const outcome = options.proposeApp?.(input);
+      return outcome ?? { ok: false, reason: "declined" };
+    },
     async listDatabases() {
       return databaseInfos.map((entry) => ({
         ...entry,
@@ -2153,6 +2499,7 @@ function createMockSessionState(options = {}) {
     getLicensedProducts() {
       return [...launchContext.licensedProducts ?? []];
     },
+    proposedApps,
     createViewNavigator: session.createViewNavigator,
     openViewNavigator: session.openViewNavigator,
     bridge,
@@ -2197,6 +2544,7 @@ function createMockMindooDBAppSession(options = {}) {
     getLaunchContext: state.getLaunchContext,
     setLaunchContext: state.setLaunchContext,
     getLicensedProducts: state.getLicensedProducts,
+    proposedApps: state.proposedApps,
     listDatabases: state.listDatabaseInfos,
     setDatabases: state.setDatabases,
     emitThemeChange: state.emitThemeChange,
@@ -2421,6 +2769,8 @@ function createFakeBridgeHost(options = {}) {
       case "sealedChannel.close":
         await state.session.closeSealedChannel(String(params.channelId));
         return { ok: true };
+      case "apps.propose":
+        return await state.session.proposeApp(params);
       case "documents.list":
         return await state.getDatabase(String(params.databaseId)).documents.list(
           params.query
@@ -2915,6 +3265,9 @@ function createFakeBridgeHost(options = {}) {
     get requests() {
       return requests;
     },
+    get proposedApps() {
+      return state.proposedApps;
+    },
     install,
     dispose() {
       restoreWindow();