@fireproof/core 0.20.0-dev-preview-40 → 0.20.0-dev-preview-50

package/tests/fireproof/fireproof.test.ts

@@ -41,11 +41,11 @@ describe("dreamcode", function () {
   let result: IndexRows<string, Doc>;
   let db: Database;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     db = fireproof("test-db");
     ok = await db.put({ _id: "test-1", text: "fireproof", dream: true });
@@ -65,7 +65,7 @@ describe("dreamcode", function () {
     expect(result.rows.length).toBe(1);
     expect(result.rows[0].key).toBe("fireproof");
   });
-  it("should query with function", async function () {
+  it("should query with function", async () => {
     const result = await db.query<boolean, Doc>((doc) => doc.dream);
     expect(result).toBeTruthy();
     expect(result.rows).toBeTruthy();
@@ -89,7 +89,7 @@ describe("public API", function () {
     await db.destroy();
   });
 
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     db = fireproof("test-api");
     // index = index(db, 'test-index', (doc) => doc.foo)
@@ -131,23 +131,24 @@ describe("database fullconfig", () => {
         // meta: `${base}/meta?taste=${taste}`,
         data: {
           meta: base.build().pathname("dist/full/meta"),
-          data: base.build().pathname("dist/full/data"),
+          car: base.build().pathname("dist/full/data"),
           wal: base.build().pathname("dist/full/wal"),
         },
         idx: {
           meta: base.build().pathname("dist/full/idx-meta"),
-          data: base.build().pathname("dist/full/idx-data"),
+          car: base.build().pathname("dist/full/idx-data"),
           wal: base.build().pathname("dist/full/idx-wal"),
         },
         // wal: `${base}/wal?taste=${taste}`,
       },
     });
+    await db.ready();
 
-    const carStore = await db.ledger.crdt.blockstore.loader?.carStore();
+    const carStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
     expect(carStore.url().getParam(PARAM.NAME)).toBe("my-funky-name");
-    const metaStore = await db.ledger.crdt.blockstore.loader?.metaStore();
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
     expect(metaStore.url().getParam(PARAM.NAME)).toBe("my-funky-name");
-    const walStore = await db.ledger.crdt.blockstore.loader?.WALStore();
+    const walStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.wal;
     expect(walStore.url().getParam(PARAM.NAME)).toBe("my-funky-name");
 
     expect(db).toBeTruthy();
@@ -163,26 +164,26 @@ describe("basic ledger", function () {
   }
   let db: Database;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     db = fireproof("test-basic");
   });
-  it("can put with id", async function () {
+  it("can put with id", async () => {
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
   });
-  it("can put without id", async function () {
+  it("can put without id", async () => {
     const ok = await db.put({ foo: "bam" });
     expect(ok).toBeTruthy();
     const got = await db.get<Doc>(ok.id);
     expect(got.foo).toBe("bam");
   });
-  it("can bulk an array", async function () {
+  it("can bulk an array", async () => {
     const ok = await db.bulk([{ foo: "cool" }, { foo: "dude" }]);
     expect(ok).toBeTruthy();
     expect(ok.ids.length).toBe(2);
@@ -191,7 +192,7 @@ describe("basic ledger", function () {
     const got2 = await db.get<Doc>(ok.ids[1]);
     expect(got2.foo).toBe("dude");
   });
-  it("can define an index", async function () {
+  it("can define an index", async () => {
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     const idx = index<string, { foo: string }>(db, "test-index", (doc) => doc.foo);
@@ -201,7 +202,7 @@ describe("basic ledger", function () {
     expect(result.rows.length).toBe(1);
     expect(result.rows[0].key).toBe("bar");
   });
-  it("can define an index with a default function", async function () {
+  it("can define an index with a default function", async () => {
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     const idx = index(db, "foo");
@@ -211,7 +212,7 @@ describe("basic ledger", function () {
     expect(result.rows.length).toBe(1);
     expect(result.rows[0].key).toBe("bar");
   });
-  it("should query with multiple successive functions", async function () {
+  it("should query with multiple successive functions", async () => {
     interface TestDoc {
       _id: string;
       foo: string;
@@ -236,16 +237,16 @@ describe("basic ledger", function () {
 describe("benchmarking with compaction", function () {
   let db: Database;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     // erase the existing test data
     await sthis.start();
     db = fireproof("test-benchmark-compaction", { autoCompact: 3 });
   });
-  it.skip("insert during compaction", async function () {
+  it.skip("insert during compaction", async () => {
     const ok = await db.put({ _id: "test", foo: "fast" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
@@ -290,11 +291,11 @@ describe("benchmarking with compaction", function () {
 describe("benchmarking a ledger", function () {
   let db: Database;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     // erase the existing test data
     db = fireproof("test-benchmark", { autoCompact: 100000, public: true });
@@ -448,11 +449,11 @@ describe("Reopening a ledger", function () {
   }
   let db: Database;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     // erase the existing test data
     await sthis.start();
 
@@ -465,12 +466,12 @@ describe("Reopening a ledger", function () {
     expect(db.ledger.crdt.clock.head.length).toBe(1);
   });
 
-  it("should persist data", async function () {
+  it("should persist data", async () => {
     const doc = await db.get<Doc>("test");
     expect(doc.foo).toBe("bar");
   });
 
-  it("should have the same data on reopen", async function () {
+  it("should have the same data on reopen", async () => {
     const db2 = fireproof("test-reopen");
     const doc = await db2.get<FooType>("test");
     expect(doc.foo).toBe("bar");
@@ -480,27 +481,27 @@ describe("Reopening a ledger", function () {
     await db2.close();
   });
 
-  it("should have a car in the car log", async function () {
+  it("should have a car in the car log", async () => {
     await db.ledger.crdt.ready();
     const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeDefined();
     expect(loader.carLog).toBeDefined();
-    expect(loader.carLog.length).toBe(1);
+    expect(loader.carLog.length).toBe(1 + 1 /* genesis */);
   });
 
-  it("should have carlog after reopen", async function () {
+  it("should have carlog after reopen", async () => {
     const db2 = fireproof("test-reopen");
     await db2.ledger.crdt.ready();
     const blocks = db2.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeDefined();
     expect(loader.carLog).toBeDefined();
-    expect(loader.carLog.length).toBe(1);
+    expect(loader.carLog.length).toBe(1 + 1 /* genesis */);
     await db2.close();
   });
 
-  it("faster, should have the same data on reopen after reopen and update", async function () {
+  it("faster, should have the same data on reopen after reopen and update", async () => {
     for (let i = 0; i < 4; i++) {
       // console.log('iteration', i)
       const db = fireproof("test-reopen");
@@ -508,17 +509,17 @@ describe("Reopening a ledger", function () {
       await db.ready();
       const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
-      expect(loader.carLog.length).toBe(i + 1);
+      expect(loader.carLog.length).toBe(i + 1 + 1 /* genesis */);
       const ok = await db.put({ _id: `test${i}`, fire: "proof".repeat(50 * 1024) });
       expect(ok).toBeTruthy();
-      expect(loader.carLog.length).toBe(i + 2);
+      expect(loader.carLog.length).toBe(i + 2 + 1 /* genesis */);
       const doc = await db.get<FireType>(`test${i}`);
       expect(doc.fire).toBe("proof".repeat(50 * 1024));
       await db.close();
     }
   }, 20000);
 
-  it.skip("passing slow, should have the same data on reopen after reopen and update", async function () {
+  it.skip("passing slow, should have the same data on reopen after reopen and update", async () => {
     for (let i = 0; i < 200; i++) {
       // console.log("iteration", i);
       // console.time("db open");
@@ -553,11 +554,11 @@ describe("Reopening a ledger with indexes", function () {
   let didMap: boolean;
   let mapFn: MapFn<Doc>;
   const sthis = ensureSuperThis();
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
     db = fireproof("test-reopen-idx");
     const ok = await db.put({ _id: "test", foo: "bar" });
@@ -572,7 +573,7 @@ describe("Reopening a ledger with indexes", function () {
     idx = index<string, Doc>(db, "foo", mapFn);
   });
 
-  it("should persist data", async function () {
+  it("should persist data", async () => {
     const doc = await db.get<Doc>("test");
     expect(doc.foo).toBe("bar");
     const idx2 = index<string, Doc>(db, "foo");
@@ -585,7 +586,7 @@ describe("Reopening a ledger with indexes", function () {
     expect(didMap).toBeTruthy();
   });
 
-  it("should reuse the index", async function () {
+  it("should reuse the index", async () => {
     const idx2 = index(db, "foo", mapFn);
     expect(idx2).toBe(idx);
     const result = await idx2.query();
@@ -603,7 +604,7 @@ describe("Reopening a ledger with indexes", function () {
     expect(didMap).toBeFalsy();
   });
 
-  it("should have the same data on reopen", async function () {
+  it("should have the same data on reopen", async () => {
     const db2 = fireproof("test-reopen-idx");
     const doc = await db2.get<FooType>("test");
     expect(doc.foo).toBe("bar");
@@ -612,7 +613,7 @@ describe("Reopening a ledger with indexes", function () {
     expect(db2.ledger.crdt.clock.head).toEqual(db.ledger.crdt.clock.head);
   });
 
-  it("should have the same data on reopen after a query", async function () {
+  it("should have the same data on reopen after a query", async () => {
     const r0 = await idx.query();
     expect(r0).toBeTruthy();
     expect(r0.rows).toBeTruthy();
@@ -627,7 +628,7 @@ describe("Reopening a ledger with indexes", function () {
     expect(db2.ledger.crdt.clock.head).toEqual(db.ledger.crdt.clock.head);
   });
 
-  // it('should query the same data on reopen', async function () {
+  // it('should query the same data on reopen', async () =>{
   //   const r0 = await idx.query()
   //   assert(r0)
   //   assert(r0.rows)
@@ -650,10 +651,10 @@ describe("Reopening a ledger with indexes", function () {
 
 describe("basic js verify", function () {
   const sthis = ensureSuperThis();
-  beforeAll(async function () {
+  beforeAll(async () => {
     await sthis.start();
   });
-  it("should include cids in arrays", async function () {
+  it("should include cids in arrays", async () => {
     const db = fireproof("test-verify");
     const ok = await db.put({ _id: "test", foo: ["bar", "bam"] });
     expect(ok.id).toBe("test");
@@ -662,7 +663,7 @@ describe("basic js verify", function () {
     const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
-    const cid = loader.carLog[0][0];
+    const cid = loader.carLog.asArray()[0][0];
     const cid2 = db.ledger.crdt.clock.head[0];
     expect(cid).not.toBe(cid2);
     expect(cid).not.toBe(cid2);
@@ -697,17 +698,18 @@ describe("same workload twice, same CID", function () {
     },
   };
 
-  afterEach(async function () {
+  afterEach(async () => {
     await dbA.close();
     await dbA.destroy();
     await dbB.close();
     await dbB.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     let ok: DocResponse;
     await sthis.start();
     // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
     dbA = fireproof("test-dual-workload-a", configA);
+    await dbA.destroy();
     for (const doc of docs) {
       ok = await dbA.put(doc);
       expect(ok).toBeTruthy();
@@ -717,6 +719,7 @@ describe("same workload twice, same CID", function () {
 
     // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
     dbB = fireproof("test-dual-workload-b", configB);
+    await dbA.destroy();
     for (const doc of docs) {
       ok = await dbB.put(doc);
       expect(ok).toBeTruthy();
@@ -724,32 +727,32 @@ describe("same workload twice, same CID", function () {
     }
     headB = dbB.ledger.crdt.clock.head.toString();
   });
-  it("should have head A and B", async function () {
+  it("should have head A and B", async () => {
     expect(headA).toBeTruthy();
     expect(headB).toBeTruthy();
     expect(headA).toEqual(headB);
     expect(headA.length).toBeGreaterThan(10);
   });
-  it("should have same car log", async function () {
+  it("should have same car log", async () => {
     const logA = dbA.ledger.crdt.blockstore.loader?.carLog;
     expect(logA).toBeTruthy();
     assert(logA);
-    expect(logA.length).toBe(docs.length);
+    expect(logA.length).toBe(docs.length + 1 /*genesis*/);
 
     const logB = dbB.ledger.crdt.blockstore.loader?.carLog;
     expect(logB).toBeTruthy();
     assert(logB);
-    expect(logB.length).toBe(docs.length);
+    expect(logB.length).toBe(docs.length + 1 /*genesis*/);
 
-    const logA2 = logA.map((c) => c.toString());
-    const logB2 = logB.map((c) => c.toString());
+    const logA2 = logA.asArray().map((c) => c.toString());
+    const logB2 = logB.asArray().map((c) => c.toString());
 
     expect(logA2.length).toBe(logB2.length);
 
     // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
     // expect(logA2).toEqual(logB2);
   });
-  it("should have same car log after compact", async function () {
+  it("should have same car log after compact", async () => {
     await dbA.compact();
     await dbB.compact();
 
@@ -763,8 +766,8 @@ describe("same workload twice, same CID", function () {
     assert(cmpLogB);
     expect(cmpLogB.length).toBe(1);
 
-    const cmpLogA2 = cmpLogA.map((c) => c.toString());
-    const cmpLogB2 = cmpLogB.map((c) => c.toString());
+    const cmpLogA2 = cmpLogA.asArray().map((c) => c.toString());
+    const cmpLogB2 = cmpLogB.asArray().map((c) => c.toString());
 
     expect(cmpLogA2.length).toBe(cmpLogB2.length);
 

package/tests/fireproof/hello.test.ts

@@ -49,23 +49,23 @@ describe("hello public API", () => {
 
 describe("Simplified Reopening a ledger", function () {
   let db: Database;
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     db = fireproof("test-reopen-simple");
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
   });
 
-  it("should persist data", async function () {
+  it("should persist data", async () => {
     const doc = await db.get<{ foo: string }>("test");
     expect(doc.foo).toBe("bar");
   });
 
-  it("should have the same data on reopen", async function () {
+  it("should have the same data on reopen", async () => {
     const db2 = fireproof("test-reopen-simple");
     const doc = await db2.get<{ foo: string }>("test");
     expect(doc.foo).toBe("bar");