@roc-db/indexed-db 0.2.0-pre.7 → 0.2.0-pre.71

package/dist/index.js

@@ -15,28 +15,72 @@ import { createAdapter, Snowflake } from "roc-db";
 // src/functions/index.ts
 var exports_functions = {};
 __export(exports_functions, {
-  updateEntity: () => updateEntity,
   saveMutation: () => saveMutation,
+  refByUniqueField: () => refByUniqueField,
   readMutation: () => readMutation,
   readEntity: () => readEntity,
-  patchEntity: () => patchEntity,
   pageMutations: () => pageMutations,
+  pageEntitiesByIndex: () => pageEntitiesByIndex,
+  pageEntities: () => pageEntities,
   getChangeSetMutations: () => getChangeSetMutations,
   findDebounceMutation: () => findDebounceMutation,
   end: () => end,
-  deleteEntity: () => deleteEntity,
-  createEntity: () => createEntity,
-  begin: () => begin
+  commit: () => commit,
+  begin: () => begin,
+  batchReadEntities: () => batchReadEntities
 });
 
+// src/lib/documentFromDBRow.ts
+var documentFromDBRow = ({
+  unique_constraint_0,
+  unique_constraint_1,
+  index_entries,
+  ...document
+}) => {
+  return {
+    ...document,
+    __: {
+      uniqueExisting: [],
+      indexExisting: []
+    }
+  };
+};
+
+// 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 result = event.target.result;
+      if (!result) {
+        return resolve(undefined);
+      }
+      resolve(documentFromDBRow(result));
+    };
+    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, callback) => {
+var begin = async (engineOpts, callback) => {
   return new Promise((resolve, reject) => {
     let db;
     const idbRequest = indexedDB.open(engineOpts.dbName, 1);
     idbRequest.onupgradeneeded = (event) => {
       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 });
+      entitiesObjectStore.createIndex("unique_constraint_1", ["entity", "unique_constraint_1"], { unique: true });
+      entitiesObjectStore.createIndex("byIndexEntry", "index_entries", {
+        multiEntry: true
+      });
       mutationsObjectStore.createIndex("timestamp", "timestamp", {
         unique: false
       });
@@ -49,93 +93,139 @@ 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
+import {
+  createUniqueConstraintConflictError
+} from "roc-db";
+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) => {
+  const request = objectStore.add(document);
+  return new Promise((resolve, reject) => {
+    request.onsuccess = (event) => {
+      resolve(document);
+    };
+    request.onerror = (event) => {
+      if (event?.target?.error?.name === "ConstraintError") {
+        reject(createUniqueConstraintConflictError(document.entity));
+      } else {
         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
+import { entityFromRef } from "roc-db";
+var commitDelete = async (txn, ref) => {
+  const entity = entityFromRef(ref);
+  let objectStore;
+  if (entity === "Mutation") {
+    objectStore = txn.engineOpts.txn.objectStore("mutations");
+  } else {
+    objectStore = txn.engineOpts.txn.objectStore("entities");
+  }
+  const request = objectStore.delete(ref);
   return new Promise((resolve, reject) => {
     request.onsuccess = () => {
       resolve(true);
     };
     request.onerror = (event) => {
-      console.error("Error patching document", event?.target?.error);
+      console.error("Error deleting document", event?.target?.error);
       reject(event?.target?.error);
     };
   });
 };
-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/lib/documentToDBRow.ts
+var stringifyIndexEntry = (entity, [k, v]) => `${entity}:${k}:${JSON.stringify(v)}`;
+var stringifyUniqueEntry = ([k, v]) => `${k}:${JSON.stringify(v)}`;
+var stringifyIndexEntries = (entity, arr) => {
+  return arr.map((pair) => stringifyIndexEntry(entity, pair));
+};
+var documentToDBRow = (document) => {
+  return {
+    ...document,
+    index_entries: document.__.index ? stringifyIndexEntries(document.entity, document.__.index) : [],
+    unique_constraint_0: document.__?.unique?.[0] ? stringifyUniqueEntry(document.__?.unique?.[0]) : null,
+    unique_constraint_1: document.__?.unique?.[1] ? stringifyUniqueEntry(document.__?.unique?.[1]) : null
+  };
+};
+
+// 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, documentToDBRow(doc));
+  }
+  for (const doc of updated) {
+    await commitUpdate(txn, documentToDBRow(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);
     };
   });
@@ -160,11 +250,10 @@ 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();
+  const timestamp = new Date(now - request.operation.debounce * 1000).toISOString();
   const range = IDBKeyRange.lowerBound(timestamp, true);
   const idbRequest = index.openCursor(range);
   return new Promise((resolve, reject) => {
@@ -173,7 +262,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();
@@ -190,89 +279,83 @@ 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);
+// src/functions/pageEntities.ts
+var pageEntities = async (txn, args) => {
+  const { size, entities, childrenOf } = args;
+  const objectStore = txn.engineOpts.txn.objectStore("entities");
+  const idbRequest = objectStore.openCursor();
   return new Promise((resolve, reject) => {
     const results = [];
     idbRequest.onsuccess = () => {
+      if (results.length >= size) {
+        resolve(results);
+        return;
+      }
       const cursor = idbRequest.result;
       if (cursor) {
-        results.push(cursor.value);
-        cursor.continue();
+        if (entities && entities !== "*" && !entities.includes(cursor.value.entity)) {
+          cursor.continue();
+        } else {
+          if (childrenOf && childrenOf.length > 0 && !childrenOf.some((childRef) => cursor.value.__.parentRefs.includes(childRef))) {
+            cursor.continue();
+          } else {
+            results.push(cursor.value);
+            cursor.continue();
+          }
+        }
       } else {
         resolve(results);
       }
     };
   });
 };
-// 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/pageEntitiesByIndex.ts
+var pageEntitiesByIndex = async (txn, entity, field, value) => {
   const objectStore = txn.engineOpts.txn.objectStore("entities");
-  const request = objectStore.get(ref);
+  const index = objectStore.index("byIndexEntry");
+  const entry = `${entity}:${field}:${JSON.stringify(value)}`;
+  const range = IDBKeyRange.only(entry);
+  const idbRequest = index.openCursor(range);
   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;
+// 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 {
-    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);
-      };
-    });
+    idbRequest = objectStore.openCursor();
   }
+  return new Promise((resolve, reject) => {
+    const results = [];
+    idbRequest.onsuccess = () => {
+      const cursor = idbRequest.result;
+      if (cursor) {
+        results.push(cursor.value);
+        cursor.continue();
+      } else {
+        resolve(results);
+      }
+    };
+  });
 };
 // 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) => {
@@ -285,66 +368,39 @@ 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);
-  }
+// src/functions/refByUniqueField.ts
+var refByUniqueField = async (txn, entity, field, fieldIndex, value) => {
+  const objectStore = txn.engineOpts.txn.objectStore("entities");
+  if (fieldIndex > 1)
+    throw new Error("Field index must be 0 or 1");
+  const index = objectStore.index(`unique_constraint_${fieldIndex}`);
+  const range = IDBKeyRange.only([
+    entity,
+    `${field}:${JSON.stringify(value)}`
+  ]);
+  const idbRequest = index.openCursor(range);
   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);
