korajs 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/index.cjs

@@ -212,7 +212,7 @@ function detectAdapterType() {
   }
   return "better-sqlite3";
 }
-async function createAdapter(type, dbName, workerUrl, emitter, workerResponseTimeoutMs, sharedWorkerUrl) {
+async function createAdapter(type, dbName, workerUrl, emitter, workerResponseTimeoutMs, sharedWorkerUrl, suppressNonPersistentDiagnostic = false) {
   switch (type) {
     case "tauri-sqlite": {
       const { TauriSqliteAdapter } = await importOptionalPeer("@korajs/tauri");
@@ -233,7 +233,8 @@ async function createAdapter(type, dbName, workerUrl, emitter, workerResponseTim
         workerUrl,
         sharedWorkerUrl,
         workerResponseTimeoutMs,
-        emitter
+        emitter,
+        emitNonPersistentDiagnostic: !suppressNonPersistentDiagnostic
       });
     }
     case "indexeddb": {
@@ -1055,6 +1056,51 @@ function createSyncTransport(sync) {
   return new import_sync.WebSocketTransport();
 }
 
+// src/local-operation-bus.ts
+var MESSAGE_TYPE = "kora-local-operation";
+function wireLocalOperationBus(dbName, store, emitter) {
+  if (typeof BroadcastChannel === "undefined") {
+    return () => {
+    };
+  }
+  const originId = createOriginId();
+  const channel = new BroadcastChannel(`kora-local-ops-${dbName}`);
+  const onMessage = (event) => {
+    const message = event.data;
+    if (message?.type !== MESSAGE_TYPE || message.originId === originId || !isOperationLike(message.operation)) {
+      return;
+    }
+    store.notifyExternalOperation(message.operation);
+  };
+  channel.addEventListener("message", onMessage);
+  const unsubscribe = emitter.on("operation:created", (event) => {
+    const message = {
+      type: MESSAGE_TYPE,
+      originId,
+      operation: event.operation
+    };
+    channel.postMessage(message);
+  });
+  return () => {
+    unsubscribe();
+    channel.removeEventListener("message", onMessage);
+    channel.close();
+  };
+}
+function createOriginId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function isOperationLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.id === "string" && typeof candidate.collection === "string" && typeof candidate.recordId === "string" && typeof candidate.nodeId === "string" && typeof candidate.sequenceNumber === "number";
+}
+
 // src/merge-aware-sync-store.ts
 var MergeAwareSyncStore = class {
   constructor(store, mergeEngine, emitter, options) {
@@ -1279,22 +1325,23 @@ function createSyncQuerySubscriptionHook(getSyncEngine) {
 async function initializeApp(config, emitter, mergeEngine) {
   const adapterType = config.store?.adapter ?? detectAdapterType();
   const dbName = config.store?.name ?? "kora-db";
-  const adapter = await createAdapter(
+  let adapter = await createAdapter(
     adapterType,
     dbName,
     config.store?.workerUrl,
     emitter,
     config.store?.workerResponseTimeoutMs,
-    config.store?.sharedWorkerUrl
+    config.store?.sharedWorkerUrl,
+    adapterType === "sqlite-wasm"
   );
   const authBinding = config.sync?.authClient ?? null;
   const authNodeId = authBinding?.resolveNodeId ? await authBinding.resolveNodeId() : void 0;
   let syncEngine = null;
   const encryptionKey = config.sync?.encryption?.key;
   const secretKeyProvider = encryptionKey ? typeof encryptionKey === "string" ? () => encryptionKey : () => encryptionKey() : void 0;
-  const store = new import_store8.Store({
+  const buildStore = (storeAdapter) => new import_store8.Store({
     schema: config.schema,
-    adapter,
+    adapter: storeAdapter,
     emitter,
     dbName,
     nodeId: authNodeId,
@@ -1302,7 +1349,44 @@ async function initializeApp(config, emitter, mergeEngine) {
     ...secretKeyProvider ? { secretKeyProvider } : {},
     ...config.sync ? { onQuerySubscribed: createSyncQuerySubscriptionHook(() => syncEngine) } : {}
   });
+  let store = buildStore(adapter);
   await store.open();
+  if (adapterType === "sqlite-wasm" && adapter.getStorageOpenState?.()?.persistent === false) {
+    const fallbackReason = adapter.getStorageOpenState()?.fallbackReason ?? "unsupported";
+    await store.close();
+    try {
+      adapter = await createAdapter(
+        "indexeddb",
+        dbName,
+        config.store?.workerUrl,
+        emitter,
+        config.store?.workerResponseTimeoutMs
+      );
+      store = buildStore(adapter);
+      await store.open();
+      emitter.emit({
+        type: "store:storage-fallback",
+        dbName,
+        from: "opfs",
+        to: "indexeddb",
+        reason: fallbackReason,
+        message: `OPFS persistence is unavailable (${fallbackReason}) for database "${dbName}"; Kora is using durable IndexedDB instead.`
+      });
+    } catch {
+      adapter = await createAdapter(
+        "sqlite-wasm",
+        dbName,
+        config.store?.workerUrl,
+        emitter,
+        config.store?.workerResponseTimeoutMs,
+        config.store?.sharedWorkerUrl,
+        true
+      );
+      store = buildStore(adapter);
+      await store.open();
+      emitOpfsUnavailable(emitter, dbName, fallbackReason);
+    }
+  }
   let recordConflict;
   const applyPipeline = new ApplyPipeline({
     store,
@@ -1312,6 +1396,7 @@ async function initializeApp(config, emitter, mergeEngine) {
   });
   store.setLocalMutationHandler(applyPipeline);
   const unsubscribeAudit = wireAuditPersistence(store, emitter);
+  const unsubscribeLocalOperations = wireLocalOperationBus(dbName, store, emitter);
   const blobStore = await resolveBlobStore(config.blob, dbName);
   let blobChunkProvider = null;
   let unsubscribeSync = null;
@@ -1366,11 +1451,20 @@ async function initializeApp(config, emitter, mergeEngine) {
     syncEngine,
     unsubscribeSync,
     unsubscribeAudit,
+    unsubscribeLocalOperations,
     authBinding,
     blobStore,
     blobChunkProvider
   };
 }
+function emitOpfsUnavailable(emitter, dbName, reason) {
+  emitter.emit({
+    type: "store:opfs-unavailable",
+    dbName,
+    reason,
+    message: `OPFS persistence is unavailable (${reason}) for database "${dbName}", and IndexedDB fallback could not open; the store is running in memory and data will not survive a reload.`
+  });
+}
 
 // src/sequences-accessor.ts
 function createSequencesAccessor(ready, getStore) {
@@ -1831,6 +1925,7 @@ function createApp(config) {
   let blobApi = null;
   let unsubscribeSync = null;
   let unsubscribeAudit = null;
+  let unsubscribeLocalOperations = null;
   const syncState = {
     syncEngine: null,
     syncStatusBridge: null,
@@ -1847,6 +1942,7 @@ function createApp(config) {
     store = init.store;
     unsubscribeSync = init.unsubscribeSync;
     unsubscribeAudit = init.unsubscribeAudit;
+    unsubscribeLocalOperations = init.unsubscribeLocalOperations;
     blobApi = createBlobApi(
       init.blobStore,
       init.blobChunkProvider,
@@ -1929,6 +2025,10 @@ function createApp(config) {
         unsubscribeAudit();
         unsubscribeAudit = null;
       }
+      if (unsubscribeLocalOperations) {
+        unsubscribeLocalOperations();
+        unsubscribeLocalOperations = null;
+      }
       if (syncState.syncEngine) {
         await syncState.syncEngine.stop();
         syncState.syncEngine = null;