@korajs/store 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/adapters/better-sqlite3.d.cts

@@ -1,5 +1,5 @@
 import { SchemaDefinition } from '@korajs/core';
-import { S as StorageAdapter, T as Transaction, M as MigrationPlan } from '../types-D1MzKVmk.cjs';
+import { S as StorageAdapter, T as Transaction, M as MigrationPlan } from '../types-BslDOTk0.cjs';
 
 /**
  * Storage adapter backed by better-sqlite3 for Node.js environments.

package/dist/adapters/better-sqlite3.d.ts

@@ -1,5 +1,5 @@
 import { SchemaDefinition } from '@korajs/core';
-import { S as StorageAdapter, T as Transaction, M as MigrationPlan } from '../types-D1MzKVmk.js';
+import { S as StorageAdapter, T as Transaction, M as MigrationPlan } from '../types-BslDOTk0.js';
 
 /**
  * Storage adapter backed by better-sqlite3 for Node.js environments.

package/dist/adapters/indexeddb.cjs

@@ -282,93 +282,15 @@ var IndexedDbPersistenceScheduler = class {
 var import_core2 = require("@korajs/core");
 init_errors();
 
-// src/multi-tab/shared-worker-bridge.ts
-init_errors();
-var SW_REQUEST = "kora-sw-request";
-var SW_RESPONSE = "kora-sw-response";
-var SharedWorkerClientBridge = class {
-  constructor(sharedWorker, dbName, workerUrl, timeoutMs = 3e4) {
-    this.dbName = dbName;
-    this.workerUrl = workerUrl;
-    this.timeoutMs = timeoutMs;
-    this.port = sharedWorker.port;
-    this.port.start();
-    this.port.addEventListener("message", (event) => {
-      const data = event.data;
-      if (data?.type !== SW_RESPONSE) {
-        return;
-      }
-      const entry = this.pending.get(data.requestId);
-      if (entry) {
-        this.pending.delete(data.requestId);
-        entry.resolve(data.response);
-      }
-    });
-  }
-  dbName;
-  workerUrl;
-  port;
-  pending = /* @__PURE__ */ new Map();
-  timeoutMs;
-  terminated = false;
-  async send(request) {
-    if (this.terminated) {
-      return {
-        id: request.id,
-        type: "error",
-        message: "SharedWorker bridge terminated",
-        code: "BRIDGE_TERMINATED"
-      };
-    }
-    const requestId = crypto.randomUUID();
-    const msg = {
-      type: SW_REQUEST,
-      requestId,
-      dbName: this.dbName,
-      workerUrl: this.workerUrl,
-      request
-    };
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(requestId);
-        reject(new WorkerTimeoutError(`shared-worker:${request.type}`, this.timeoutMs));
-      }, this.timeoutMs);
-      this.pending.set(requestId, {
-        resolve: (response) => {
-          clearTimeout(timer);
-          resolve(response);
-        },
-        reject: (error) => {
-          clearTimeout(timer);
-          reject(error);
-        }
-      });
-      this.port.postMessage(msg);
-    });
-  }
-  terminate() {
-    if (this.terminated) {
-      return;
-    }
-    this.terminated = true;
-    this.port.close();
-    for (const [, entry] of this.pending) {
-      entry.reject(new Error("SharedWorker bridge terminated"));
-    }
-    this.pending.clear();
-  }
-};
-
 // src/multi-tab/tab-storage.ts
 init_errors();
 var RPC_REQUEST = "kora-worker-request";
 var RPC_RESPONSE = "kora-worker-response";
+var CLIENT_LEAVE = "kora-client-leave";
 var LEADER_PING = "kora-leader-ping";
 var LEADER_PONG = "kora-leader-pong";
 var DEFAULT_LIVENESS_PROBE_MS = 2e3;
-function isSharedWorkerStorageSupported() {
-  return typeof globalThis !== "undefined" && typeof SharedWorker !== "undefined";
-}
+var DEFAULT_TRANSACTION_IDLE_TIMEOUT_MS = 1e4;
 function isMultiTabStorageSupported() {
   return typeof globalThis !== "undefined" && typeof BroadcastChannel !== "undefined" && typeof navigator !== "undefined" && typeof navigator.locks?.request === "function";
 }
