@roc-db/indexed-db 0.2.0-pre.1 → 0.2.0-pre.100

package/dist/index.js

@@ -10,32 +10,83 @@ var __export = (target, all) => {
 };
 
 // src/createIndexedDBAdapter.ts
-import { createAdapter, Snowflake } from "roc-db";
+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/functions/begin.ts
-var begin = async (request, engineOpts) => {
+// 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) => {
-    let db;
-    const idbRequest = indexedDB.open(engineOpts.dbName, 1);
-    idbRequest.onupgradeneeded = (event) => {
+    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 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 });
+      entitiesObjectStore.createIndex("unique_constraint_1", ["entity", "unique_constraint_1"], { unique: true });
+      entitiesObjectStore.createIndex("byIndexEntry", "index_entries", {
+        multiEntry: true
+      });
       mutationsObjectStore.createIndex("timestamp", "timestamp", {
         unique: false
       });
@@ -43,104 +94,209 @@ var begin = async (request, engineOpts) => {
         unique: false
       });
     };
-    idbRequest.onsuccess = (event) => {
-      db = idbRequest.result;
-      resolve({
-        ...engineOpts,
-        db,
-        txn: db.transaction(["entities", "mutations"], request.type === "write" ? "readwrite" : "readonly"),
-        changeSet: request.changeSetRef ? {
-          entities: new Map([]),
-          mutations: new Map([])
-        } : null
-      });
+    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;
 };
-// src/functions/createEntity.ts
-import { entityFromRef } from "roc-db";
-var createEntity = (txn, ref, { data = {}, children = {}, ancestors = {}, parents = {} }) => {
+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 { createUniqueConstraintConflictError } from "roc-db";
+var commitCreate = (txn, document) => {
   const objectStore = txn.engineOpts.txn.objectStore("entities");
+  const request = objectStore.add(document);
+  return new Promise((resolve, reject) => {
+    request.onsuccess = (event) => {
+      resolve(document);
+    };
+    request.onerror = (event) => {
+      const error = event?.target?.error;
+      if (error?.name === "ConstraintError") {
+        event.stopPropagation();
+        event.preventDefault();
+        reject(createUniqueConstraintConflictError(document.entity));
+      } else {
+        console.error("Error creating entity:", document, error);
+        reject(error);
+      }
+    };
+  });
+};
+
+// src/functions/commitDelete.ts
+import { entityFromRef } from "roc-db";
+var commitDelete = async (txn, ref) => {
   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;
-    }
+  const engineTxn = txn.engineOpts.txn;
+  let objectStore;
+  if (entity === "Mutation") {
+    objectStore = engineTxn.objectStore("mutations");
   } 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);
-      };
-    });
+    objectStore = engineTxn.objectStore("entities");
   }
-};
-// src/functions/deleteEntity.ts
-import { DELETED_IN_CHANGE_SET_SYMBOL } from "roc-db";
-var deleteIndexed = (store, ref) => {
-  const request = store.delete(ref);
+  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 = (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);
     };
   });
 };
 // src/functions/getChangeSetMutations.ts