+    idbRequest.onsuccess = () => {
+      const cursor = idbRequest.result;
+      resolve(cursor?.value?.ref);
     };
   });
 };
-// 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

@@ -1,19 +1,8 @@
-export declare const createIndexedDBAdapter: ({ operations, entities, dbName, }: {
+import { type Adapter } from "roc-db";
+export declare const createIndexedDBAdapter: ({ operations, entities, session, dbName, optimistic, }: {
     operations: any;
     entities: any;
+    session: any;
     dbName?: string | undefined;
-}) => {
-    _name: string;
-    _engineOpts: EngineOptions;
-    _entityKinds: Entities[number]["shape"]["entity"]["value"];
-    _operationNames: Operations[number]["operationName"];
-    _operations: Operations;
-    _entites: Entities;
-    createRef: (entity: any) => string;
-    changeSet: (changeSetRef: any) => /*elided*/ any & {
-        [x: string]: any;
-    };
-    syncOptimisticMutation: (mutation: any) => any;
-} & {
-    [x: string]: any;
-};
+    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

@@ -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/{createEntity.d.ts → commitCreate.d.ts}

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

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

@@ -0,0 +1,2 @@
+import { type Ref, type WriteTransaction } from "roc-db";
+export declare const commitDelete: (txn: WriteTransaction, ref: Ref) => 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/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) => Promise<unknown>;
+export declare const findDebounceMutation: (request: WriteRequest, engine: IndexedDBEngine, now: number, mutationName: string) => Promise<unknown>;

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

@@ -1,12 +1,13 @@
+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 { pageEntities } from "./pageEntities";
+export { pageEntitiesByIndex } from "./pageEntitiesByIndex";
 export { pageMutations } from "./pageMutations";
-export { patchEntity } from "./patchEntity";
 export { readEntity } from "./readEntity";
 export { readMutation } from "./readMutation";
+export { refByUniqueField } from "./refByUniqueField";
 export { saveMutation } from "./saveMutation";
-export { updateEntity } from "./updateEntity";

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export declare const refByUniqueField: (txn: any, entity: any, field: any, fieldIndex: any, value: any) => Promise<unknown>;

package/dist/types/lib/documentFromDBRow.d.ts

@@ -0,0 +1,11 @@
+export declare const documentFromDBRow: ({ unique_constraint_0, unique_constraint_1, index_entries, ...document }: {
+    [x: string]: any;
+    unique_constraint_0: any;
+    unique_constraint_1: any;
+    index_entries: any;
+}) => {
+    __: {
+        uniqueExisting: never[];
+        indexExisting: never[];
+    };
+};

package/dist/types/lib/documentToDBRow.d.ts

@@ -0,0 +1 @@
+export declare const documentToDBRow: (document: any) => any;

package/package.json

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

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>;