@fireproof/core 0.14.8 → 0.15.0-dev

package/dist/node/fireproof.esm.js

@@ -20977,7 +20977,7 @@ import { homedir } from "os";
 import { mkdir, readFile, writeFile, unlink } from "fs/promises";
 
 // src/version.ts
-var PACKAGE_VERSION = "0.14.8";
+var PACKAGE_VERSION = "0.15.0-dev";
 
 // src/store.ts
 var match = PACKAGE_VERSION.match(/^([^.]*\.[^.]*)/);
@@ -21005,9 +21005,9 @@ var MetaStore = class extends VersionedStore {
 var DataStore = class {
   tag = "car-base";
   STORAGE_VERSION = STORAGE_VERSION;
-  loader;
-  constructor(loader) {
-    this.loader = loader;
+  name;
+  constructor(name8) {
+    this.name = name8;
   }
 };
 
@@ -21214,7 +21214,7 @@ var DataStore2 = class _DataStore extends DataStore {
     await writePathFile(filepath, car.bytes);
   }
   cidPath(cid) {
-    return join(_DataStore.dataDir, this.loader.name, "data", cid.toString() + ".car");
+    return join(_DataStore.dataDir, this.name, "data", cid.toString() + ".car");
   }
   async load(cid) {
     const filepath = this.cidPath(cid);
@@ -21272,7 +21272,7 @@ var Loader = class {
     this.name = name8;
     this.opts = opts || this.opts;
     this.metaStore = new MetaStore2(this.name);
-    this.carStore = new DataStore2(this);
+    this.carStore = new DataStore2(this.name);
     this.remoteWAL = new RemoteWAL2(this);
     this.ready = Promise.resolve().then(async () => {
       if (!this.metaStore || !this.carStore || !this.remoteWAL)
@@ -30337,7 +30337,7 @@ var DbLoader = class _DbLoader extends Loader {
   fileStore;
   constructor(name8, clock, opts) {
     super(name8, opts);
-    this.fileStore = new DataStore2(this);
+    this.fileStore = new DataStore2(this.name);
     this.clock = clock;
   }
   async _readyForMerge() {
@@ -30542,7 +30542,7 @@ function applyHeadQueue(worker) {
         const task = queue.shift();
         if (!task)
           continue;
-        await worker(task.id, task.newHead, task.prevHead, task.updates);
+        await worker(task.newHead, task.prevHead);
         if (task.updates) {
           allUpdates.push(...task.updates);
         }
@@ -30571,7 +30571,7 @@ function applyHeadQueue(worker) {
 
 // src/crdt-clock.ts
 var CRDTClock = class {
-  // todo: keep the clock of remote and local changes separate, merge on read
+  // todo: track local and remote clocks independently, merge on read
   // that way we can drop the whole remote if we need to
   // should go with making sure the local clock only references locally available blocks on write
   head = [];
@@ -30587,68 +30587,22 @@ var CRDTClock = class {
     this.head = head;
   }
   async applyHead(newHead, prevHead, updates = null) {
-    const taskId = Math.random().toString().slice(2, 8);
     for await (const { updates: updatesAcc, all } of this.applyHeadQueue.push({
-      id: taskId,
-      // tblocks,
       newHead,
       prevHead,
       updates
     })) {
-      ;
-      ((updatesAcc2, all2) => {
-        void Promise.resolve().then(async () => {
-          let intUpdates = updatesAcc2;
-          if (this.watchers.size && !all2) {
-            const changes = await clockChangesSince(this.blocks, this.head, prevHead, {});
-            intUpdates = changes.result;
-          }
-          this.zoomers.forEach((fn) => fn());
-          this.notifyWatchers(intUpdates || []);
-        });
-      })([...updatesAcc], all);
+      this.processUpdates(updatesAcc, all, prevHead);
     }
   }
-  async int_applyHead(taskId, newHead, prevHead) {
-    const ogHead = this.head.sort((a, b) => a.toString().localeCompare(b.toString()));
-    newHead = newHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-    newHead.map(async (cid) => {
-      const got = await this.blocks.get(cid);
-      if (!got) {
-        throw new Error("int_applyHead missing block: " + cid.toString());
-      }
-    });
-    if (ogHead.toString() === newHead.toString()) {
-      return;
-    }
-    const ogPrev = prevHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-    if (ogHead.toString() === ogPrev.toString()) {
-      this.setHead(newHead);
-      return;
+  async processUpdates(updatesAcc, all, prevHead) {
+    let internalUpdates = updatesAcc;
+    if (this.watchers.size && !all) {
+      const changes = await clockChangesSince(this.blocks, this.head, prevHead, {});
+      internalUpdates = changes.result;
     }
-    let head = this.head;
-    const noLoader = false;
-    const withBlocks = async (fn) => {
-      if (!this.blocks)
-        throw new Error("missing blocks");
-      return await this.blocks.transaction(fn, void 0, { noLoader });
-    };
-    await withBlocks(async (tblocks) => {
-      for (const cid of newHead) {
-        try {
-          head = await advance(tblocks, head, cid);
-        } catch (e) {
-          console.error("failed to advance", cid.toString(), e);
-          continue;
-        }
-      }
-      const result = await root(tblocks, head);
-      for (const { cid, bytes } of [...result.additions, ...result.removals]) {
-        tblocks.putSync(cid, bytes);
-      }
-      return { head };
-    });
-    this.setHead(head);
+    this.zoomers.forEach((fn) => fn());
+    this.notifyWatchers(internalUpdates || []);
   }
   notifyWatchers(updates) {
     this.emptyWatchers.forEach((fn) => fn());
@@ -30663,7 +30617,62 @@ var CRDTClock = class {
   onZoom(fn) {
     this.zoomers.add(fn);
   }
+  async int_applyHead(newHead, prevHead) {
+    const ogHead = sortClockHead(this.head);
+    newHead = sortClockHead(newHead);
+    await validateBlocks(newHead, this.blocks);
+    if (compareClockHeads(ogHead, newHead)) {
+      return;
+    }
+    const ogPrev = sortClockHead(prevHead);
+    if (compareClockHeads(ogHead, ogPrev)) {
+      this.setHead(newHead);
+      return;
+    }
+    let head = this.head;
+    const noLoader = false;
+    if (!this.blocks)
+      throw new Error("missing blocks");
+    await this.blocks.transaction(
+      async (tblocks) => {
+        head = await advanceBlocks(newHead, tblocks, head);
+        const result = await root(tblocks, head);
+        for (const { cid, bytes } of [...result.additions, ...result.removals]) {
+          tblocks.putSync(cid, bytes);
+        }
+        return { head };
+      },
+      void 0,
+      { noLoader }
+    );
+    this.setHead(head);
+  }
 };
+function sortClockHead(clockHead) {
+  return clockHead.sort((a, b) => a.toString().localeCompare(b.toString()));
+}
+async function validateBlocks(newHead, blocks) {
+  newHead.map(async (cid) => {
+    const got = await blocks.get(cid);
+    if (!got) {
+      throw new Error("int_applyHead missing block: " + cid.toString());
+    }
+  });
+}
+function compareClockHeads(head1, head2) {
+  return head1.toString() === head2.toString();
+}
+async function advanceBlocks(newHead, tblocks, head) {
+  for (const cid of newHead) {
+    try {
+      head = await advance(tblocks, head, cid);
+    } catch (e) {
+      console.error("failed to advance", cid.toString(), e);
+      continue;
+    }
+  }
+  return head;
+}
 
 // src/crdt.ts
 var CRDT = class {
@@ -30838,6 +30847,9 @@ var Database = class {
     }));
     return { rows, clock: head };
   }
+  async allDocuments() {
+    return this.allDocs();
+  }
   subscribe(listener, updates) {
     if (updates) {
       if (!this._listening) {