@fireproof/core 0.19.0-dev-publish → 0.19.0-dev-global

package/tests/fireproof/config.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { fireproof, rt } from "@fireproof/core";
+import { isNode } from "std-env";
+
+describe("fireproof/config", () => {
+  let _my_app = "my-app";
+  function my_app() {
+    return _my_app;
+  }
+  beforeAll(async () => {
+    await rt.SysContainer.start();
+    if (isNode) {
+      const fpStorageUrl = rt.SysContainer.env.get("FP_STORAGE_URL");
+      if (fpStorageUrl) {
+        let url: URL;
+        try {
+          url = new URL(fpStorageUrl);
+        } catch (e) {
+          url = new URL(`file://${fpStorageUrl}`);
+        }
+        _my_app = `my-app-${url.protocol.replace(/:$/, "")}`;
+      }
+    }
+  });
+
+  if (!isNode) {
+    it("default", async () => {
+      const db = fireproof(my_app());
+      await db.put({ name: "my-app" });
+      expect(db.name).toBe(my_app());
+      const carStore = await db.blockstore.loader?.carStore();
+      expect(carStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=data&version=${rt.INDEXDB_VERSION}`));
+      const fileStore = await db.blockstore.loader?.fileStore();
+      expect(fileStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=data&version=${rt.INDEXDB_VERSION}`));
+      const metaStore = await db.blockstore.loader?.metaStore();
+      expect(metaStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=meta&version=${rt.INDEXDB_VERSION}`));
+      await db.close();
+    });
+    return;
+  }
+  it("node default", async () => {
+    const old = rt.SysContainer.env.get("FP_STORAGE_URL");
+    rt.SysContainer.env.del("FP_STORAGE_URL");
+    let baseDir = rt
+      .dataDir(my_app())
+      .replace(/\?.*$/, "")
+      .replace(/^file:\/\//, "");
+    baseDir = rt.SysContainer.join(baseDir, rt.FILESTORE_VERSION, my_app());
+    await rt.SysContainer.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    expect(baseDir).toMatch(new RegExp(`/\\.fireproof/${rt.FILESTORE_VERSION}/${my_app()}`));
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`file:.*\\/\\.fireproof\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`file:.*\\/\\.fireproof\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`file:.*\\/\\.fireproof\\?name=${my_app()}&store=meta&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    rt.SysContainer.env.set("FP_STORAGE_URL", old);
+    await db.close();
+  });
+
+  it("set by env", async () => {
+    const old = rt.SysContainer.env.get("FP_STORAGE_URL");
+    rt.SysContainer.env.set("FP_STORAGE_URL", "./dist/env");
+
+    let baseDir = rt
+      .dataDir(my_app())
+      .replace(/\?.*$/, "")
+      .replace(/^file:\/\//, "");
+    baseDir = rt.SysContainer.join(baseDir, rt.FILESTORE_VERSION, my_app());
+    await rt.SysContainer.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`file://\\./dist/env\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`file://\\./dist/env\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`file://\\./dist/env\\?name=${my_app()}&store=meta&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+    rt.SysContainer.env.set("FP_STORAGE_URL", old);
+  });
+
+  it("file path", async () => {
+    let baseDir = "./dist/data".replace(/\?.*$/, "").replace(/^file:\/\//, "");
+    baseDir = rt.SysContainer.join(baseDir, rt.FILESTORE_VERSION, my_app());
+    await rt.SysContainer.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), {
+      store: {
+        stores: {
+          base: "./dist/data",
+        },
+      },
+    });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`file://.\\/dist\\/data\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`file://.\\/dist\\/data\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`file://.\\/dist\\/data\\?name=${my_app()}&store=meta&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+  });
+
+  it("sqlite path", async () => {
+    let dbFile = "sqlite://./dist/sqlite".replace(/\?.*$/, "").replace(/^sqlite:\/\//, "");
+    dbFile = rt.SysContainer.join(dbFile, `${my_app()}.sqlite`);
+    await rt.SysContainer.rm(dbFile, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), {
+      store: {
+        stores: {
+          base: "sqlite://./dist/sqlite",
+        },
+      },
+    });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect((await rt.SysContainer.stat(dbFile)).isFile()).toBeTruthy();
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite\\?name=${my_app()}&store=meta&version=${rt.SQLITE_VERSION}`),
+    );
+    await db.close();
+  });
+
+  it("full config path", async () => {
+    const db = fireproof(my_app(), {
+      store: {
+        stores: {
+          base: "sqlite://./dist/sqlite",
+
+          meta: "sqlite://./dist/sqlite/meta",
+          data: "sqlite://./dist/sqlite/data",
+          index: "sqlite://./dist/sqlite/index",
+          remoteWAL: "sqlite://./dist/sqlite/wal",
+        },
+      },
+    });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: my_app() });
+    expect(db.name).toBe(my_app());
+
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      // sqlite://./dist/sqlite/data?store=data&version=v0.19-sqlite
+      new RegExp(`sqlite://./dist/sqlite/data\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite/data\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite/meta\\?name=${my_app()}&store=meta&version=${rt.SQLITE_VERSION}`),
+    );
+    await db.close();
+  });
+});

package/tests/fireproof/crdt.test.ts

@@ -0,0 +1,434 @@
+import { itSkip } from "../helpers.js";
+
+import { uuidv4 } from "uuidv7";
+
+import { CRDT } from "@fireproof/core";
+import { bs, rt } from "@fireproof/core";
+import { CRDTMeta, DocValue } from "@fireproof/core";
+import { Index, index } from "@fireproof/core";
+
+describe("Fresh crdt", function () {
+  let crdt: CRDT<{ hello: string } | { points: number }>;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT();
+  });
+  it("should have an empty head", async function () {
+    const head = crdt.clock.head;
+    expect(head.length).toBe(0);
+  });
+  it("should accept put and return results", async function () {
+    const didPut = await crdt.bulk([{ id: "hello", value: { hello: "world" } }]);
+    const head = didPut.head;
+    expect(head.length).toBe(1);
+  });
+  it("should accept multi-put and return results", async function () {
+    const didPut = await crdt.bulk([
+      { id: "ace", value: { points: 11 } },
+      { id: "king", value: { points: 10 } },
+    ]);
+    const head = didPut.head;
+    expect(head.length).toBe(1);
+  });
+});
+
+describe("CRDT with one record", function () {
+  interface CRDTTestType {
+    readonly hello: string;
+    readonly nice: string;
+  }
+  let crdt: CRDT<Partial<CRDTTestType>>;
+  let firstPut: CRDTMeta;
+
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT(`test@${uuidv4()}`);
+    firstPut = await crdt.bulk([{ id: "hello", value: { hello: "world" } }]);
+  });
+  it("should have a one-element head", async function () {
+    const head = crdt.clock.head;
+    expect(head.length).toBe(1);
+  });
+  it("should return the head", async function () {
+    expect(firstPut.head.length).toBe(1);
+  });
+  it("return the record on get", async function () {
+    const got = (await crdt.get("hello")) as DocValue<CRDTTestType>;
+    expect(got).toBeTruthy();
+    expect(got.doc.hello).toBe("world");
+  });
+  it("should accept another put and return results", async function () {
+    const didPut = await crdt.bulk([{ id: "nice", value: { nice: "data" } }]);
+    const head = didPut.head;
+    expect(head.length).toBe(1);
+    const { doc } = (await crdt.get("nice")) as DocValue<CRDTTestType>;
+    expect(doc.nice).toBe("data");
+  });
+  it("should allow for a delete", async function () {
+    const didDel = await crdt.bulk([{ id: "hello", del: true }]);
+    expect(didDel.head).toBeTruthy();
+    const got = await crdt.get("hello");
+    expect(got).toBeFalsy();
+  });
+  it("should offer changes", async function () {
+    const { result } = await crdt.changes([]);
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe("hello");
+    expect(result[0].value?.hello).toBe("world");
+  });
+});
+
+describe("CRDT with a multi-write", function () {
+  interface CRDTTestType {
+    readonly points: number;
+  }
+  let crdt: CRDT<CRDTTestType>;
+  let firstPut: CRDTMeta;
+
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT();
+    firstPut = await crdt.bulk([
+      { id: "ace", value: { points: 11 } },
+      { id: "king", value: { points: 10 } },
+    ]);
+  });
+  it("should have a one-element head", async function () {
+    const head = crdt.clock.head;
+    expect(head.length).toBe(1);
+    expect(firstPut.head.length).toBe(1);
+  });
+  it("return the records on get", async function () {
+    const { doc } = (await crdt.get("ace")) as DocValue<CRDTTestType>;
+    expect(doc.points).toBe(11);
+
+    const got2 = (await crdt.get("king")) as DocValue<CRDTTestType>;
+    expect(got2).toBeTruthy();
+    expect(got2.doc.points).toBe(10);
+  });
+  it("should accept another put and return results", async function () {
+    const didPut = await crdt.bulk([{ id: "queen", value: { points: 10 } }]);
+    const head = didPut.head;
+    expect(head.length).toBe(1);
+    const got = (await crdt.get("queen")) as DocValue<CRDTTestType>;
+    expect(got).toBeTruthy();
+    expect(got.doc.points).toBe(10);
+  });
+  it("should offer changes", async function () {
+    const { result } = await crdt.changes([]);
+    expect(result.length).toBe(2);
+    expect(result[0].id).toBe("ace");
+    expect(result[0].value?.points).toBe(11);
+    expect(result[1].id).toBe("king");
+  });
+  it("should offer changes since", async function () {
+    /** @type {CRDTMeta} */
+    const secondPut = await crdt.bulk([
+      { id: "queen", value: { points: 10 } },
+      { id: "jack", value: { points: 10 } },
+    ]);
+    expect(secondPut.head).toBeTruthy();
+    const { result: r2, head: h2 } = await crdt.changes();
+    expect(r2.length).toBe(4);
+    const { result: r3 } = await crdt.changes(firstPut.head);
+    expect(r3.length).toBe(2);
+    const { result: r4 } = await crdt.changes(h2);
+    expect(r4.length).toBe(0);
+  });
+});
+
+interface CRDTTestType {
+  readonly points: number;
+}
+describe("CRDT with two multi-writes", function () {
+  /** @type {CRDT} */
+  let crdt: CRDT<CRDTTestType>;
+  let firstPut: CRDTMeta;
+  let secondPut: CRDTMeta;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async () => {
+    await rt.SysContainer.start();
+    crdt = new CRDT();
+    firstPut = await crdt.bulk([
+      { id: "ace", value: { points: 11 } },
+      { id: "king", value: { points: 10 } },
+    ]);
+    secondPut = await crdt.bulk([
+      { id: "queen", value: { points: 10 } },
+      { id: "jack", value: { points: 10 } },
+    ]);
+  });
+  it("should have a one-element head", async function () {
+    const head = crdt.clock.head;
+    expect(head.length).toBe(1);
+    expect(firstPut.head.length).toBe(1);
+    expect(secondPut.head.length).toBe(1);
+    expect(firstPut.head[0]).not.toBe(secondPut.head[0]);
+  });
+  it("return the records on get", async function () {
+    const ret = await crdt.get("ace");
+    expect(ret).not.toBeNull();
+    const { doc } = ret as DocValue<CRDTTestType>;
+    expect(doc.points).toBe(11);
+
+    for (const key of ["king", "queen", "jack"]) {
+      const { doc } = (await crdt.get(key)) as DocValue<CRDTTestType>;
+      expect(doc.points).toBe(10);
+    }
+  });
+  it("should offer changes", async function () {
+    const { result } = await crdt.changes();
+    expect(result.length).toBe(4);
+    expect(result[0].id).toBe("ace");
+    expect(result[0].value?.points).toBe(11);
+    expect(result[1].id).toBe("king");
+    expect(result[2].id).toBe("queen");
+    expect(result[3].id).toBe("jack");
+  });
+});
+
+describe("Compact a named CRDT with writes", function () {
+  let crdt: CRDT<CRDTTestType>;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT("named-crdt-compaction");
+    for (let i = 0; i < 10; i++) {
+      const bulk = [
+        { id: "ace", value: { points: 11 } },
+        { id: "king", value: { points: 10 } },
+      ];
+      await crdt.bulk(bulk);
+    }
+  });
+  it("has data", async function () {
+    const got = (await crdt.get("ace")) as DocValue<CRDTTestType>;
+    expect(got.doc).toBeTruthy();
+    expect(got.doc.points).toBe(11);
+  });
+  it("should start with blocks", async function () {
+    const blz: bs.AnyBlock[] = [];
+    for await (const blk of crdt.blockstore.entries()) {
+      blz.push(blk);
+    }
+    expect(blz.length).toBe(13);
+  });
+  it("should start with changes", async function () {
+    const { result } = await crdt.changes();
+    expect(result.length).toBe(2);
+    expect(result[0].id).toBe("ace");
+  });
+  itSkip("should have fewer blocks after compact", async function () {
+    await crdt.compact();
+    const blz: bs.AnyBlock[] = [];
+    for await (const blk of crdt.blockstore.entries()) {
+      blz.push(blk);
+    }
+    expect(blz.length).toBe(23);
+  });
+  it("should have data after compact", async function () {
+    await crdt.compact();
+    const got = (await crdt.get("ace")) as DocValue<CRDTTestType>;
+    expect(got.doc).toBeTruthy();
+    expect(got.doc.points).toBe(11);
+  });
+  it("should have changes after compact", async function () {
+    const chs = await crdt.changes();
+    expect(chs.result[0].id).toBe("ace");
+  });
+});
+
+describe("CRDT with an index", function () {
+  let crdt: CRDT<CRDTTestType>;
+  let idx: Index<number, CRDTTestType>;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT<CRDTTestType>();
+    await crdt.bulk([
+      { id: "ace", value: { points: 11 } },
+      { id: "king", value: { points: 10 } },
+    ]);
+    idx = await index<number, CRDTTestType>({ _crdt: crdt }, "points");
+  });
+  it("should query the data", async function () {
+    const got = await idx.query({ range: [9, 12] });
+    expect(got.rows.length).toBe(2);
+    expect(got.rows[0].id).toBe("king");
+    expect(got.rows[0].key).toBe(10);
+  });
+  it("should register the index", async function () {
+    const rIdx = await index<number, CRDTTestType>({ _crdt: crdt }, "points");
+    expect(rIdx).toBeTruthy();
+    expect(rIdx.name).toBe("points");
+    const got = await rIdx.query({ range: [9, 12] });
+    expect(got.rows.length).toBe(2);
+    expect(got.rows[0].id).toBe("king");
+    expect(got.rows[0].key).toBe(10);
+  });
+  it("creating a different index with same name should not work", async function () {
+    const e = await index({ _crdt: crdt }, "points", (doc) => doc._id)
+      .query()
+      .catch((err) => err);
+    expect(e.message).toMatch(/cannot apply/);
+  });
+});
+
+describe("Loader with a committed transaction", function () {
+  interface CRDTTestType {
+    readonly foo: string;
+  }
+  let loader: bs.Loader;
+  let blockstore: bs.EncryptedBlockstore;
+  let crdt: CRDT<CRDTTestType>;
+  let done: CRDTMeta;
+  const dbname = "test-loader";
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT(dbname);
+    blockstore = crdt.blockstore as bs.EncryptedBlockstore;
+    expect(blockstore.loader).toBeTruthy();
+    loader = blockstore.loader;
+    done = await crdt.bulk([{ id: "foo", value: { foo: "bar" } }]);
+  });
+  it("should have a name", function () {
+    expect(loader.name).toBe(dbname);
+  });
+  it("should commit a transaction", function () {
+    expect(done.head).toBeTruthy();
+    // expect(done.cars).toBeTruthy();
+    expect(loader.carLog.length).toBe(1);
+  });
+  it("can load the car", async function () {
+    const blk = loader.carLog[0][0];
+    expect(blk).toBeTruthy();
+    const reader = await loader.loadCar(blk);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+});
+
+describe("Loader with two committed transactions", function () {
+  interface CRDTTestType {
+    readonly foo: string;
+  }
+  let loader: bs.Loader;
+  let crdt: CRDT<CRDTTestType>;
+  let blockstore: bs.EncryptedBlockstore;
+  let done1: CRDTMeta;
+  let done2: CRDTMeta;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT("test-loader");
+    blockstore = crdt.blockstore as bs.EncryptedBlockstore;
+    expect(blockstore.loader).toBeTruthy();
+    loader = blockstore.loader;
+    done1 = await crdt.bulk([{ id: "apple", value: { foo: "bar" } }]);
+    done2 = await crdt.bulk([{ id: "orange", value: { foo: "bar" } }]);
+  });
+  it("should commit two transactions", function () {
+    expect(done1.head).toBeTruthy();
+    // expect(done1.cars).toBeTruthy();
+    expect(done2.head).toBeTruthy();
+    // expect(done2.cars).toBeTruthy();
+    expect(done1.head).not.toBe(done2.head);
+    // expect(done1.cars).not.toBe(done2.cars);
+    // expect(blockstore.transactions.size).toBe(2);
+    expect(loader.carLog.length).toBe(2);
+    // expect(loader.carLog.indexOf(done1.cars)).toBe(1);
+    // expect(loader.carLog.map((cs) => cs.toString()).indexOf(done1.cars.toString())).toBe(1);
+    // expect(loader.carLog.indexOf(done2.cars)).toBe(0);
+    // expect(loader.carLog.map((cs) => cs.toString()).indexOf(done2.cars.toString())).toBe(0);
+  });
+  it("can load the car", async function () {
+    const blk = loader.carLog[0][0];
+    expect(blk).toBeTruthy();
+    const reader = await loader.loadCar(blk);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(1);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+});
+
+describe("Loader with many committed transactions", function () {
+  interface Doc {
+    foo: string;
+  }
+  let loader: bs.Loader;
+  let blockstore: bs.EncryptedBlockstore;
+  let crdt: CRDT<Doc>;
+  let dones: CRDTMeta[];
+  const count = 10;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    crdt = new CRDT("test-loader-many");
+    blockstore = crdt.blockstore as bs.EncryptedBlockstore;
+    expect(blockstore.loader).toBeTruthy();
+    loader = blockstore.loader;
+    dones = [];
+    for (let i = 0; i < count; i++) {
+      const did = await crdt.bulk([{ id: `apple${i}`, value: { foo: "bar" } }]);
+      dones.push(did);
+    }
+  });
+  it("should commit many transactions", function () {
+    for (const done of dones) {
+      expect(done.head).toBeTruthy();
+      // expect(done.cars).toBeTruthy();
+    }
+    expect(blockstore.transactions.size).toBe(0); // cleaned up on commit
+    expect(loader.carLog.length).toBe(count);
+  });
+  it("can load the car", async function () {
+    const blk = loader.carLog[2][0];
+    // expect(dones[5].cars).toBeTruthy();
+    const reader = await loader.loadCar(blk);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(7);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+});