-var getChangeSetMutations = async (txn, changeSetRef) => {
+var getChangeSetMutations = (txn, changeSetRef) => {
   const objectStore = txn.engineOpts.txn.objectStore("mutations");
   const index = objectStore.index("byChangeSetRef");
   const range = IDBKeyRange.only(changeSetRef);
@@ -159,11 +315,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 = (request, engine, now, mutationName, identityRef) => {
   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.getTime() - request.operation.debounce * 1000).toISOString();
   const range = IDBKeyRange.lowerBound(timestamp, true);
   const idbRequest = index.openCursor(range);
   return new Promise((resolve, reject) => {
@@ -172,81 +327,97 @@ 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 && 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/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/pageEntities.ts
+var pageEntities = async (txn, args) => {
+  const { size, entities, childrenOf } = args;
   const objectStore = txn.engineOpts.txn.objectStore("entities");
-  const request = objectStore.get(ref);
+  const idbRequest = objectStore.openCursor();
   return new Promise((resolve, reject) => {
-    request.onsuccess = (event) => {
-      const document = event.target.result;
-      resolve(document);
+    const results = [];
+    idbRequest.onsuccess = () => {
+      if (results.length >= size) {
+        resolve(results);
+        return;
+      }
+      const cursor = idbRequest.result;
+      if (cursor) {
+        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);
+      }
     };
-    request.onerror = (event) => {
-      reject(event.target.error);
+  });
+};
+// src/functions/pageEntitiesByIndex.ts
+var pageEntitiesByIndex = async (txn, entity, field, value) => {
+  const objectStore = txn.engineOpts.txn.objectStore("entities");
+  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) => {
+    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) => {
@@ -262,67 +433,41 @@ 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 = (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,
+  snowflake = new Snowflake(1, 1)
 }) => {
   return createAdapter({
     name: "indexed-db",
     operations,
     entities,
     functions: exports_functions,
-    snowflake: new Snowflake(1, 1),
+    optimistic,
+    session,
+    snowflake,
     async: true
   }, {
     dbName,

package/dist/types/createIndexedDBAdapter.d.ts

@@ -0,0 +1,12 @@
+import { Snowflake, type Adapter, type Entity, type Operation } from "roc-db";
+export declare const createIndexedDBAdapter: ({ operations, entities, session, dbName, optimistic, snowflake, }: {
+    operations: readonly Operation[];
+    entities: readonly Entity<any>[];
+    session: {
+        identityRef: string;
+        sessionRef?: string;
+    };
+    dbName?: string;
+    optimistic?: boolean;
+    snowflake?: Snowflake;
+}) => Adapter;

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { WriteTransaction } from "roc-db";
+import type { IndexedDBEngine } from "../types/IndexedDBEngine";
+export declare const commitCreate: (txn: WriteTransaction<IndexedDBEngine>, document: any) => Promise<unknown>;

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

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

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

@@ -0,0 +1,3 @@
+import type { WriteTransaction } from "roc-db";
+import type { IndexedDBEngine } from "../types/IndexedDBEngine";
+export declare const commitUpdate: (txn: WriteTransaction<IndexedDBEngine>, document: any) => Promise<unknown>;

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

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

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

@@ -0,0 +1,2 @@
+import type { FindDebounceMutationFunction } from "roc-db";
+export declare const findDebounceMutation: FindDebounceMutationFunction;

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

@@ -0,0 +1,2 @@
+import type { GetChangeSetMutationsFunction } from "roc-db";
+export declare const getChangeSetMutations: GetChangeSetMutationsFunction;

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

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

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

@@ -0,0 +1,2 @@
+import type { PageEntitiesFunction } from "roc-db";
+export declare const pageEntities: PageEntitiesFunction;

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

@@ -0,0 +1,2 @@
+import type { PageEntitiesByIndexFunction } from "roc-db";
+export declare const pageEntitiesByIndex: PageEntitiesByIndexFunction;

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

@@ -0,0 +1,2 @@
+import type { PageMutationsFunction } from "roc-db";
+export declare const pageMutations: PageMutationsFunction;

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

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

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

@@ -0,0 +1,2 @@
+import type { ReadMutationFunction } from "roc-db";
+export declare const readMutation: ReadMutationFunction;

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

@@ -0,0 +1,2 @@
+import type { RefByUniqueFieldFunction } from "roc-db";
+export declare const refByUniqueField: RefByUniqueFieldFunction;

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

@@ -0,0 +1,2 @@
+import type { SaveMutationFunction } from "roc-db";
+export declare const saveMutation: SaveMutationFunction;

package/dist/types/index.d.ts

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

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

@@ -0,0 +1 @@
+export declare const documentFromDBRow: ({ unique_constraint_0, unique_constraint_1, index_entries, ...document }: any) => any;

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

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

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

@@ -0,0 +1,10 @@
+export type IndexedDBEngine = {
+    dbName: string;
+    version?: number;
+    db?: IDBDatabase;
+    txn?: IDBTransaction;
+};
+export type IndexedDBTxnEngine = IndexedDBEngine & {
+    db: IDBDatabase;
+    txn: IDBTransaction;
+};

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

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

package/dist/types/types/IndexedDBWriteTransaction.d.ts

@@ -0,0 +1,3 @@
+import type { IndexedDBEngine } from "./IndexedDBEngine";
+import type { WriteTransaction } from "roc-db";
+export type IndexedDBWriteTransaction = WriteTransaction<IndexedDBEngine>;

package/package.json

@@ -1,29 +1,21 @@
 {
     "name": "@roc-db/indexed-db",
-    "version": "0.2.0-pre.1",
+    "version": "0.2.0-pre.100",
     "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.1",
-        "fake-indexeddb": "6.0.0",
-        "roc-db": "0.2.0-pre.1",
-        "zod": "3.24.2"
-    },
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.1",
-        "zod": "3.24.2"
+        "roc-db": ">=0.2.0-pre.98 <1.0.0",
+        "zod": ">=4.0.0"
     },
     "keywords": [],
     "author": "Eigil Sagafos",
@@ -31,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/"
+    }
 }