@roc-db/indexed-db 0.2.0-pre.98 → 0.2.0-pre.99

package/dist/index.js

@@ -69,11 +69,14 @@ var batchReadEntities = (txn, refs) => {
   return Promise.all(refs.map((ref) => readEntity(txn, ref)));
 };
 // src/functions/begin.ts
-var begin = async (engineOpts, callback) => {
-  return new Promise((resolve, reject) => {
-    let db;
-    const idbRequest = indexedDB.open(engineOpts.dbName, 1);
-    idbRequest.onupgradeneeded = (event) => {
+var DB_CACHE = new WeakMap;
+var openDatabase = (engineOpts) => {
+  let cached = DB_CACHE.get(engineOpts);
+  if (cached)
+    return cached;
+  const promise = new Promise((resolve, reject) => {
+    const idbRequest = indexedDB.open(engineOpts.dbName, engineOpts.version);
+    idbRequest.onupgradeneeded = () => {
       const entitiesObjectStore = idbRequest.result.createObjectStore("entities", { keyPath: "ref" });
       const mutationsObjectStore = idbRequest.result.createObjectStore("mutations", { keyPath: "ref" });
       entitiesObjectStore.createIndex("unique_constraint_0", ["entity", "unique_constraint_0"], { unique: true });
@@ -88,15 +91,72 @@ var begin = async (engineOpts, callback) => {
         unique: false
       });
     };
-    idbRequest.onsuccess = (event) => {
-      db = idbRequest.result;
-      resolve(callback({
-        ...engineOpts,
-        db,
-        txn: db.transaction(["entities", "mutations"], "readwrite")
-      }));
+    idbRequest.onsuccess = () => {
+      const db = idbRequest.result;
+      db.onversionchange = () => {
+        db.close();
+        DB_CACHE.delete(engineOpts);
+      };
+      resolve(db);
+    };
+    idbRequest.onerror = () => {
+      DB_CACHE.delete(engineOpts);
+      reject(idbRequest.error);
     };
   });
+  DB_CACHE.set(engineOpts, promise);
+  return promise;
+};
+var begin = async (engineOpts, callback) => {
+  const db = await openDatabase(engineOpts);
+  return new Promise((resolve, reject) => {
+    const txn = db.transaction(["entities", "mutations"], "readwrite");
+    let callbackResult;
+    let callbackDone = false;
+    let txnComplete = false;
+    let settled = false;
+    const maybeResolve = () => {
+      if (settled)
+        return;
+      if (callbackDone && txnComplete) {
+        settled = true;
+        resolve(callbackResult);
+      }
+    };
+    txn.oncomplete = () => {
+      txnComplete = true;
+      maybeResolve();
+    };
+    txn.onerror = (event) => {
+      if (settled)
+        return;
+      settled = true;
+      reject(txn.error ?? event.target?.error);
+    };
+    txn.onabort = () => {
+      if (settled)
+        return;
+      settled = true;
+      reject(txn.error ?? new Error("Transaction aborted"));
+    };
+    Promise.resolve(callback({
+      ...engineOpts,
+      db,
+      txn
+    })).then((result) => {
+      callbackResult = result;
+      callbackDone = true;
+      maybeResolve();
+    }).catch((error) => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        txn.abort();
+      } catch {}
+      reject(error);
+    });
+  });
 };
 // src/functions/commitCreate.ts
 import {
@@ -111,6 +171,8 @@ var commitCreate = (txn, document) => {
     };
     request.onerror = (event) => {
       if (event?.target?.error?.name === "ConstraintError") {
+        event.stopPropagation();
+        event.preventDefault();
         reject(createUniqueConstraintConflictError(document.entity));
       } else {
         console.error("Error creating entity:", document, event?.target?.error);
@@ -250,7 +312,7 @@ var getChangeSetMutations = async (txn, changeSetRef) => {
   });
 };
 // src/functions/findDebounceMutation.ts
-var findDebounceMutation = async (request, engine, now, mutationName) => {
+var findDebounceMutation = async (request, engine, now, mutationName, identityRef) => {
   const objectStore = engine.txn.objectStore("mutations");
   const index = objectStore.index("timestamp");
   const timestamp = new Date(now - request.operation.debounce * 1000).toISOString();
@@ -262,21 +324,21 @@ var findDebounceMutation = async (request, engine, now, mutationName) => {
       const cursor = idbRequest.result;
       if (cursor) {
         const doc = cursor.value;
-        if (doc.operation.name === mutationName && doc.payload.ref === request.payload.ref && doc.changeSetRef === request.changeSetRef) {
+        if (doc.operation.name === mutationName && doc.payload.ref === request.payload.ref && doc.changeSetRef === request.changeSetRef && doc.identityRef === identityRef) {
           results.push(doc);
         }
         cursor.continue();
       } else {
-        if (results.length) {
-          if (results.length > 1) {
-            throw new Error("Unhandled multiple debounced mutations");
-          }
-          resolve(results[0]);
-        } else {
-          resolve(undefined);
+        if (results.length > 1) {
+          reject(new Error("Unhandled multiple debounced mutations"));
+          return;
         }
+        resolve(results[0]);
       }
     };
+    idbRequest.onerror = () => {
+      reject(idbRequest.error);
+    };
   });
 };
 // src/functions/pageEntities.ts
@@ -392,7 +454,8 @@ var createIndexedDBAdapter = ({
   entities,
   session,
   dbName = "roc-db",
-  optimistic = false
+  optimistic = false,
+  snowflake = new Snowflake(1, 1)
 }) => {
   return createAdapter({
     name: "indexed-db",
@@ -401,7 +464,7 @@ var createIndexedDBAdapter = ({
     functions: exports_functions,
     optimistic,
     session,
-    snowflake: new Snowflake(1, 1),
+    snowflake,
     async: true
   }, {
     dbName,

package/dist/types/createIndexedDBAdapter.d.ts

@@ -1,8 +1,9 @@
-import { type Adapter } from "roc-db";
-export declare const createIndexedDBAdapter: ({ operations, entities, session, dbName, optimistic, }: {
+import { Snowflake, type Adapter } from "roc-db";
+export declare const createIndexedDBAdapter: ({ operations, entities, session, dbName, optimistic, snowflake, }: {
     operations: any;
     entities: any;
     session: any;
     dbName?: string | undefined;
     optimistic?: boolean | undefined;
+    snowflake?: Snowflake | undefined;
 }) => Adapter;

package/dist/types/functions/findDebounceMutation.d.ts

@@ -1,3 +1,3 @@
 import type { WriteRequest } from "roc-db";
 import type { IndexedDBEngine } from "../types/IndexedDBEngine";
-export declare const findDebounceMutation: (request: WriteRequest, engine: IndexedDBEngine, now: number, mutationName: string) => Promise<unknown>;
+export declare const findDebounceMutation: (request: WriteRequest, engine: IndexedDBEngine, now: number, mutationName: string, identityRef: string) => Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/indexed-db",
-    "version": "0.2.0-pre.98",
+    "version": "0.2.0-pre.99",
     "type": "module",
     "exports": {
         ".": {
@@ -14,7 +14,7 @@
     "sideEffects": false,
     "dependencies": {},
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.98",
+        "roc-db": ">=0.2.0-pre.98 <1.0.0",
         "zod": ">=4.0.0"
     },
     "keywords": [],
@@ -23,5 +23,9 @@
         "type": "git",
         "url": "git+https://github.com/eigilsagafos/roc-db.git"
     },
-    "license": "MIT"
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
 }