mindoodb-app-sdk 0.0.19 → 0.0.26

package/dist/index.js

@@ -80,6 +80,9 @@ function expandAbbreviatedName(value) {
   ].join("/");
 }
 
+// src/client/createMindooDBAppBridge.ts
+import { parseMindooDBFormulaBooleanExpression } from "mindoodb-view-language";
+
 // src/client/portRpcClient.ts
 var PROTOCOL = "mindoodb-app-bridge";
 function normalizeRpcValue(value, seen = /* @__PURE__ */ new WeakMap()) {
@@ -232,6 +235,9 @@ var PortRpcClient = class {
 // src/client/createMindooDBAppBridge.ts
 var PROTOCOL2 = "mindoodb-app-bridge";
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+function isMethodNotFoundError(error) {
+  return error instanceof Error && error.name === "method-not-found";
+}
 function toTransferableArrayBuffer(chunk) {
   return chunk.buffer.slice(
     chunk.byteOffset,
@@ -247,6 +253,24 @@ function isStreamAckFor(streamId, message) {
 function isStreamErrorFor(streamId, message) {
   return message.kind === "stream-error" && message.streamId === streamId;
 }
+function isQueryResultFor(subscriptionId, message) {
+  return message.kind === "query-result" && message.subscriptionId === subscriptionId;
+}
+function isViewChangedFor(navigatorId, message) {
+  return message.kind === "view-changed" && message.navigatorId === navigatorId;
+}
+function normalizeDocumentQuery(query) {
+  if (!query) {
+    return {};
+  }
+  const { filter, ...rest } = query;
+  return {
+    ...rest,
+    ...filter !== void 0 ? {
+      filter: typeof filter === "string" ? parseMindooDBFormulaBooleanExpression(filter) : filter
+    } : {}
+  };
+}
 function isThemeChangedMessage(message) {
   return message.kind === "theme-changed";
 }
@@ -256,6 +280,9 @@ function isViewportChangedMessage(message) {
 function isUiPreferencesChangedMessage(message) {
   return message.kind === "ui-preferences-changed";
 }
+function isLocaleChangedMessage(message) {
+  return message.kind === "locale-changed";
+}
 function toStreamError(message) {
   const error = new Error(message.error.message);
   error.name = message.error.code || "MindooDBAppBridgeStreamError";
@@ -378,6 +405,13 @@ var MindooDBAppViewNavigatorImpl = class {
     this.viewCursor = result.viewCursor;
     return this.viewCursor;
   }
+  onDidUpdate(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isViewChangedFor(this.navigatorId, message)) {
+        listener(message.stats);
+      }
+    });
+  }
   async getCurrentEntry() {
     return await this.call("viewNavigators.current.get");
   }
@@ -719,6 +753,44 @@ var MindooDBAppDatabaseImpl = class {
         databaseId: this.databaseId,
         query: query ?? {}
       }),
+      query: async (query) => await this.rpc.call("documents.query", {
+        databaseId: this.databaseId,
+        query: normalizeDocumentQuery(query)
+      }),
+      liveQuery: async (query, onResult) => {
+        const { subscriptionId, result } = await this.rpc.call("documents.liveQuery.subscribe", {
+          databaseId: this.databaseId,
+          query: normalizeDocumentQuery(query)
+        });
+        let disposed = false;
+        const unsubscribe = this.rpc.addMessageListener((message) => {
+          if (!disposed && isQueryResultFor(subscriptionId, message)) {
+            onResult(message.result);
+          }
+        });
+        onResult(result);
+        const subscription = {
+          refresh: async () => {
+            if (disposed) {
+              return;
+            }
+            await this.rpc.call("documents.liveQuery.refresh", {
+              subscriptionId
+            });
+          },
+          dispose: async () => {
+            if (disposed) {
+              return;
+            }
+            disposed = true;
+            unsubscribe();
+            await this.rpc.call("documents.liveQuery.unsubscribe", {
+              subscriptionId
+            });
+          }
+        };
+        return subscription;
+      },
       getHeadCursor: async () => await this.rpc.call("documents.getHeadCursor", {
         databaseId: this.databaseId
       }),
@@ -732,10 +804,44 @@ var MindooDBAppDatabaseImpl = class {
         path,
         revisionId: options?.revisionId
       }),
+      getAutomergeSnapshot: async (docId, options) => await this.rpc.call("documents.automerge.getSnapshot", {
+        databaseId: this.databaseId,
+        docId,
+        revisionId: options?.revisionId
+      }),
+      applyAutomergeChanges: async (docId, patch) => await this.rpc.call("documents.automerge.applyChanges", {
+        databaseId: this.databaseId,
+        docId,
+        patch
+      }),
       create: async (input) => await this.rpc.call("documents.create", {
         databaseId: this.databaseId,
         input
       }),
+      createMany: async (inputs) => {
+        if (inputs.length === 0) {
+          return { ids: [] };
+        }
+        try {
+          return await this.rpc.call("documents.createMany", {
+            databaseId: this.databaseId,
+            inputs
+          });
+        } catch (error) {
+          if (!isMethodNotFoundError(error)) {
+            throw error;
+          }
+          const ids = [];
+          for (const input of inputs) {
+            const document = await this.rpc.call("documents.create", {
+              databaseId: this.databaseId,
+              input
+            });
+            ids.push(document.id);
+          }
+          return { ids };
+        }
+      },
       update: async (docId, patch) => await this.rpc.call("documents.update", {
         databaseId: this.databaseId,
         docId,
@@ -745,10 +851,51 @@ var MindooDBAppDatabaseImpl = class {
         databaseId: this.databaseId,
         docId
       }),
+      deleteMany: async (docIds) => {
+        if (docIds.length === 0) {
+          return { ok: true };
+        }
+        try {
+          return await this.rpc.call("documents.deleteMany", {
+            databaseId: this.databaseId,
+            docIds
+          });
+        } catch (error) {
+          if (!isMethodNotFoundError(error)) {
+            throw error;
+          }
+          for (const docId of docIds) {
+            await this.rpc.call("documents.delete", {
+              databaseId: this.databaseId,
+              docId
+            });
+          }
+          return { ok: true };
+        }
+      },
       undelete: async (docId) => await this.rpc.call("documents.undelete", {
         databaseId: this.databaseId,
         docId
       }),
+      canCreate: async (input) => await this.rpc.call("documents.canCreate", {
+        databaseId: this.databaseId,
+        input: input ?? {}
+      }),
+      canChange: async (docId) => await this.rpc.call("documents.canChange", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      canDelete: async (docId) => await this.rpc.call("documents.canDelete", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      canUndelete: async (docId) => await this.rpc.call("documents.canUndelete", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      getDefaultCreateKeyId: async () => await this.rpc.call("documents.getDefaultCreateKeyId", {
+        databaseId: this.databaseId
+      }),
       listHistory: async (docId) => await this.rpc.call("documents.history.list", {
         databaseId: this.databaseId,
         docId
@@ -889,6 +1036,36 @@ var MindooDBAppDatabaseImpl = class {
       databaseId: this.databaseId
     });
   }
+  /** Reads the full-text configuration from the synced `dbsetup` document. */
+  async getFulltextSetup() {
+    const result = await this.rpc.call(
+      "database.getFulltextSetup",
+      { databaseId: this.databaseId }
+    );
+    return result.config;
+  }
+  /** Writes (or removes, with `null`) the full-text configuration. */
+  async setFulltextSetup(config) {
+    await this.rpc.call("database.setFulltextSetup", {
+      databaseId: this.databaseId,
+      config
+    });
+  }
+  /** Reads the attachment extraction configuration from the synced `dbsetup` document. */
+  async getExtractionSetup() {
+    const result = await this.rpc.call(
+      "database.getExtractionSetup",
+      { databaseId: this.databaseId }
+    );
+    return result.config;
+  }
+  /** Writes (or removes, with `null`) the attachment extraction configuration. */
+  async setExtractionSetup(config) {
+    await this.rpc.call("database.setExtractionSetup", {
+      databaseId: this.databaseId,
+      config
+    });
+  }
 };
 var MindooDBAppSessionImpl = class {
   constructor(rpc) {
@@ -906,6 +1083,10 @@ var MindooDBAppSessionImpl = class {
   async getLaunchContext() {
     return await this.rpc.call("session.getLaunchContext", {});
   }
+  /** Returns the product names currently licensed in the Haven host. */
+  async getLicensedProducts() {
+    return await this.rpc.call("session.getLicensedProducts", {});
+  }
   /** Lists the databases that the host has made available for this app session. */
   async listDatabases() {
     return await this.rpc.call("session.listDatabases", {});
@@ -973,6 +1154,14 @@ var MindooDBAppSessionImpl = class {
       }
     });
   }
+  /** Subscribe to host-pushed UI language changes. */
+  onLocaleChange(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isLocaleChangedMessage(message)) {
+        listener(message.locale);
+      }
+    });
+  }
   /** Disconnects from the host and always disposes the underlying port client. */
   async disconnect() {
     try {
@@ -997,11 +1186,18 @@ function createMindooDBAppBridge() {
 var MindooDBRichTextHandle = class {
   constructor(options) {
     this.options = options;
-    this.spansInternal = cloneSpans(options.spans ?? []);
+    const initialSpans = cloneSpans(options.spans ?? []);
+    this.spansInternal = initialSpans;
+    this.baseMaterializedText = readMaterializedRichTextText(
+      options.document.data,
+      options.path,
+      initialSpans
+    );
     this.heads = options.document.heads ? [...options.document.heads] : [];
   }
   options;
   spansInternal;
+  baseMaterializedText;
   heads;
   dirtyInternal = false;
   listeners = /* @__PURE__ */ new Set();
@@ -1041,6 +1237,7 @@ var MindooDBRichTextHandle = class {
   reconcile(document, snapshot) {
     const previous = JSON.stringify(this.spansInternal);
     this.spansInternal = cloneSpans(snapshot.spans);
+    this.baseMaterializedText = spansToPlainText(snapshot.spans);
     this.heads = snapshot.heads ?? document.heads ?? [];
     this.dirtyInternal = false;
     const changed = JSON.stringify(this.spansInternal) !== previous;
@@ -1081,14 +1278,16 @@ var MindooDBRichTextHandle = class {
         reconciled: false
       };
     }
-    const localSpansAtFlush = JSON.stringify(this.spansInternal);
-    const document = await this.options.database.documents.update(
+    const localSpansAtFlush = cloneSpans(this.spansInternal);
+    const localTextAtFlush = spansToPlainText(localSpansAtFlush);
+    const textChanged = localTextAtFlush !== this.baseMaterializedText;
+    const document = textChanged ? await this.flushTextSteps(localTextAtFlush) : await this.options.database.documents.update(
       this.options.document.id,
       {
         richText: [{
           path: this.options.path,
           baseHeads: this.heads,
-          spans: cloneSpans(this.spansInternal),
+          spans: localSpansAtFlush,
           updateSpansConfig
         }]
       }
@@ -1097,8 +1296,9 @@ var MindooDBRichTextHandle = class {
       this.options.document.id,
       this.options.path
     );
-    const reconciled = JSON.stringify(snapshot.spans) !== localSpansAtFlush;
+    const reconciled = JSON.stringify(snapshot.spans) !== JSON.stringify(localSpansAtFlush);
     this.spansInternal = cloneSpans(snapshot.spans);
+    this.baseMaterializedText = spansToPlainText(snapshot.spans);
     this.heads = snapshot.heads ?? document.heads ?? [];
     this.dirtyInternal = false;
     if (reconciled) {
@@ -1110,6 +1310,21 @@ var MindooDBRichTextHandle = class {
       reconciled
     };
   }
+  async flushTextSteps(localTextAtFlush) {
+    const edit = computeSingleSplice(this.baseMaterializedText, localTextAtFlush);
+    return this.options.database.documents.update(this.options.document.id, {
+      richTextSteps: [{
+        path: this.options.path,
+        baseHeads: this.heads,
+        steps: [{
+          type: "splice",
+          index: edit.index,
+          deleteCount: edit.deleteCount,
+          insert: edit.insert ?? ""
+        }]
+      }]
+    });
+  }
   emitChange() {
     const snapshot = {
       path: [...this.options.path],
@@ -1127,6 +1342,44 @@ function createMindooDBRichTextHandle(options) {
 function cloneSpans(spans) {
   return structuredClone(spans);
 }
+function spansToPlainText(spans) {
+  return spans.filter((span) => span.type === "text").map((span) => span.type === "text" ? span.value : "").join("");
+}
+function readMaterializedRichTextText(data, path, fallbackSpans) {
+  let value = data;
+  for (const segment of path) {
+    if (value == null || typeof value !== "object") {
+      return spansToPlainText(fallbackSpans);
+    }
+    value = value[segment];
+  }
+  if (typeof value === "string") {
+    return value.replace(/\uFFFC/g, "");
+  }
+  if (Array.isArray(value)) {
+    return spansToPlainText(value);
+  }
+  return spansToPlainText(fallbackSpans);
+}
+function computeSingleSplice(previous, next) {
+  let prefixLength = 0;
+  const maxPrefix = Math.min(previous.length, next.length);
+  while (prefixLength < maxPrefix && previous[prefixLength] === next[prefixLength]) {
+    prefixLength += 1;
+  }
+  let suffixLength = 0;
+  const previousRemaining = previous.length - prefixLength;
+  const nextRemaining = next.length - prefixLength;
+  const maxSuffix = Math.min(previousRemaining, nextRemaining);
+  while (suffixLength < maxSuffix && previous[previous.length - 1 - suffixLength] === next[next.length - 1 - suffixLength]) {
+    suffixLength += 1;
+  }
+  return {
+    index: prefixLength,
+    deleteCount: previous.length - prefixLength - suffixLength,
+    insert: next.slice(prefixLength, next.length - suffixLength)
+  };
+}
 
 // src/textBuffer.ts
 var MindooDBTextBuffer = class {
@@ -1181,7 +1434,7 @@ var MindooDBTextBuffer = class {
     if (nextValue === this.valueInternal) {
       return;
     }
-    const edit = computeSingleSplice(this.valueInternal, nextValue);
+    const edit = computeSingleSplice2(this.valueInternal, nextValue);
     this.splice(edit.index, edit.deleteCount, edit.insert ?? "");
   }
   /**
@@ -1248,7 +1501,7 @@ function readTextAtPath(data, path) {
   }
   return typeof value === "string" ? value : "";
 }
-function computeSingleSplice(previous, next) {
+function computeSingleSplice2(previous, next) {
   let prefixLength = 0;
   const maxPrefix = Math.min(previous.length, next.length);
   while (prefixLength < maxPrefix && previous[prefixLength] === next[prefixLength]) {
@@ -1269,12 +1522,20 @@ function computeSingleSplice(previous, next) {
 }
 
 // src/viewLanguage.ts
+import { parseMindooDBFormulaBooleanExpression as parseMindooDBFormulaBooleanExpression2 } from "mindoodb-view-language";
 import {
   createViewLanguage,
   getMindooDBViewLanguageHelper,
   mindooDBViewLanguageHelpers,
   mindooDBViewLanguageHelpersByName
 } from "mindoodb-view-language";
+async function queryDocuments(db, filter, sortBy, options) {
+  if (!db.query) {
+    throw new Error("This MindooDB instance does not support ad-hoc queries.");
+  }
+  const expression = typeof filter === "string" ? parseMindooDBFormulaBooleanExpression2(filter) : filter;
+  return db.query({ filter: expression, sortBy }, options);
+}
 export {
   MindooDBRichTextHandle,
   MindooDBTextBuffer,
@@ -1284,5 +1545,6 @@ export {
   createMindooDBRichTextHandle,
   createMindooDBTextBuffer,
   createViewLanguage,
-  expandAbbreviatedName
+  expandAbbreviatedName,
+  queryDocuments
 };

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { ae as MindooDBAppLaunchContext, Z as MindooDBAppDatabaseInfo, _ as MindooDBAppDocumentApi, Y as MindooDBAppCreateViewNavigatorInput, aT as MindooDBAppViewNavigator, aV as MindooDBAppViewNavigatorOpenOptions, f as MindooDBAppAttachmentApi, a as MindooDBAppBridge, aH as MindooDBAppSession, s as MindooDBAppBridgeRpcRequest, a8 as MindooDBAppHostTheme, a_ as MindooDBAppViewport, aN as MindooDBAppUiPreferences, p as MindooDBAppBridgePortMessage } from '../types-nFt-aryL.js';
+import { au as MindooDBAppLaunchContext, a7 as MindooDBAppDatabaseInfo, a8 as MindooDBAppDocumentApi, a6 as MindooDBAppCreateViewNavigatorInput, bh as MindooDBAppViewNavigator, bj as MindooDBAppViewNavigatorOpenOptions, h as MindooDBAppAttachmentApi, ai as MindooDBAppFulltextSetup, ah as MindooDBAppExtractionSetup, a as MindooDBAppBridge, b5 as MindooDBAppSession, B as MindooDBAppBridgeRpcRequest, al as MindooDBAppHostTheme, bp as MindooDBAppViewport, bb as MindooDBAppUiPreferences, aK as MindooDBAppQueryResult, bo as MindooDBAppViewUpdateStats, x as MindooDBAppBridgePortMessage } from '../types-B6vEy1VC.js';
 import 'mindoodb-view-language';
 
 type MaybePromise<T> = T | Promise<T>;
@@ -14,6 +14,21 @@ type MockDatabaseMethods = {
 interface MockMindooDBAppDatabaseDefinition {
     info: MindooDBAppDatabaseInfo;
     methods?: MockDatabaseMethods;
+    /**
+     * Initial full-text configuration returned by `getFulltextSetup()`.
+     * `setFulltextSetup()` overwrites it for the lifetime of the handle.
+     * Note the mock evaluates `text` query clauses regardless of this
+     * config (see TESTING.md) — it exists so apps can test their setup/
+     * bootstrap logic.
+     */
+    fulltextSetup?: MindooDBAppFulltextSetup | null;
+    /**
+     * Initial extraction configuration returned by `getExtractionSetup()`.
+     * `setExtractionSetup()` overwrites it for the lifetime of the handle.
+     * The mock runs no extraction service — this exists so apps can test
+     * their setup/bootstrap logic.
+     */
+    extractionSetup?: MindooDBAppExtractionSetup | null;
 }
 interface CreateMockMindooDBAppSessionOptions {
     launchContext?: Partial<MindooDBAppLaunchContext>;
@@ -25,11 +40,13 @@ interface MockMindooDBAppSessionController {
     session: MindooDBAppSession;
     getLaunchContext(): MindooDBAppLaunchContext;
     setLaunchContext(patch?: Partial<MindooDBAppLaunchContext>): MindooDBAppLaunchContext;
+    getLicensedProducts(): string[];
     listDatabases(): MindooDBAppDatabaseInfo[];
     setDatabases(definitions: MockMindooDBAppDatabaseDefinition[]): void;
     emitThemeChange(theme: MindooDBAppHostTheme): void;
     emitViewportChange(viewport: MindooDBAppViewport): void;
     emitUiPreferencesChange(uiPreferences: MindooDBAppUiPreferences): void;
+    emitLocaleChange(locale: string): void;
 }
 declare function createMockMindooDBAppSession(options?: CreateMockMindooDBAppSessionOptions): MockMindooDBAppSessionController;
 declare function createMockMindooDBAppBridge(options?: CreateMockMindooDBAppSessionOptions): MockMindooDBAppSessionController;
@@ -57,6 +74,11 @@ interface FakeBridgeHostController {
     emitThemeChange(theme: MindooDBAppHostTheme): void;
     emitViewportChange(viewport: MindooDBAppViewport): void;
     emitUiPreferencesChange(uiPreferences: MindooDBAppUiPreferences): void;
+    emitLocaleChange(locale: string): void;
+    /** Push a live-query result to connected apps, as the Haven host would. */
+    emitQueryResult(subscriptionId: string, result: MindooDBAppQueryResult): void;
+    /** Push a navigator view-changed event to connected apps. */
+    emitViewChanged(navigatorId: string, stats: MindooDBAppViewUpdateStats): void;
     postPortMessage(message: MindooDBAppBridgePortMessage, transfer?: Transferable[]): void;
     setRequestHandler(method: string, handler: FakeBridgeRequestHandler): void;
     clearRequestHandler(method: string): void;