@roc-db/indexed-db 0.2.0-pre.4 → 0.2.0-pre.40

package/dist/index.js

@@ -15,21 +15,39 @@ import { createAdapter, Snowflake } from "roc-db";
 // src/functions/index.ts
 var exports_functions = {};
 __export(exports_functions, {
-  updateEntity: () => updateEntity,
   saveMutation: () => saveMutation,
   readMutation: () => readMutation,
   readEntity: () => readEntity,
-  patchEntity: () => patchEntity,
+  pageMutations: () => pageMutations,
   getChangeSetMutations: () => getChangeSetMutations,
   findDebounceMutation: () => findDebounceMutation,
   end: () => end,
-  deleteEntity: () => deleteEntity,
-  createEntity: () => createEntity,
-  begin: () => begin
+  commit: () => commit,
+  begin: () => begin,
+  batchReadEntities: () => batchReadEntities
 });
 
+// src/functions/readEntity.ts
+var readEntity = async (txn, ref) => {
+  const objectStore = txn.engineOpts.txn.objectStore("entities");
+  const request = objectStore.get(ref);
+  return new Promise((resolve, reject) => {
+    request.onsuccess = (event) => {
+      const document = event.target.result;
+      resolve(document);
+    };
+    request.onerror = (event) => {
+      reject(event.target.error);
+    };
+  });
+};
+
+// src/functions/batchReadEntities.ts
+var batchReadEntities = (txn, refs) => {
+  return Promise.all(refs.map((ref) => readEntity(txn, ref)));
+};
 // src/functions/begin.ts
