@fireproof/core 0.20.0-dev-preview-06 → 0.20.0-dev-preview-10

package/tests/fireproof/fireproof.test.ts

@@ -4,18 +4,17 @@ import { CID } from "multiformats/cid";
 
 import {
   ConfigOpts,
-  Database,
-  DatabaseFactory,
   DocResponse,
   DocWithId,
   Index,
   IndexRows,
   MapFn,
   bs,
-  fireproof,
   index,
-  isDatabase,
   ensureSuperThis,
+  fireproof,
+  Database,
+  isDatabase,
 } from "@fireproof/core";
 
 export function carLogIncludesGroup(list: bs.AnyLink[], cid: CID) {
@@ -46,7 +45,7 @@ describe("dreamcode", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = fireproof("test-db");
+    db = fireproof.DB("test-db");
     ok = await db.put({ _id: "test-1", text: "fireproof", dream: true });
     doc = await db.get(ok.id);
     result = await db.query("text", { range: ["a", "z"] });
@@ -90,13 +89,13 @@ describe("public API", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    db = fireproof("test-api");
+    db = fireproof.DB("test-api");
     // index = index(db, 'test-index', (doc) => doc.foo)
     ok = await db.put({ _id: "test", foo: "bar" });
     doc = await db.get("test");
     query = await db.query<string, Doc>((doc) => doc.foo);
   });
-  it("should be a database instance", function () {
+  it("should be a ledger instance", function () {
     expect(db).toBeTruthy();
     expect(isDatabase(db)).toBeTruthy();
   });
@@ -115,11 +114,11 @@ describe("public API", function () {
   });
 });
 
-describe("basic database", function () {
+describe("basic ledger", function () {
   interface Doc {
     foo: string;
   }
-  let db: Database<Doc>;
+  let db: Database;
   const sthis = ensureSuperThis();
   afterEach(async function () {
     await db.close();
@@ -127,7 +126,7 @@ describe("basic database", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-basic");
+    db = fireproof.DB("test-basic");
   });
   it("can put with id", async function () {
     const ok = await db.put({ _id: "test", foo: "bar" });
@@ -201,14 +200,14 @@ describe("benchmarking with compaction", function () {
   beforeEach(async function () {
     // erase the existing test data
     await sthis.start();
-    db = DatabaseFactory("test-benchmark-compaction", { autoCompact: 3 });
+    db = fireproof.DB("test-benchmark-compaction", { autoCompact: 3 });
   });
   it.skip("insert during compaction", async function () {
     const ok = await db.put({ _id: "test", foo: "fast" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
-    expect(db.crdt.clock.head).toBeTruthy();
-    expect(db.crdt.clock.head.length).toBe(1);
+    expect(db.ledger.crdt.clock.head).toBeTruthy();
+    expect(db.ledger.crdt.clock.head.length).toBe(1);
 
     const numDocs = 20;
     const batchSize = 5;
@@ -229,7 +228,7 @@ describe("benchmarking with compaction", function () {
           }),
         );
       }
-      const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
+      const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
       expect(loader).toBeTruthy();
 
@@ -245,8 +244,7 @@ describe("benchmarking with compaction", function () {
   });
 });
 
-describe("benchmarking a database", function () {
-  /** @type {Database} */
+describe("benchmarking a ledger", function () {
   let db: Database;
   const sthis = ensureSuperThis();
   afterEach(async function () {
@@ -256,8 +254,8 @@ describe("benchmarking a database", function () {
   beforeEach(async function () {
     await sthis.start();
     // erase the existing test data
-    db = DatabaseFactory("test-benchmark", { autoCompact: 100000, public: true });
-    // db = DatabaseFactory(null, {autoCompact: 100000})
+    db = fireproof.DB("test-benchmark", { autoCompact: 100000, public: true });
+    // db = fireproof.DB(null, {autoCompact: 100000})
   });
 
   // run benchmarking tests
@@ -270,8 +268,8 @@ describe("benchmarking a database", function () {
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
 
-    expect(db.crdt.clock.head).toBeTruthy();
-    expect(db.crdt.clock.head.length).toBe(1);
+    expect(db.ledger.crdt.clock.head).toBeTruthy();
+    expect(db.ledger.crdt.clock.head.length).toBe(1);
 
     const numDocs = 2500;
     const batchSize = 500;
@@ -307,7 +305,7 @@ describe("benchmarking a database", function () {
     // equals(allDocsResult2.rows.length, numDocs+1)
 
     // console.time("open new DB");
-    const newDb = DatabaseFactory("test-benchmark", { autoCompact: 100000, public: true });
+    const newDb = fireproof.DB("test-benchmark", { autoCompact: 100000, public: true });
     const doc = await newDb.get<{ foo: string }>("test");
     expect(doc.foo).toBe("fast");
     // console.timeEnd("open new DB");
@@ -337,7 +335,7 @@ describe("benchmarking a database", function () {
     await db.put({ _id: "compacted-test", foo: "bar" });
 
     // console.log('car log length', db._crdt.blockstore.loader.carLog.length)
-    const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
+    const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
     expect(loader.carLog.length).toBe(2);
@@ -349,10 +347,10 @@ describe("benchmarking a database", function () {
     await sleep(100);
 
     // console.time("compacted reopen again");
-    const newDb2 = DatabaseFactory("test-benchmark", { autoCompact: 100000, public: true });
+    const newDb2 = fireproof.DB("test-benchmark", { autoCompact: 100000, public: true });
     const doc21 = await newDb2.get<FooType>("test");
     expect(doc21.foo).toBe("fast");
-    const blocks2 = newDb2.crdt.blockstore as bs.EncryptedBlockstore;
+    const blocks2 = newDb2.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader2 = blocks2.loader;
     expect(loader2).toBeTruthy();
 
@@ -401,7 +399,7 @@ describe("benchmarking a database", function () {
   }, 20000000);
 });
 
-describe("Reopening a database", function () {
+describe("Reopening a ledger", function () {
   interface Doc {
     foo: string;
   }
@@ -415,13 +413,13 @@ describe("Reopening a database", function () {
     // erase the existing test data
     await sthis.start();
 
-    db = DatabaseFactory("test-reopen", { autoCompact: 100000 });
+    db = fireproof.DB("test-reopen", { autoCompact: 100000 });
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
 
-    expect(db.crdt.clock.head).toBeDefined();
-    expect(db.crdt.clock.head.length).toBe(1);
+    expect(db.ledger.crdt.clock.head).toBeDefined();
+    expect(db.ledger.crdt.clock.head.length).toBe(1);
   });
 
   it("should persist data", async function () {
@@ -430,18 +428,18 @@ describe("Reopening a database", function () {
   });
 
   it("should have the same data on reopen", async function () {
-    const db2 = DatabaseFactory("test-reopen");
+    const db2 = fireproof.DB("test-reopen");
     const doc = await db2.get<FooType>("test");
     expect(doc.foo).toBe("bar");
-    expect(db2.crdt.clock.head).toBeDefined();
-    expect(db2.crdt.clock.head.length).toBe(1);
-    expect(db2.crdt.clock.head).toEqual(db.crdt.clock.head);
+    expect(db2.ledger.crdt.clock.head).toBeDefined();
+    expect(db2.ledger.crdt.clock.head.length).toBe(1);
+    expect(db2.ledger.crdt.clock.head).toEqual(db.ledger.crdt.clock.head);
     await db2.close();
   });
 
   it("should have a car in the car log", async function () {
-    await db.crdt.ready();
-    const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
+    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();
@@ -449,9 +447,9 @@ describe("Reopening a database", function () {
   });
 
   it("should have carlog after reopen", async function () {
-    const db2 = DatabaseFactory("test-reopen");
-    await db2.crdt.ready();
-    const blocks = db2.crdt.blockstore as bs.EncryptedBlockstore;
+    const db2 = fireproof.DB("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();
@@ -462,10 +460,10 @@ describe("Reopening a database", function () {
   it("faster, should have the same data on reopen after reopen and update", async function () {
     for (let i = 0; i < 4; i++) {
       // console.log('iteration', i)
-      const db = DatabaseFactory("test-reopen");
+      const db = fireproof.DB("test-reopen");
       // assert(db._crdt.xready());
-      await db.crdt.ready();
-      const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
+      await db.ready();
+      const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
       expect(loader.carLog.length).toBe(i + 1);
       const ok = await db.put({ _id: `test${i}`, fire: "proof".repeat(50 * 1024) });
@@ -481,11 +479,11 @@ describe("Reopening a database", function () {
     for (let i = 0; i < 200; i++) {
       // console.log("iteration", i);
       // console.time("db open");
-      const db = DatabaseFactory("test-reopen", { autoCompact: 1000 }); // try with 10
+      const db = fireproof.DB("test-reopen", { autoCompact: 1000 }); // try with 10
       // assert(db._crdt.ready);
-      await db.crdt.ready();
+      await db.ready();
       // console.timeEnd("db open");
-      const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
+      const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
       expect(loader).toBeDefined();
       expect(loader.carLog.length).toBe(i + 1);
@@ -503,7 +501,7 @@ describe("Reopening a database", function () {
   }, 200000);
 });
 
-describe("Reopening a database with indexes", function () {
+describe("Reopening a ledger with indexes", function () {
   interface Doc {
     foo: string;
   }
@@ -518,7 +516,7 @@ describe("Reopening a database with indexes", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = fireproof("test-reopen-idx");
+    db = fireproof.DB("test-reopen-idx");
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok.id).toBe("test");
 
@@ -563,12 +561,12 @@ describe("Reopening a database with indexes", function () {
   });
 
   it("should have the same data on reopen", async function () {
-    const db2 = fireproof("test-reopen-idx");
+    const db2 = fireproof.DB("test-reopen-idx");
     const doc = await db2.get<FooType>("test");
     expect(doc.foo).toBe("bar");
-    expect(db2.crdt.clock.head).toBeTruthy();
-    expect(db2.crdt.clock.head.length).toBe(1);
-    expect(db2.crdt.clock.head).toEqual(db.crdt.clock.head);
+    expect(db2.ledger.crdt.clock.head).toBeTruthy();
+    expect(db2.ledger.crdt.clock.head.length).toBe(1);
+    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 () {
@@ -578,12 +576,12 @@ describe("Reopening a database with indexes", function () {
     expect(r0.rows.length).toBe(1);
     expect(r0.rows[0].key).toBe("bar");
 
-    const db2 = fireproof("test-reopen-idx");
+    const db2 = fireproof.DB("test-reopen-idx");
     const doc = await db2.get<FooType>("test");
     expect(doc.foo).toBe("bar");
-    expect(db2.crdt.clock.head).toBeTruthy();
-    expect(db2.crdt.clock.head.length).toBe(1);
-    expect(db2.crdt.clock.head).toEqual(db.crdt.clock.head);
+    expect(db2.ledger.crdt.clock.head).toBeTruthy();
+    expect(db2.ledger.crdt.clock.head.length).toBe(1);
+    expect(db2.ledger.crdt.clock.head).toEqual(db.ledger.crdt.clock.head);
   });
 
   // it('should query the same data on reopen', async function () {
@@ -613,16 +611,16 @@ describe("basic js verify", function () {
     await sthis.start();
   });
   it("should include cids in arrays", async function () {
-    const db = fireproof("test-verify");
+    const db = fireproof.DB("test-verify");
     const ok = await db.put({ _id: "test", foo: ["bar", "bam"] });
     expect(ok.id).toBe("test");
     const ok2 = await db.put({ _id: "test2", foo: ["bar", "bam"] });
     expect(ok2.id).toBe("test2");
-    const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
+    const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
     const cid = loader.carLog[0][0];
-    const cid2 = db.crdt.clock.head[0];
+    const cid2 = db.ledger.crdt.clock.head[0];
     expect(cid).not.toBe(cid2);
     expect(cid).not.toBe(cid2);
     const cidList = [cid, cid2];
@@ -665,23 +663,23 @@ describe("same workload twice, same CID", function () {
   beforeEach(async function () {
     let ok: DocResponse;
     await sthis.start();
-    // todo this fails because the test setup doesn't properly configure both databases to use the same key
-    dbA = fireproof("test-dual-workload-a", configA);
+    // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
+    dbA = fireproof.DB("test-dual-workload-a", configA);
     for (const doc of docs) {
       ok = await dbA.put(doc);
       expect(ok).toBeTruthy();
       expect(ok.id).toBeTruthy();
     }
-    headA = dbA.crdt.clock.head.toString();
+    headA = dbA.ledger.crdt.clock.head.toString();
 
-    // todo this fails because the test setup doesn't properly configure both databases to use the same key
-    dbB = fireproof("test-dual-workload-b", configB);
+    // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
+    dbB = fireproof.DB("test-dual-workload-b", configB);
     for (const doc of docs) {
       ok = await dbB.put(doc);
       expect(ok).toBeTruthy();
       expect(ok.id).toBeTruthy();
     }
-    headB = dbB.crdt.clock.head.toString();
+    headB = dbB.ledger.crdt.clock.head.toString();
   });
   it("should have head A and B", async function () {
     expect(headA).toBeTruthy();
@@ -690,12 +688,12 @@ describe("same workload twice, same CID", function () {
     expect(headA.length).toBeGreaterThan(10);
   });
   it("should have same car log", async function () {
-    const logA = dbA.crdt.blockstore.loader?.carLog;
+    const logA = dbA.ledger.crdt.blockstore.loader?.carLog;
     expect(logA).toBeTruthy();
     assert(logA);
     expect(logA.length).toBe(docs.length);
 
-    const logB = dbB.crdt.blockstore.loader?.carLog;
+    const logB = dbB.ledger.crdt.blockstore.loader?.carLog;
     expect(logB).toBeTruthy();
     assert(logB);
     expect(logB.length).toBe(docs.length);
@@ -705,19 +703,19 @@ describe("same workload twice, same CID", function () {
 
     expect(logA2.length).toBe(logB2.length);
 
-    // todo this fails because the test setup doesn't properly configure both databases to use the same key
+    // 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 () {
     await dbA.compact();
     await dbB.compact();
 
-    const cmpLogA = dbA.crdt.blockstore.loader?.carLog;
+    const cmpLogA = dbA.ledger.crdt.blockstore.loader?.carLog;
     expect(cmpLogA).toBeTruthy();
     assert(cmpLogA);
     expect(cmpLogA.length).toBe(1);
 
-    const cmpLogB = dbB.crdt.blockstore.loader?.carLog;
+    const cmpLogB = dbB.ledger.crdt.blockstore.loader?.carLog;
     expect(cmpLogB).toBeTruthy();
     assert(cmpLogB);
     expect(cmpLogB.length).toBe(1);
@@ -727,7 +725,7 @@ describe("same workload twice, same CID", function () {
 
     expect(cmpLogA2.length).toBe(cmpLogB2.length);
 
-    // todo this fails because the test setup doesn't properly configure both databases to use the same key
+    // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
     // expect(cmpLogA2).toEqual(cmpLogB2);
   });
 });

package/tests/fireproof/hello.test.ts

@@ -1,9 +1,9 @@
-import { fireproof, Database, DocResponse, DocWithId, index, isDatabase } from "@fireproof/core";
+import { fireproof, DocResponse, DocWithId, index, Database, isDatabase } from "@fireproof/core";
 import { mockSuperThis } from "../helpers.js";
 
 describe("Hello World Test", function () {
   it("should pass the hello world test", function () {
-    const result = fireproof("hello"); // call to your library function
+    const result = fireproof.DB("hello"); // call to your library function
     expect(result.name).toBe("hello");
   });
 });
@@ -23,12 +23,12 @@ describe("hello public API", () => {
   });
   beforeEach(async () => {
     await sthis.start();
-    db = fireproof("test-public-api");
+    db = fireproof.DB("test-public-api");
     index<string, TestDoc>(db, "test-index", (doc) => doc.foo);
     ok = await db.put({ _id: "test", foo: "bar" });
     doc = await db.get("test");
   });
-  it("should have a database", function () {
+  it("should have a ledger", function () {
     expect(db).toBeTruthy();
     expect(isDatabase(db)).toBeTruthy();
   });
@@ -41,20 +41,20 @@ describe("hello public API", () => {
   });
   it("should get when you open it again", async () => {
     await db.close();
-    db = fireproof("test-public-api");
+    db = fireproof.DB("test-public-api");
     doc = await db.get("test");
     expect(doc.foo).toBe("bar");
   });
 });
 
-describe("Simplified Reopening a database", function () {
+describe("Simplified Reopening a ledger", function () {
   let db: Database;
   afterEach(async function () {
     await db.close();
     await db.destroy();
   });
   beforeEach(async function () {
-    db = fireproof("test-reopen-simple");
+    db = fireproof.DB("test-reopen-simple");
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
@@ -66,7 +66,7 @@ describe("Simplified Reopening a database", function () {
   });
 
   it("should have the same data on reopen", async function () {
-    const db2 = fireproof("test-reopen-simple");
+    const db2 = fireproof.DB("test-reopen-simple");
     const doc = await db2.get<{ foo: string }>("test");
     expect(doc.foo).toBe("bar");
     await db2.close();