@roc-db/indexed-db 0.1.0-pre.2

package/dist/index.js

@@ -0,0 +1,334 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/createIndexedDBAdapter.ts
+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,
+  getChangeSetMutations: () => getChangeSetMutations,
+  findDebounceMutation: () => findDebounceMutation,
+  end: () => end,
+  deleteEntity: () => deleteEntity,
+  createEntity: () => createEntity,
+  begin: () => begin
+});
+
+// src/functions/begin.ts
+var begin = async (request, engineOpts) => {
+  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" });
+      mutationsObjectStore.createIndex("timestamp", "timestamp", {
+        unique: false
+      });
+      mutationsObjectStore.createIndex("byChangeSetRef", "changeSetRef", {
+        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
+      });
+    };
+  });
+};
+// src/functions/createEntity.ts
+import { entityFromRef } from "roc-db";
+var createEntity = (txn, ref, { data = {}, children = {}, ancestors = {}, parents = {} }) => {
+  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);
+      };
+    });
+  }
+};
+// src/functions/deleteEntity.ts
+import { DELETED_IN_CHANGE_SET_SYMBOL } from "roc-db";
+var deleteIndexed = (store, ref) => {
+  const request = store.delete(ref);
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => {
+      resolve(true);
+    };
+    request.onerror = (event) => {
+      console.error("Error patching 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;
+  } else {
+    const objectStore = txn.engineOpts.txn.objectStore("entities");
+    await deleteIndexed(objectStore, ref);
+    if (cascade) {
+      throw new Error("TGOD");
+    }
+    return true;
+  }
+};
+// src/functions/end.ts
+var end = (txn) => {
+  return new Promise((resolve, reject) => {
+    txn.engineOpts.txn.oncomplete = () => {
+      resolve(undefined);
+    };
+    txn.engineOpts.txn.onerror = (event) => {
+      reject(event.target.error);
+    };
+  });
+};
+// src/functions/getChangeSetMutations.ts
+var getChangeSetMutations = async (txn, changeSetRef) => {
+  const objectStore = txn.engineOpts.txn.objectStore("mutations");
+  const index = objectStore.index("byChangeSetRef");
+  const range = IDBKeyRange.only(changeSetRef);
+  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/findDebounceMutation.ts
+var findDebounceMutation = async (request, engine, now) => {
+  const mutationName = request.schema.shape.name.value;
+  const objectStore = engine.txn.objectStore("mutations");
+  const index = objectStore.index("timestamp");
+  const timestamp = new Date(now - request.settings.debounce * 1000).toISOString();
+  const range = IDBKeyRange.lowerBound(timestamp, true);
+  const idbRequest = index.openCursor(range);
+  return new Promise((resolve, reject) => {
+    const results = [];
+    idbRequest.onsuccess = () => {
+      const cursor = idbRequest.result;
+      if (cursor) {
+        const doc = cursor.value;
+        if (doc.name === mutationName && doc.payload.ref === request.payload.ref && doc.changeSetRef === request.changeSetRef) {
+          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);
+        }
+      }
+    };
+  });
+};
+// 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;
+  }
+  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/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) => {
+  const objectStore = engineOpts.txn.objectStore("mutations");
+  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/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"
+}) => {
+  return createAdapter({
+    name: "indexed-db",
+    operations,
+    entities,
+    functions: exports_functions,
+    snowflake: new Snowflake(1, 1),
+    async: true
+  }, {
+    dbName,
+    version: 1
+  });
+};
+export {
+  createIndexedDBAdapter
+};

package/dist/types/createIndexedDBAdapter.d.ts

@@ -0,0 +1,18 @@
+export declare const createIndexedDBAdapter: ({ operations, entities, dbName, }: {
+    operations: any;
+    entities: any;
+    dbName?: string | undefined;
+}) => {
+    _name: string;
+    _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;
+};

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

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

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

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

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

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

@@ -0,0 +1,4 @@
+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) => 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,11 @@
+export { begin } from "./begin";
+export { createEntity } from "./createEntity";
+export { deleteEntity } from "./deleteEntity";
+export { end } from "./end";
+export { getChangeSetMutations } from "./getChangeSetMutations";
+export { findDebounceMutation } from "./findDebounceMutation";
+export { patchEntity } from "./patchEntity";
+export { readEntity } from "./readEntity";
+export { readMutation } from "./readMutation";
+export { saveMutation } from "./saveMutation";
+export { updateEntity } from "./updateEntity";

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

@@ -0,0 +1,7 @@
+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/readEntity.d.ts

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

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/functions/updateEntity.d.ts

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

@@ -0,0 +1,35 @@
+{
+    "name": "@roc-db/indexed-db",
+    "version": "0.1.0-pre.2",
+    "type": "module",
+    "exports": {
+        ".": "./src/index.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.1.0-pre.1",
+        "fake-indexeddb": "6.0.0",
+        "roc-db": "0.1.0-pre.1",
+        "zod": "3.24.2"
+    },
+    "peerDependencies": {
+        "roc-db": "0.1.0-pre.1",
+        "zod": "3.24.2"
+    },
+    "keywords": [],
+    "author": "Eigil Sagafos",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/eigilsagafos/roc-db.git"
+    },
+    "license": "MIT"
+}