-var begin = async (request, engineOpts) => {
+var begin = async (engineOpts, callback) => {
   return new Promise((resolve, reject) => {
     let db;
     const idbRequest = indexedDB.open(engineOpts.dbName, 1);
@@ -45,63 +63,33 @@ var begin = async (request, engineOpts) => {
     };
     idbRequest.onsuccess = (event) => {
       db = idbRequest.result;
-      resolve({
+      resolve(callback({
         ...engineOpts,
         db,
-        txn: db.transaction(["entities", "mutations"], request.type === "write" ? "readwrite" : "readonly"),
-        changeSet: request.changeSetRef ? {
-          entities: new Map([]),
-          mutations: new Map([])
-        } : null
-      });
+        txn: db.transaction(["entities", "mutations"], "readwrite")
+      }));
     };
   });
 };
-// src/functions/createEntity.ts
-import { entityFromRef } from "roc-db";
-var createEntity = (txn, ref, { data = {}, children = {}, ancestors = {}, parents = {} }) => {
+// src/functions/commitCreate.ts
+var commitCreate = (txn, document) => {
   const objectStore = txn.engineOpts.txn.objectStore("entities");
-  const entity = entityFromRef(ref);
-  const document = {
-    ref,
-    created: {
-      mutationRef: txn.mutation.ref,
-      timestamp: txn.mutation.timestamp
-    },
-    updated: {
-      mutationRef: txn.mutation.ref,
-      timestamp: txn.mutation.timestamp
-    },
-    entity,
-    data,
-    children,
-    ancestors,
-    parents
-  };
-  if (txn.request.changeSetRef) {
-    if (txn.engineOpts.changeSet.entities.has(ref)) {
-      throw new Error("Entity already exists in changeSet");
-    } else {
-      txn.engineOpts.changeSet.entities.set(ref, document);
-      return document;
-    }
-  } else {
-    const request = objectStore.add(document);
-    return new Promise((resolve, reject) => {
-      request.onsuccess = (event) => {
-        resolve(document);
-      };
-      request.onerror = (event) => {
-        console.error("Error creating entity:", document, event?.target?.error);
-        reject(event?.target?.error);
-      };
-    });
-  }
+  const request = objectStore.add(document);
+  return new Promise((resolve, reject) => {
+    request.onsuccess = (event) => {
+      resolve(document);
+    };
+    request.onerror = (event) => {
+      console.error("Error creating entity:", document, event?.target?.error);
+      reject(event?.target?.error);
+    };
+  });
 };
-// src/functions/deleteEntity.ts
-import { DELETED_IN_CHANGE_SET_SYMBOL } from "roc-db";
-var deleteIndexed = (store, ref) => {
-  const request = store.delete(ref);
+
+// src/functions/commitDelete.ts
+var commitDelete = async (txn, ref, cascade = false) => {
+  const objectStore = txn.engineOpts.txn.objectStore("entities");
+  const request = objectStore.delete(ref);
   return new Promise((resolve, reject) => {
     request.onsuccess = () => {
       resolve(true);
@@ -112,29 +100,76 @@ var deleteIndexed = (store, ref) => {
     };
   });
 };
-var deleteEntity = async (txn, ref, cascade = false) => {
-  if (txn.request.changeSetRef) {
-    txn.engineOpts.changeSet.entities.set(ref, DELETED_IN_CHANGE_SET_SYMBOL);
-    if (cascade) {
-      throw new Error("TGOD");
-    }
-    return true;
+
+// src/functions/commitUpdate.ts
+var commitUpdate = async (txn, document) => {
+  const objectStore = txn.engineOpts.txn.objectStore("entities");
+  const request = objectStore.put(document);
+  return new Promise((resolve, reject) => {
+    request.onsuccess = (event) => {
+      resolve(document);
+    };
+    request.onerror = (event) => {
+      console.error("Error updating document", event?.target?.error);
+      reject(event?.target?.error);
+    };
+  });
+};
+
+// src/functions/saveMutation.ts
+var saveMutation = async (txn, finalizedMutation) => {
+  const objectStore = txn.engineOpts.txn.objectStore("mutations");
+  let request;
+  if (finalizedMutation.debounceCount > 0 || finalizedMutation.appliedAt) {
+    request = objectStore.put(finalizedMutation);
   } else {
-    const objectStore = txn.engineOpts.txn.objectStore("entities");
-    await deleteIndexed(objectStore, ref);
-    if (cascade) {
-      throw new Error("TGOD");
+    request = objectStore.add(finalizedMutation);
+  }
+  return new Promise((resolve, reject) => {
+    request.onsuccess = (event) => {
+      resolve(finalizedMutation);
+    };
+    request.onerror = (event) => {
+      console.error("Error saving mutation", event?.target?.error);
+      reject(event?.target?.error);
+    };
+  });
+};
+
+// src/functions/commit.ts
+var commit = async (txn, mutation, { created, updated, deleted }) => {
+  const currentMutation = await txn.readMutation(txn.mutation.ref, false);
+  if (currentMutation) {
+    if (currentMutation && mutation.appliedAt === txn.timestamp) {
+      await saveMutation(txn, mutation);
+    } else if (currentMutation && mutation.debounceCount > currentMutation.debounceCount) {
+      await saveMutation(txn, mutation);
+    } else {
+      throw new Error("Mutation already exists");
     }
-    return true;
+  } else {
+    await saveMutation(txn, mutation);
+  }
+  if (txn.request.changeSetRef)
+    return mutation;
+  for (const doc of created) {
+    await commitCreate(txn, doc);
+  }
+  for (const doc of updated) {
+    await commitUpdate(txn, doc);
   }
+  for (const ref of deleted) {
+    await commitDelete(txn, ref);
+  }
+  return mutation;
 };
 // src/functions/end.ts
-var end = (txn) => {
+var end = (engineOpts) => {
   return new Promise((resolve, reject) => {
-    txn.engineOpts.txn.oncomplete = () => {
+    engineOpts.txn.oncomplete = () => {
       resolve(undefined);
     };
-    txn.engineOpts.txn.onerror = (event) => {
+    engineOpts.txn.onerror = (event) => {
       reject(event.target.error);
     };
   });
@@ -159,8 +194,7 @@ var getChangeSetMutations = async (txn, changeSetRef) => {
   });
 };
 // src/functions/findDebounceMutation.ts
-var findDebounceMutation = async (request, engine, now) => {
-  const mutationName = request.schema.shape.name.value;
+var findDebounceMutation = async (request, engine, now, mutationName) => {
   const objectStore = engine.txn.objectStore("mutations");
   const index = objectStore.index("timestamp");
   const timestamp = new Date(now - request.settings.debounce * 1000).toISOString();
@@ -172,7 +206,7 @@ var findDebounceMutation = async (request, engine, now) => {
       const cursor = idbRequest.result;
       if (cursor) {
         const doc = cursor.value;
-        if (doc.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) {
           results.push(doc);
         }
         cursor.continue();
@@ -189,67 +223,33 @@ var findDebounceMutation = async (request, engine, now) => {
     };
   });
 };
-// src/functions/patchEntity.ts
-import { deepPatch, NotFoundError } from "roc-db";
-
-// src/functions/readEntity.ts
-import { DELETED_IN_CHANGE_SET_SYMBOL as DELETED_IN_CHANGE_SET_SYMBOL2 } from "roc-db";
-var readEntity = (txn, ref) => {
-  if (txn.request.changeSetRef) {
-    const doc = txn.engineOpts.changeSet.entities.get(ref);
-    if (doc === DELETED_IN_CHANGE_SET_SYMBOL2)
-      return;
-    if (doc)
-      return doc;
+// src/functions/pageMutations.ts
+var pageMutations = async (txn, args) => {
+  const { size, changeSetRef, skip } = args;
+  const objectStore = txn.engineOpts.txn.objectStore("mutations");
+  let idbRequest;
+  if (changeSetRef) {
+    const index = objectStore.index("byChangeSetRef");
+    const range = IDBKeyRange.only(changeSetRef);
+    idbRequest = index.openCursor(range);
+  } else {
+    idbRequest = objectStore.openCursor();
   }
-  const objectStore = txn.engineOpts.txn.objectStore("entities");
-  const request = objectStore.get(ref);
   return new Promise((resolve, reject) => {
-    request.onsuccess = (event) => {
-      const document = event.target.result;
-      resolve(document);
-    };
-    request.onerror = (event) => {
-      reject(event.target.error);
+    const results = [];
+    idbRequest.onsuccess = () => {
+      const cursor = idbRequest.result;
+      if (cursor) {
+        results.push(cursor.value);
+        cursor.continue();
+      } else {
+        resolve(results);
+      }
     };
   });
 };
-
-// src/functions/patchEntity.ts
-var patchEntity = async (txn, ref, { data = {}, children = {}, parents = {}, ancestors = {} }) => {
-  const existingDocument = await readEntity(txn, ref);
-  if (!existingDocument)
-    throw new NotFoundError(ref);
-  const updatedDocument = {
-    ...existingDocument,
-    updated: {
-      timestamp: txn.mutation.timestamp,
-      mutationRef: txn.mutation.ref
-    },
-    data: deepPatch(existingDocument.data, data),
-    children: deepPatch(existingDocument.children, children),
-    parents: deepPatch(existingDocument.parents, parents),
-    ancestors: deepPatch(existingDocument.ancestors, ancestors)
-  };
-  if (txn.request.changeSetRef) {
-    txn.engineOpts.changeSet.entities.set(ref, updatedDocument);
-    return updatedDocument;
-  } else {
-    const objectStore = txn.engineOpts.txn.objectStore("entities");
-    const request = objectStore.put(updatedDocument);
-    return new Promise((resolve, reject) => {
-      request.onsuccess = (event) => {
-        resolve(updatedDocument);
-      };
-      request.onerror = (event) => {
-        console.error("Error patching document", event?.target?.error);
-        reject(event?.target?.error);
-      };
-    });
-  }
-};
 // src/functions/readMutation.ts
-var readMutation = (engineOpts, ref) => {
+var readMutation = async (engineOpts, ref) => {
   const objectStore = engineOpts.txn.objectStore("mutations");
   const request = objectStore.get(ref);
   return new Promise((resolve, reject) => {
@@ -262,66 +262,21 @@ var readMutation = (engineOpts, ref) => {
     };
   });
 };
-// src/functions/saveMutation.ts
-var saveMutation = (txn, finalizedMutation) => {
-  const objectStore = txn.engineOpts.txn.objectStore("mutations");
-  let request;
-  if (finalizedMutation.debounceCount > 0) {
-    request = objectStore.put(finalizedMutation);
-  } else {
-    request = objectStore.add(finalizedMutation);
-  }
-  return new Promise((resolve, reject) => {
-    request.onsuccess = (event) => {
-      resolve(finalizedMutation);
-    };
-    request.onerror = (event) => {
-      console.error("Error saving mutation", event?.target?.error);
-      reject(event?.target?.error);
-    };
-  });
-};
-// src/functions/updateEntity.ts
-var updateEntity = async (txn, ref, { data = {}, children = {}, parents = {}, ancestors = {} }) => {
-  const currentEntity = await readEntity(txn, ref);
-  const objectStore = txn.engineOpts.txn.objectStore("entities");
-  const document = {
-    ...currentEntity,
-    updated: {
-      mutationRef: txn.mutation.ref,
-      timestamp: txn.mutation.timestamp
-    },
-    data,
-    children,
-    parents,
-    ancestors
-  };
-  if (txn.request.changeSetRef) {
-    throw new Error("TODO support changeSetRef");
-  } else {
-    const request = objectStore.put(document);
-    return new Promise((resolve, reject) => {
-      request.onsuccess = (event) => {
-        resolve(document);
-      };
-      request.onerror = (event) => {
-        console.error("Error updating document", event?.target?.error);
-        reject(event?.target?.error);
-      };
-    });
-  }
-};
 // src/createIndexedDBAdapter.ts
 var createIndexedDBAdapter = ({
   operations,
   entities,
-  dbName = "roc-db"
+  session,
+  dbName = "roc-db",
+  optimistic = false
 }) => {
   return createAdapter({
     name: "indexed-db",
     operations,
     entities,
     functions: exports_functions,
+    optimistic,
+    session,
     snowflake: new Snowflake(1, 1),
     async: true
   }, {

package/dist/types/createIndexedDBAdapter.d.ts

@@ -0,0 +1,7 @@
+export declare const createIndexedDBAdapter: ({ operations, entities, session, dbName, optimistic, }: {
+    operations: any;
+    entities: any;
+    session: any;
+    dbName?: string | undefined;
+    optimistic?: boolean | undefined;
+}) => Adapter;

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

@@ -0,0 +1,2 @@
+import type { Ref } from "roc-db";
+export declare const batchReadEntities: (txn: any, refs: Ref[]) => Promise<unknown[]>;

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

@@ -0,0 +1 @@
+export declare const begin: (engineOpts: any, callback: any) => Promise<unknown>;

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

@@ -0,0 +1,5 @@
+export declare const commit: (txn: any, mutation: any, { created, updated, deleted }: {
+    created: any;
+    updated: any;
+    deleted: any;
+}) => Promise<any>;

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

@@ -0,0 +1,3 @@
+import type { CreateEntityFunction } from "roc-db";
+import type { IndexedDBEngine } from "../types/IndexedDBEngine";
+export declare const commitCreate: CreateEntityFunction<IndexedDBEngine>;

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

@@ -0,0 +1 @@
+export declare const commitDelete: (txn: any, ref: any, cascade?: boolean) => Promise<unknown>;

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

@@ -0,0 +1 @@
+export declare const commitUpdate: (txn: any, document: any) => Promise<unknown>;

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

@@ -0,0 +1,5 @@
+import type { EndFunction } from "roc-db";
+import type { IndexedDBEngine } from "../types/IndexedDBEngine";
+import type { WriteRequest } from "roc-db/src/types/WriteRequest";
+export declare const end: EndFunction<WriteRequest, IndexedDBEngine, [
+], any>;

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

@@ -0,0 +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>;

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

@@ -0,0 +1,3 @@
+import type { Ref } from "roc-db";
+import type { IndexedDBReadTransaction } from "../types/IndexedDBReadTransaction";
+export declare const getChangeSetMutations: (txn: IndexedDBReadTransaction, changeSetRef: Ref) => Promise<unknown>;

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

@@ -0,0 +1,10 @@
+export { batchReadEntities } from "./batchReadEntities";
+export { begin } from "./begin";
+export { commit } from "./commit";
+export { end } from "./end";
+export { getChangeSetMutations } from "./getChangeSetMutations";
+export { findDebounceMutation } from "./findDebounceMutation";
+export { pageMutations } from "./pageMutations";
+export { readEntity } from "./readEntity";
+export { readMutation } from "./readMutation";
+export { saveMutation } from "./saveMutation";

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

@@ -0,0 +1,2 @@
+import type { IndexedDBReadTransaction } from "../types/IndexedDBReadTransaction";
+export declare const pageMutations: (txn: IndexedDBReadTransaction, args: any) => Promise<unknown>;

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

@@ -0,0 +1 @@
+export declare const readEntity: (txn: any, ref: any) => Promise<unknown>;

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

@@ -0,0 +1 @@
+export declare const readMutation: (engineOpts: any, ref: any) => Promise<unknown>;

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

@@ -0,0 +1 @@
+export declare const saveMutation: (txn: any, finalizedMutation: any) => Promise<unknown>;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { createIndexedDBAdapter } from "./createIndexedDBAdapter";

package/dist/types/types/IndexedDBEngine.d.ts

@@ -0,0 +1,5 @@
+export type IndexedDBEngine = {
+    dbName: string;
+    db: IDBDatabase;
+    txn: IDBTransaction;
+};

package/dist/types/types/IndexedDBReadTransaction.d.ts

@@ -0,0 +1,4 @@
+import type { ReadTransaction } from "roc-db";
+import type { IndexedDBEngine } from "./IndexedDBEngine";
+export type IndexedDBReadTransaction = ReadTransaction<any, IndexedDBEngine, [
+], any>;

package/package.json

@@ -1,29 +1,21 @@
 {
     "name": "@roc-db/indexed-db",
-    "version": "0.2.0-pre.4",
+    "version": "0.2.0-pre.40",
     "type": "module",
     "exports": {
-        ".": "./src/index.ts"
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/types/index.d.ts"
+        }
     },
     "files": [
         "dist"
     ],
     "sideEffects": false,
-    "scripts": {
-        "build": "NODE_ENV=production bun run scripts/build.ts",
-        "build:types": "rm -rf dist/types && bun run tsc --noCheck",
-        "test": "bun test"
-    },
     "dependencies": {},
-    "devDependencies": {
-        "@roc-db/test-utils": "0.2.0-pre.4",
-        "fake-indexeddb": "6.0.0",
-        "roc-db": "0.2.0-pre.4",
-        "zod": "3.24.2"
-    },
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.4",
-        "zod": "3.24.2"
+        "roc-db": "0.2.0-pre.40",
+        "zod": "^3.0.0"
     },
     "keywords": [],
     "author": "Eigil Sagafos",