@@ -430,10 +352,16 @@ function startLeaderRpcRelay(channelName, bridge) {
       channel.postMessage({ type: LEADER_PONG });
       return;
     }
+    if (data?.type === CLIENT_LEAVE) {
+      if (hasReclaimClient(bridge)) {
+        bridge.reclaimClient(data.clientId, "client-left");
+      }
+      return;
+    }
     if (data?.type !== RPC_REQUEST) {
       return;
     }
-    void bridge.send(data.request).then((response) => {
+    void bridge.send(data.request, data.clientId).then((response) => {
       const msg = {
         type: RPC_RESPONSE,
         requestId: data.requestId,
@@ -463,6 +391,10 @@ function startLeaderRpcRelay(channelName, bridge) {
 }
 var FollowerBroadcastBridge = class {
   channel;
+  clientId = createClientId();
+  onPageHide = () => {
+    this.leaveLeader();
+  };
   pending = /* @__PURE__ */ new Map();
   timeoutMs;
   livenessProbeMs;
@@ -471,6 +403,9 @@ var FollowerBroadcastBridge = class {
     this.timeoutMs = timeoutMs;
     this.livenessProbeMs = Math.min(livenessProbeMs, timeoutMs);
     this.channel = new BroadcastChannel(channelName);
+    if (typeof addEventListener === "function") {
+      addEventListener("pagehide", this.onPageHide);
+    }
     this.channel.addEventListener("message", (event) => {
       const data = event.data;
       if (data?.type !== RPC_RESPONSE) {
@@ -534,8 +469,13 @@ var FollowerBroadcastBridge = class {
         code: "BRIDGE_TERMINATED"
       };
     }
-    const requestId = crypto.randomUUID();
-    const msg = { type: RPC_REQUEST, requestId, request };
+    const requestId = createClientId();
+    const msg = {
+      type: RPC_REQUEST,
+      requestId,
+      clientId: this.clientId,
+      request
+    };
     return new Promise((resolve, reject) => {
       const settle = (fn) => {
         clearTimeout(timer);
@@ -565,16 +505,213 @@ var FollowerBroadcastBridge = class {
       return;
     }
     this.terminated = true;
+    this.leaveLeader();
+    if (typeof removeEventListener === "function") {
+      removeEventListener("pagehide", this.onPageHide);
+    }
     this.channel.close();
     for (const [, entry] of this.pending) {
       entry.reject(new Error("Follower bridge terminated"));
     }
     this.pending.clear();
   }
+  leaveLeader() {
+    try {
+      const message = {
+        type: CLIENT_LEAVE,
+        clientId: this.clientId
+      };
+      this.channel.postMessage(message);
+    } catch {
+    }
+  }
 };
+var TransactionSerializingWorkerBridge = class {
+  inner;
+  leaderClientId = createClientId();
+  transactionIdleTimeoutMs;
+  queue = [];
+  activeTransactionClient = null;
+  abortedClients = /* @__PURE__ */ new Set();
+  transactionIdleTimer = null;
+  reclaiming = false;
+  processing = false;
+  terminated = false;
+  constructor(inner, transactionIdleTimeoutMs = DEFAULT_TRANSACTION_IDLE_TIMEOUT_MS) {
+    this.inner = inner;
+    this.transactionIdleTimeoutMs = transactionIdleTimeoutMs;
+  }
+  send(request, clientId = this.leaderClientId) {
+    if (this.terminated) {
+      return Promise.resolve({
+        id: request.id,
+        type: "error",
+        message: "Worker has been terminated",
+        code: "WORKER_TERMINATED"
+      });
+    }
+    if (this.abortedClients.has(clientId)) {
+      if (request.type === "begin") {
+        this.abortedClients.delete(clientId);
+      } else {
+        return Promise.resolve({
+          id: request.id,
+          type: "error",
+          message: "Previous transaction was aborted because the client stopped sending requests.",
+          code: "TRANSACTION_ABORTED"
+        });
+      }
+    }
+    return new Promise((resolve, reject) => {
+      this.queue.push({ clientId, request, resolve, reject });
+      void this.processQueue();
+    });
+  }
+  terminate() {
+    if (this.terminated) {
+      return;
+    }
+    this.terminated = true;
+    this.clearTransactionIdleTimer();
+    this.inner.terminate();
+    const pending = this.queue.splice(0);
+    for (const entry of pending) {
+      entry.reject(new Error("Worker terminated"));
+    }
+  }
+  reclaimClient(clientId, reason) {
+    if (this.terminated) {
+      return;
+    }
+    void this.reclaimClientNow(clientId, reason);
+  }
+  async processQueue() {
+    if (this.processing || this.reclaiming) {
+      return;
+    }
+    this.processing = true;
+    try {
+      while (!this.terminated) {
+        const index = this.nextRunnableIndex();
+        if (index === -1) {
+          return;
+        }
+        const [entry] = this.queue.splice(index, 1);
+        if (!entry) {
+          return;
+        }
+        try {
+          const response = await this.inner.send(entry.request);
+          this.recordTransactionState(entry, response);
+          entry.resolve(response);
+        } catch (error) {
+          this.resetFailedTransaction(entry);
+          entry.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    } finally {
+      this.processing = false;
+      if (!this.terminated && !this.reclaiming && this.nextRunnableIndex() !== -1) {
+        void this.processQueue();
+      }
+    }
+  }
+  nextRunnableIndex() {
+    if (this.queue.length === 0) {
+      return -1;
+    }
+    if (this.activeTransactionClient === null) {
+      return 0;
+    }
+    return this.queue.findIndex((entry) => entry.clientId === this.activeTransactionClient);
+  }
+  recordTransactionState(entry, response) {
+    if (response.type === "error") {
+      this.resetFailedTransaction(entry);
+      return;
+    }
+    if (entry.request.type === "begin") {
+      this.activeTransactionClient = entry.clientId;
+      this.armTransactionIdleTimer(entry.clientId);
+      return;
+    }
+    if (this.activeTransactionClient === entry.clientId) {
+      this.armTransactionIdleTimer(entry.clientId);
+    }
+    if (this.activeTransactionClient === entry.clientId && (entry.request.type === "commit" || entry.request.type === "rollback")) {
+      this.activeTransactionClient = null;
+      this.clearTransactionIdleTimer();
+    }
+  }
+  resetFailedTransaction(entry) {
+    if (this.activeTransactionClient === entry.clientId) {
+      this.activeTransactionClient = null;
+      this.clearTransactionIdleTimer();
+    }
+  }
+  armTransactionIdleTimer(clientId) {
+    this.clearTransactionIdleTimer();
+    this.transactionIdleTimer = setTimeout(() => {
+      void this.reclaimClientNow(clientId, "transaction-idle-timeout");
+    }, this.transactionIdleTimeoutMs);
+  }
+  clearTransactionIdleTimer() {
+    if (this.transactionIdleTimer) {
+      clearTimeout(this.transactionIdleTimer);
+      this.transactionIdleTimer = null;
+    }
+  }
+  async reclaimClientNow(clientId, reason) {
+    if (this.reclaiming || this.activeTransactionClient !== clientId) {
+      return;
+    }
+    this.reclaiming = true;
+    this.clearTransactionIdleTimer();
+    this.activeTransactionClient = null;
+    this.abortedClients.add(clientId);
+    this.rejectQueuedClientRequests(clientId, reason);
+    try {
+      const response = await this.inner.send({ id: 0, type: "rollback" });
+      if (response.type === "error") {
+      }
+    } catch {
+    } finally {
+      this.reclaiming = false;
+      if (!this.terminated && this.nextRunnableIndex() !== -1) {
+        void this.processQueue();
+      }
+    }
+  }
+  rejectQueuedClientRequests(clientId, reason) {
+    const keep = [];
+    for (const entry of this.queue) {
+      if (entry.clientId === clientId) {
+        entry.resolve({
+          id: entry.request.id,
+          type: "error",
+          message: `Transaction client was reclaimed: ${reason}`,
+          code: "TRANSACTION_ABORTED"
+        });
+      } else {
+        keep.push(entry);
+      }
+    }
+    this.queue = keep;
+  }
+};
+function hasReclaimClient(bridge) {
+  return typeof bridge.reclaimClient === "function";
+}
+function createClientId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
 
 // src/adapters/sqlite-wasm-adapter.ts
 init_sqlite_wasm_channel();
+var warnedSharedWorkerDeprecated = false;
 var SqliteWasmAdapter = class {
   bridge = null;
   opened = false;
@@ -586,7 +723,8 @@ var SqliteWasmAdapter = class {
   dbName;
   emitter;
   tabSession = null;
-  sharedWorker = null;
+  emitNonPersistentDiagnostic;
+  storageOpenState = null;
   /** Retained so a follower promoted to leader can re-open its own worker. */
   schema = null;
   promoting = false;
@@ -597,50 +735,62 @@ var SqliteWasmAdapter = class {
     this.workerResponseTimeoutMs = options.workerResponseTimeoutMs ?? 3e4;
     this.dbName = options.dbName ?? "kora-db";
     this.emitter = options.emitter;
+    this.emitNonPersistentDiagnostic = options.emitNonPersistentDiagnostic ?? true;
   }
   async open(schema) {
     if (this.opened) return;
+    const ddlStatements = (0, import_core2.generateFullDDL)(schema);
     if (this.injectedBridge) {
       this.bridge = this.injectedBridge;
-    } else if (this.sharedWorkerUrl && this.workerUrl && isSharedWorkerStorageSupported()) {
-      const workerUrlString = typeof this.workerUrl === "string" ? this.workerUrl : this.workerUrl.href;
-      const sharedUrl = typeof this.sharedWorkerUrl === "string" ? this.sharedWorkerUrl : this.sharedWorkerUrl.href;
-      this.sharedWorker = new SharedWorker(sharedUrl, {
-        type: "module",
-        name: `kora-sw-${this.dbName}`
-      });
-      this.bridge = new SharedWorkerClientBridge(this.sharedWorker, this.dbName, workerUrlString);
-    } else if (this.workerUrl) {
-      this.schema = schema;
-      this.tabSession = await acquireTabStorageSession(this.dbName, {
-        onPromote: () => {
-          void this.promoteToLeader();
-        }
-      });
-      const { WebWorkerBridge: WebWorkerBridge2 } = await Promise.resolve().then(() => (init_sqlite_wasm_channel(), sqlite_wasm_channel_exports));
-      if (this.tabSession.role === "leader") {
-        const workerBridge = new WebWorkerBridge2(this.workerUrl, this.workerResponseTimeoutMs);
-        this.tabSession.stopRelay = startLeaderRpcRelay(this.tabSession.channelName, workerBridge);
-        this.bridge = workerBridge;
-      } else {
-        const followerBridge = new FollowerBroadcastBridge(
-          this.tabSession.channelName,
-          this.workerResponseTimeoutMs
-        );
-        this.bridge = followerBridge;
-        this.emitter?.emit({
-          type: "store:db-name-collision",
-          dbName: this.dbName,
-          message: `Another runtime on this origin is already using database "${this.dbName}"; this runtime is sharing it as a follower. If these are separate apps, give each a distinct store name.`
-        });
-        await followerBridge.waitForLeader();
+      const response = await this.openCurrentBridge(ddlStatements);
+      this.reportStorageMode(response.data);
+      this.opened = true;
+      return;
+    }
+    if (this.workerUrl) {
+      this.warnSharedWorkerDeprecated();
+      await this.openDurableWorkerBridge(schema);
+      const response = await this.openCurrentBridge(ddlStatements);
+      this.reportStorageMode(response.data);
+      this.opened = true;
+      return;
+    }
+    throw new AdapterError(
+      'SqliteWasmAdapter requires either a bridge (for testing) or a workerUrl (for browsers). Pass { bridge: new MockWorkerBridge() } for tests, or { workerUrl: "/worker.js" } for browsers.'
+    );
+  }
+  async openDurableWorkerBridge(schema) {
+    if (!this.workerUrl) {
+      throw new AdapterError("Durable SQLite WASM storage requires workerUrl.");
+    }
+    this.schema = schema;
+    this.tabSession = await acquireTabStorageSession(this.dbName, {
+      onPromote: () => {
+        void this.promoteToLeader();
       }
-    } else {
-      throw new AdapterError(
-        'SqliteWasmAdapter requires either a bridge (for testing) or a workerUrl (for browsers). Pass { bridge: new MockWorkerBridge() } for tests, or { workerUrl: "/worker.js" } for browsers.'
+    });
+    const { WebWorkerBridge: WebWorkerBridge2 } = await Promise.resolve().then(() => (init_sqlite_wasm_channel(), sqlite_wasm_channel_exports));
+    if (this.tabSession.role === "leader") {
+      const workerBridge = new TransactionSerializingWorkerBridge(
+        new WebWorkerBridge2(this.workerUrl, this.workerResponseTimeoutMs)
       );
+      this.tabSession.stopRelay = startLeaderRpcRelay(this.tabSession.channelName, workerBridge);
+      this.bridge = workerBridge;
+      return;
     }
-    const ddlStatements = (0, import_core2.generateFullDDL)(schema);
+    const followerBridge = new FollowerBroadcastBridge(
+      this.tabSession.channelName,
+      this.workerResponseTimeoutMs
+    );
+    this.bridge = followerBridge;
+    this.emitter?.emit({
+      type: "store:db-name-collision",
+      dbName: this.dbName,
+      message: `Another runtime on this origin is already using database "${this.dbName}"; this runtime is sharing it as a follower. If these are separate apps, give each a distinct store name.`
+    });
+    await followerBridge.waitForLeader();
+  }
+  async openCurrentBridge(ddlStatements) {
     const response = await this.sendRequest({
       id: 0,
       type: "open",
@@ -653,8 +803,7 @@ var SqliteWasmAdapter = class {
         dbName: this.dbName
       });
     }
-    this.reportStorageMode(response.data);
-    this.opened = true;
+    return response;
   }
   /**
    * Surface a `store:opfs-unavailable` diagnostic when the worker reported that
@@ -663,12 +812,12 @@ var SqliteWasmAdapter = class {
    * bridge that does not report a mode, e.g. the Node mock) emits nothing.
    */
   reportStorageMode(data) {
-    if (!this.emitter || typeof data !== "object" || data === null) {
+    this.storageOpenState = parseStorageOpenState(data);
+    if (!this.emitNonPersistentDiagnostic || !this.emitter || !this.storageOpenState) {
       return;
     }
-    const mode = data;
-    if (mode.persistent === false) {
-      const reason = mode.fallbackReason ?? "unsupported";
+    if (this.storageOpenState.persistent === false) {
+      const reason = this.storageOpenState.fallbackReason ?? "unsupported";
       this.emitter.emit({
         type: "store:opfs-unavailable",
         dbName: this.dbName,
@@ -677,6 +826,18 @@ var SqliteWasmAdapter = class {
       });
     }
   }
+  getStorageOpenState() {
+    return this.storageOpenState;
+  }
+  warnSharedWorkerDeprecated() {
+    if (!this.sharedWorkerUrl || warnedSharedWorkerDeprecated) {
+      return;
+    }
+    warnedSharedWorkerDeprecated = true;
+    console.warn(
+      "[kora] sharedWorkerUrl is deprecated and ignored: SharedWorker-hosted SQLite cannot use OPFS and is never durable. Kora uses the durable dedicated-worker leader/follower path for multi-tab storage."
+    );
+  }
   async close() {
     if (!this.bridge) return;
     try {
@@ -688,7 +849,6 @@ var SqliteWasmAdapter = class {
         await this.tabSession.releaseLock();
       }
       this.tabSession = null;
-      this.sharedWorker = null;
       this.bridge.terminate();
       this.bridge = null;
       this.opened = false;
@@ -707,7 +867,9 @@ var SqliteWasmAdapter = class {
     }
     this.promoting = true;
     const { WebWorkerBridge: WebWorkerBridge2 } = await Promise.resolve().then(() => (init_sqlite_wasm_channel(), sqlite_wasm_channel_exports));
-    const workerBridge = new WebWorkerBridge2(this.workerUrl, this.workerResponseTimeoutMs);
+    const workerBridge = new TransactionSerializingWorkerBridge(
+      new WebWorkerBridge2(this.workerUrl, this.workerResponseTimeoutMs)
+    );
     const previousBridge = this.bridge;
     this.bridge = workerBridge;
     if (this.tabSession) {
@@ -805,7 +967,10 @@ var SqliteWasmAdapter = class {
     this.guardOpen();
     const response = await this.sendRequest({ id: 0, type: "export" });
     if (response.type === "error") {
-      throw new AdapterError(`Export failed: ${response.message}`);
+      throw new AdapterError(`Export failed: ${response.message}`, {
+        code: response.code,
+        context: response.context
+      });
     }
     return response.data;
   }
@@ -838,6 +1003,20 @@ var SqliteWasmAdapter = class {
     }
   }
 };
+function parseStorageOpenState(data) {
+  if (typeof data !== "object" || data === null) {
+    return null;
+  }
+  const mode = data;
+  if (typeof mode.persistent !== "boolean") {
+    return null;
+  }
+  return {
+    persistent: mode.persistent,
+    mode: mode.persistent ? "opfs" : "memory",
+    ...mode.fallbackReason ? { fallbackReason: mode.fallbackReason } : {}
+  };
+}
 
 // src/adapters/sqlite-wasm-persistence.ts
 init_errors();
@@ -972,6 +1151,24 @@ async function loadDumpFromIndexedDB(dbName) {
     idb.close();
   }
 }
+async function deleteSnapshotFromIndexedDB(dbName) {
+  const idb = await openIdb();
+  try {
+    await new Promise((resolve, reject) => {
+      const tx = idb.transaction(IDB_STORE_NAME, "readwrite");
+      const store = tx.objectStore(IDB_STORE_NAME);
+      store.delete(dbName);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(
+        new PersistenceError(`Failed to delete database snapshot "${dbName}" from IndexedDB`, {
+          dbName
+        })
+      );
+    });
+  } finally {
+    idb.close();
+  }
+}
 
 // src/adapters/indexeddb-adapter.ts
 var IndexedDbAdapter = class {
@@ -979,6 +1176,7 @@ var IndexedDbAdapter = class {
   dbName;
   emitter;
   scheduler;
+  storageOpenState = null;
   constructor(options = {}) {
     this.dbName = options.dbName ?? "kora-db";
     this.emitter = options.emitter;
@@ -996,8 +1194,12 @@ var IndexedDbAdapter = class {
   }
   async open(schema) {
     await this.inner.open(schema);
+    this.storageOpenState = { persistent: true, mode: "indexeddb" };
     const persisted = await loadFromIndexedDB(this.dbName);
-    if (!persisted) return;
+    if (!persisted) {
+      await this.restoreFromDumpFallback();
+      return;
+    }
     try {
       await this.inner.importDatabase(persisted);
     } catch {
@@ -1024,6 +1226,9 @@ var IndexedDbAdapter = class {
     await this.inner.migrate(from, to, migration);
     this.scheduler.schedule();
   }
+  getStorageOpenState() {
+    return this.storageOpenState;
+  }
   /**
    * Force an immediate snapshot write to IndexedDB (skips debounce).
    * Useful before tab unload or in tests.
@@ -1032,10 +1237,17 @@ var IndexedDbAdapter = class {
     await this.scheduler.flushNow();
   }
   async writeSnapshot() {
-    const data = await this.inner.exportDatabase();
-    await saveToIndexedDB(this.dbName, data);
     const dump = await this.exportDump();
     await saveDumpToIndexedDB(this.dbName, dump);
+    try {
+      const data = await this.inner.exportDatabase();
+      await saveToIndexedDB(this.dbName, data);
+    } catch (error) {
+      if (!isUnsupportedWorkerExport(error)) {
+        throw error;
+      }
+      await deleteSnapshotFromIndexedDB(this.dbName);
+    }
   }
   handlePersistenceError(error) {
     const message = error instanceof Error ? error.message : "IndexedDB persistence failed";
@@ -1109,6 +1321,9 @@ function ensureSafeIdentifier(identifier) {
   }
   return identifier;
 }
+function isUnsupportedWorkerExport(error) {
+  return error instanceof AdapterError && error.context?.code === "EXPORT_NOT_SUPPORTED";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   IndexedDbAdapter