@roc-db/indexed-db 0.2.0-pre.32 → 0.2.0-pre.34

package/dist/index.js

@@ -15,31 +15,20 @@ 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,
+  commit: () => commit,
   begin: () => begin,
   batchReadEntities: () => batchReadEntities
 });
 
 // src/functions/readEntity.ts
-import { DELETED_IN_CHANGE_SET_SYMBOL } from "roc-db";
 var readEntity = async (txn, ref) => {
-  if (txn.request.changeSetRef) {
-    const doc = txn.engineOpts.changeSet.entities.get(ref);
-    if (doc === DELETED_IN_CHANGE_SET_SYMBOL)
-      return;
-    if (doc)
-      return doc;
-  }
   const objectStore = txn.engineOpts.txn.objectStore("entities");
   const request = objectStore.get(ref);
   return new Promise((resolve, reject) => {
@@ -58,7 +47,7 @@ var batchReadEntities = (txn, refs) => {
   return Promise.all(refs.map((ref) => readEntity(txn, ref)));
 };
 // src/functions/begin.ts
-var begin = async (request, engineOpts, callback) => {
+var begin = async (engineOpts, callback) => {
   return new Promise((resolve, reject) => {
     let db;
     const idbRequest = indexedDB.open(engineOpts.dbName, 1);
@@ -77,60 +66,30 @@ var begin = async (request, engineOpts, callback) => {
       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 as DELETED_IN_CHANGE_SET_SYMBOL2 } 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);
@@ -141,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_SYMBOL2);
-    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);
     };
   });
@@ -221,12 +227,15 @@ var findDebounceMutation = async (request, engine, now) => {
 // src/functions/pageMutations.ts
 var pageMutations = async (txn, args) => {
   const { size, changeSetRef, skip } = args;
-  if (!changeSetRef)
-    throw new Error("changeSetRef is required");
   const objectStore = txn.engineOpts.txn.objectStore("mutations");
-  const index = objectStore.index("byChangeSetRef");
-  const range = IDBKeyRange.only(changeSetRef);
-  const idbRequest = index.openCursor(range);
+  let idbRequest;
+  if (changeSetRef) {
+    const index = objectStore.index("byChangeSetRef");
+    const range = IDBKeyRange.only(changeSetRef);
+    idbRequest = index.openCursor(range);
+  } else {
+    idbRequest = objectStore.openCursor();
+  }
   return new Promise((resolve, reject) => {
     const results = [];
     idbRequest.onsuccess = () => {
@@ -240,40 +249,6 @@ var pageMutations = async (txn, args) => {
     };
   });
 };
-// src/functions/patchEntity.ts
-import { deepPatch, NotFoundError } from "roc-db";
-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 = async (engineOpts, ref) => {
   const objectStore = engineOpts.txn.objectStore("mutations");
@@ -288,55 +263,6 @@ var readMutation = async (engineOpts, ref) => {
     };
   });
 };
-// src/functions/saveMutation.ts
-var saveMutation = async (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,

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

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

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

@@ -1 +1 @@
-export declare const begin: (request: any, engineOpts: any, callback: any) => Promise<unknown>;
+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

@@ -1,4 +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>;
+export declare const end: EndFunction<WriteRequest, IndexedDBEngine, [
+], any>;

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/indexed-db",
-    "version": "0.2.0-pre.32",
+    "version": "0.2.0-pre.34",
     "type": "module",
     "exports": {
         ".": {
@@ -14,7 +14,7 @@
     "sideEffects": false,
     "dependencies": {},
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.32",
+        "roc-db": "0.2.0-pre.34",
         "zod": "^3.0.0"
     },
     "keywords": [],

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

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

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

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

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

@@ -1,7 +0,0 @@
-import type { IndexedDBReadTransaction } from "../types/IndexedDBReadTransaction";
-export declare const patchEntity: (txn: IndexedDBReadTransaction, ref: any, { data, children, parents, ancestors }: {
-    data?: {} | undefined;
-    children?: {} | undefined;
-    parents?: {} | undefined;
-    ancestors?: {} | undefined;
-}) => Promise<any>;

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

@@ -1,6 +0,0 @@
-export declare const updateEntity: (txn: any, ref: any, { data, children, parents, ancestors }: {
-    data?: {} | undefined;
-    children?: {} | undefined;
-    parents?: {} | undefined;
-    ancestors?: {} | undefined;
-}) => Promise<unknown>;