cojson-storage-indexeddb 0.8.34 → 0.8.36

package/dist/tests/{index.test.js → idbNode.test.js}

@@ -3,14 +3,14 @@ import { ControlledAgent, LocalNode, WasmCrypto } from "cojson";
 import { expect, test } from "vitest";
 import { IDBStorage } from "../index.js";
 const Crypto = await WasmCrypto.create();
-test.skip("Should be able to initialize and load from empty DB", async () => {
+test("Should be able to initialize and load from empty DB", async () => {
     const agentSecret = Crypto.newRandomAgentSecret();
     const node = new LocalNode(new ControlledAgent(agentSecret, Crypto), Crypto.newRandomSessionID(Crypto.getAgentID(agentSecret)), Crypto);
     node.syncManager.addPeer(await IDBStorage.asPeer({ trace: true }));
     console.log("yay!");
     const _group = node.createGroup();
     await new Promise((resolve) => setTimeout(resolve, 200));
-    expect(node.syncManager.peers["storage"]).toBeDefined();
+    expect(node.syncManager.peers["indexedDB"]).toBeDefined();
 });
 test("Should be able to sync data to database and then load that from a new node", async () => {
     const agentSecret = Crypto.newRandomAgentSecret();
@@ -29,4 +29,4 @@ test("Should be able to sync data to database and then load that from a new node
     }
     expect(map2.get("hello")).toBe("world");
 });
-//# sourceMappingURL=index.test.js.map
+//# sourceMappingURL=idbNode.test.js.map

package/dist/tests/idbNode.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idbNode.test.js","sourceRoot":"","sources":["../../src/tests/idbNode.test.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "cojson-storage-indexeddb",
-  "version": "0.8.34",
+  "version": "0.8.36",
   "main": "dist/index.js",
   "type": "module",
   "types": "src/index.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "0.8.34"
+    "cojson": "0.8.36",
+    "cojson-storage": "0.8.36"
   },
   "devDependencies": {
     "@vitest/browser": "^0.34.1",

package/src/idbClient.ts

@@ -0,0 +1,224 @@
+import { CojsonInternalTypes } from "cojson";
+import { SyncPromise } from "./syncPromises";
+import RawCoID = CojsonInternalTypes.RawCoID;
+import Transaction = CojsonInternalTypes.Transaction;
+import Signature = CojsonInternalTypes.Signature;
+import {
+  CoValueRow,
+  DBClientInterface,
+  SessionRow,
+  SignatureAfterRow,
+  StoredCoValueRow,
+  StoredSessionRow,
+  TransactionRow,
+} from "cojson-storage";
+
+export class IDBClient implements DBClientInterface {
+  private db;
+
+  currentTx:
+    | {
+        id: number;
+        tx: IDBTransaction;
+        stores: {
+          coValues: IDBObjectStore;
+          sessions: IDBObjectStore;
+          transactions: IDBObjectStore;
+          signatureAfter: IDBObjectStore;
+        };
+        startedAt: number;
+        pendingRequests: ((txEntry: {
+          stores: {
+            coValues: IDBObjectStore;
+            sessions: IDBObjectStore;
+            transactions: IDBObjectStore;
+            signatureAfter: IDBObjectStore;
+          };
+        }) => void)[];
+      }
+    | undefined;
+
+  currentTxID = 0;
+
+  constructor(db: IDBDatabase) {
+    this.db = db;
+  }
+
+  makeRequest<T>(
+    handler: (stores: {
+      coValues: IDBObjectStore;
+      sessions: IDBObjectStore;
+      transactions: IDBObjectStore;
+      signatureAfter: IDBObjectStore;
+    }) => IDBRequest,
+  ): SyncPromise<T> {
+    return new SyncPromise((resolve, reject) => {
+      let txEntry = this.currentTx;
+
+      const requestEntry = ({
+        stores,
+      }: {
+        stores: {
+          coValues: IDBObjectStore;
+          sessions: IDBObjectStore;
+          transactions: IDBObjectStore;
+          signatureAfter: IDBObjectStore;
+        };
+      }) => {
+        const request = handler(stores);
+        request.onerror = () => {
+          console.error("Error in request", request.error);
+          this.currentTx = undefined;
+          reject(request.error);
+        };
+        request.onsuccess = () => {
+          const value = request.result as T;
+          resolve(value);
+
+          const next = txEntry!.pendingRequests.shift();
+
+          if (next) {
+            next({ stores });
+          } else {
+            if (this.currentTx === txEntry) {
+              this.currentTx = undefined;
+            }
+          }
+        };
+      };
+
+      // Transaction batching
+      if (!txEntry || performance.now() - txEntry.startedAt > 20) {
+        const tx = this.db.transaction(
+          ["coValues", "sessions", "transactions", "signatureAfter"],
+          "readwrite",
+        );
+        txEntry = {
+          id: this.currentTxID++,
+          tx,
+          stores: {
+            coValues: tx.objectStore("coValues"),
+            sessions: tx.objectStore("sessions"),
+            transactions: tx.objectStore("transactions"),
+            signatureAfter: tx.objectStore("signatureAfter"),
+          },
+          startedAt: performance.now(),
+          pendingRequests: [],
+        };
+
+        this.currentTx = txEntry;
+
+        requestEntry(txEntry);
+      } else {
+        txEntry.pendingRequests.push(requestEntry);
+      }
+    });
+  }
+
+  async getCoValue(coValueId: RawCoID): Promise<StoredCoValueRow | undefined> {
+    return this.makeRequest<StoredCoValueRow | undefined>(({ coValues }) =>
+      coValues.index("coValuesById").get(coValueId),
+    );
+  }
+
+  async getCoValueSessions(coValueRowId: number): Promise<StoredSessionRow[]> {
+    return this.makeRequest<StoredSessionRow[]>(({ sessions }) =>
+      sessions.index("sessionsByCoValue").getAll(coValueRowId),
+    );
+  }
+
+  async getNewTransactionInSession(
+    sessionRowId: number,
+    firstNewTxIdx: number,
+  ): Promise<TransactionRow[]> {
+    return this.makeRequest<TransactionRow[]>(({ transactions }) =>
+      transactions.getAll(
+        IDBKeyRange.bound(
+          [sessionRowId, firstNewTxIdx],
+          [sessionRowId, Infinity],
+        ),
+      ),
+    );
+  }
+
+  async getSignatures(
+    sessionRowId: number,
+    firstNewTxIdx: number,
+  ): Promise<SignatureAfterRow[]> {
+    return this.makeRequest<SignatureAfterRow[]>(
+      ({ signatureAfter }: { signatureAfter: IDBObjectStore }) =>
+        signatureAfter.getAll(
+          IDBKeyRange.bound(
+            [sessionRowId, firstNewTxIdx],
+            [sessionRowId, Infinity],
+          ),
+        ),
+    );
+  }
+
+  async addCoValue(
+    msg: CojsonInternalTypes.NewContentMessage,
+  ): Promise<number> {
+    if (!msg.header) {
+      throw new Error("Header is required, coId: " + msg.id);
+    }
+
+    return (await this.makeRequest<IDBValidKey>(({ coValues }) =>
+      coValues.put({
+        id: msg.id,
+        header: msg.header!,
+      } satisfies CoValueRow),
+    )) as number;
+  }
+
+  async addSessionUpdate({
+    sessionUpdate,
+    sessionRow,
+  }: {
+    sessionUpdate: SessionRow;
+    sessionRow?: StoredSessionRow;
+  }): Promise<number> {
+    return this.makeRequest<number>(({ sessions }) =>
+      sessions.put(
+        sessionRow?.rowID
+          ? {
+              rowID: sessionRow.rowID,
+              ...sessionUpdate,
+            }
+          : sessionUpdate,
+      ),
+    );
+  }
+
+  addTransaction(
+    sessionRowID: number,
+    idx: number,
+    newTransaction: Transaction,
+  ) {
+    return this.makeRequest(({ transactions }) =>
+      transactions.add({
+        ses: sessionRowID,
+        idx,
+        tx: newTransaction,
+      } satisfies TransactionRow),
+    );
+  }
+
+  async addSignatureAfter({
+    sessionRowID,
+    idx,
+    signature,
+  }: { sessionRowID: number; idx: number; signature: Signature }) {
+    return this.makeRequest(({ signatureAfter }) =>
+      signatureAfter.put({
+        ses: sessionRowID,
+        idx,
+        signature,
+      } satisfies SignatureAfterRow),
+    );
+  }
+
+  async unitOfWork(operationsCallback: () => unknown[]) {
+    return Promise.all(operationsCallback());
+  }
+}

package/src/idbNode.ts

@@ -0,0 +1,123 @@
+import {
+  IncomingSyncStream,
+  OutgoingSyncQueue,
+  Peer,
+  cojsonInternals,
+} from "cojson";
+import { SyncManager } from "cojson-storage";
+import { IDBClient } from "./idbClient.js";
+
+export class IDBNode {
+  private readonly dbClient: IDBClient;
+  private readonly syncManager: SyncManager;
+
+  constructor(
+    db: IDBDatabase,
+    fromLocalNode: IncomingSyncStream,
+    toLocalNode: OutgoingSyncQueue,
+  ) {
+    this.dbClient = new IDBClient(db);
+    this.syncManager = new SyncManager(this.dbClient, toLocalNode);
+
+    const processMessages = async () => {
+      for await (const msg of fromLocalNode) {
+        try {
+          if (msg === "Disconnected" || msg === "PingTimeout") {
+            throw new Error("Unexpected Disconnected message");
+          }
+          await this.syncManager.handleSyncMessage(msg);
+        } catch (e) {
+          console.error(
+            new Error(
+              `Error reading from localNode, handling msg\n\n${JSON.stringify(
+                msg,
+                (k, v) =>
+                  k === "changes" || k === "encryptedChanges"
+                    ? v.slice(0, 20) + "..."
+                    : v,
+              )}`,
+              { cause: e },
+            ),
+          );
+        }
+      }
+    };
+
+    processMessages().catch((e) =>
+      console.error("Error in processMessages in IndexedDB", e),
+    );
+  }
+
+  static async asPeer(
+    {
+      trace,
+      localNodeName = "local",
+    }: { trace?: boolean; localNodeName?: string } | undefined = {
+      localNodeName: "local",
+    },
+  ): Promise<Peer> {
+    const [localNodeAsPeer, storageAsPeer] = cojsonInternals.connectedPeers(
+      localNodeName,
+      "indexedDB",
+      {
+        peer1role: "client",
+        peer2role: "storage",
+        trace,
+        crashOnClose: true,
+      },
+    );
+
+    await IDBNode.open(localNodeAsPeer.incoming, localNodeAsPeer.outgoing);
+
+    return { ...storageAsPeer, priority: 100 };
+  }
+
+  static async open(
+    fromLocalNode: IncomingSyncStream,
+    toLocalNode: OutgoingSyncQueue,
+  ) {
+    const dbPromise = new Promise<IDBDatabase>((resolve, reject) => {
+      const request = indexedDB.open("jazz-storage", 4);
+      request.onerror = () => {
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onupgradeneeded = async (ev) => {
+        const db = request.result;
+        if (ev.oldVersion === 0) {
+          const coValues = db.createObjectStore("coValues", {
+            autoIncrement: true,
+            keyPath: "rowID",
+          });
+
+          coValues.createIndex("coValuesById", "id", {
+            unique: true,
+          });
+
+          const sessions = db.createObjectStore("sessions", {
+            autoIncrement: true,
+            keyPath: "rowID",
+          });
+
+          sessions.createIndex("sessionsByCoValue", "coValue");
+          sessions.createIndex("uniqueSessions", ["coValue", "sessionID"], {
+            unique: true,
+          });
+
+          db.createObjectStore("transactions", {
+            keyPath: ["ses", "idx"],
+          });
+        }
+        if (ev.oldVersion <= 1) {
+          db.createObjectStore("signatureAfter", {
+            keyPath: ["ses", "idx"],
+          });
+        }
+      };
+    });
+
+    return new IDBNode(await dbPromise, fromLocalNode, toLocalNode);
+  }
+}