@fireproof/core 0.19.121-dev → 0.20.0-dev-preview-05

package/tests/fireproof/fireproof.test.ts

@@ -1,8 +1,22 @@
-import { sleep } from "../helpers.js";
+import { sleep, storageURL } from "../helpers.js";
 import { docs } from "./fireproof.test.fixture.js";
 import { CID } from "multiformats/cid";
 
-import { Database, DocResponse, DocWithId, Index, IndexRows, MapFn, bs, ensureSuperThis, fireproof, index } from "@fireproof/core";
+import {
+  ConfigOpts,
+  Ledger,
+  LedgerFactory,
+  DocResponse,
+  DocWithId,
+  Index,
+  IndexRows,
+  MapFn,
+  bs,
+  fireproof,
+  index,
+  isLedger,
+  ensureSuperThis,
+} from "@fireproof/core";
 
 export function carLogIncludesGroup(list: bs.AnyLink[], cid: CID) {
   return list.some((c) => c.equals(cid));
@@ -24,7 +38,7 @@ describe("dreamcode", function () {
   let ok: DocResponse;
   let doc: DocWithId<Doc>;
   let result: IndexRows<string, Doc>;
-  let db: Database;
+  let db: Ledger;
   const sthis = ensureSuperThis();
   afterEach(async function () {
     await db.close();
@@ -63,7 +77,7 @@ describe("public API", function () {
   interface Doc {
     foo: string;
   }
-  let db: Database;
+  let db: Ledger;
   let ok: DocResponse;
   let doc: DocWithId<Doc>;
   let query: IndexRows<string, Doc>;
@@ -82,9 +96,9 @@ describe("public API", function () {
     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(db instanceof Database).toBeTruthy();
+    expect(isLedger(db)).toBeTruthy();
   });
   it("should put", function () {
     expect(ok).toBeTruthy();
@@ -101,11 +115,11 @@ describe("public API", function () {
   });
 });
 
-describe("basic database", function () {
+describe("basic ledger", function () {
   interface Doc {
     foo: string;
   }
-  let db: Database<Doc>;
+  let db: Ledger<Doc>;
   const sthis = ensureSuperThis();
   afterEach(async function () {
     await db.close();
@@ -113,7 +127,7 @@ describe("basic database", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-basic");
+    db = LedgerFactory("test-basic");
   });
   it("can put with id", async function () {
     const ok = await db.put({ _id: "test", foo: "bar" });
@@ -126,10 +140,19 @@ describe("basic database", function () {
     const got = await db.get<Doc>(ok.id);
     expect(got.foo).toBe("bam");
   });
+  it("can bulk an array", async function () {
+    const ok = await db.bulk([{ foo: "cool" }, { foo: "dude" }]);
+    expect(ok).toBeTruthy();
+    expect(ok.ids.length).toBe(2);
+    const got = await db.get<Doc>(ok.ids[0]);
+    expect(got.foo).toBe("cool");
+    const got2 = await db.get<Doc>(ok.ids[1]);
+    expect(got2.foo).toBe("dude");
+  });
   it("can define an index", async function () {
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
-    const idx = index<string, { foo: string }>(sthis, db, "test-index", (doc) => doc.foo);
+    const idx = index<string, { foo: string }>(db, "test-index", (doc) => doc.foo);
     const result = await idx.query();
     expect(result).toBeTruthy();
     expect(result.rows).toBeTruthy();
@@ -139,7 +162,7 @@ describe("basic database", function () {
   it("can define an index with a default function", async function () {
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
-    const idx = index(sthis, db, "foo");
+    const idx = index(db, "foo");
     const result = await idx.query();
     expect(result).toBeTruthy();
     expect(result.rows).toBeTruthy();
@@ -169,7 +192,7 @@ describe("basic database", function () {
 });
 
 describe("benchmarking with compaction", function () {
-  let db: Database;
+  let db: Ledger;
   const sthis = ensureSuperThis();
   afterEach(async function () {
     await db.close();
@@ -178,14 +201,14 @@ describe("benchmarking with compaction", function () {
   beforeEach(async function () {
     // erase the existing test data
     await sthis.start();
-    db = new Database("test-benchmark-compaction", { autoCompact: 3 });
+    db = LedgerFactory("test-benchmark-compaction", { autoCompact: 3 });
   });
-  it("insert during compaction", async function () {
+  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.crdt.clock.head).toBeTruthy();
+    expect(db.crdt.clock.head.length).toBe(1);
 
     const numDocs = 20;
     const batchSize = 5;
@@ -206,7 +229,7 @@ describe("benchmarking with compaction", function () {
           }),
         );
       }
-      const blocks = db._crdt.blockstore as bs.EncryptedBlockstore;
+      const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
       expect(loader).toBeTruthy();
 
@@ -222,9 +245,9 @@ describe("benchmarking with compaction", function () {
   });
 });
 
-describe("benchmarking a database", function () {
-  /** @type {Database} */
-  let db: Database;
+describe("benchmarking a ledger", function () {
+  /** @type {Ledger} */
+  let db: Ledger;
   const sthis = ensureSuperThis();
   afterEach(async function () {
     await db.close();
@@ -233,8 +256,8 @@ describe("benchmarking a database", function () {
   beforeEach(async function () {
     await sthis.start();
     // erase the existing test data
-    db = new Database("test-benchmark", { autoCompact: 100000, public: true });
-    // db = new Database(null, {autoCompact: 100000})
+    db = LedgerFactory("test-benchmark", { autoCompact: 100000, public: true });
+    // db = LedgerFactory(null, {autoCompact: 100000})
   });
 
   // run benchmarking tests
@@ -247,8 +270,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.crdt.clock.head).toBeTruthy();
+    expect(db.crdt.clock.head.length).toBe(1);
 
     const numDocs = 2500;
     const batchSize = 500;
@@ -284,7 +307,7 @@ describe("benchmarking a database", function () {
     // equals(allDocsResult2.rows.length, numDocs+1)
 
     // console.time("open new DB");
-    const newDb = new Database("test-benchmark", { autoCompact: 100000, public: true });
+    const newDb = LedgerFactory("test-benchmark", { autoCompact: 100000, public: true });
     const doc = await newDb.get<{ foo: string }>("test");
     expect(doc.foo).toBe("fast");
     // console.timeEnd("open new DB");
@@ -314,7 +337,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.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
     expect(loader.carLog.length).toBe(2);
@@ -326,10 +349,10 @@ describe("benchmarking a database", function () {
     await sleep(100);
 
     // console.time("compacted reopen again");
-    const newDb2 = new Database("test-benchmark", { autoCompact: 100000, public: true });
+    const newDb2 = LedgerFactory("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.crdt.blockstore as bs.EncryptedBlockstore;
     const loader2 = blocks2.loader;
     expect(loader2).toBeTruthy();
 
@@ -378,11 +401,11 @@ describe("benchmarking a database", function () {
   }, 20000000);
 });
 
-describe("Reopening a database", function () {
+describe("Reopening a ledger", function () {
   interface Doc {
     foo: string;
   }
-  let db: Database;
+  let db: Ledger;
   const sthis = ensureSuperThis();
   afterEach(async function () {
     await db.close();
@@ -392,13 +415,13 @@ describe("Reopening a database", function () {
     // erase the existing test data
     await sthis.start();
 
-    db = new Database("test-reopen", { autoCompact: 100000 });
+    db = LedgerFactory("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.crdt.clock.head).toBeDefined();
+    expect(db.crdt.clock.head.length).toBe(1);
   });
 
   it("should persist data", async function () {
@@ -407,18 +430,18 @@ describe("Reopening a database", function () {
   });
 
   it("should have the same data on reopen", async function () {
-    const db2 = new Database("test-reopen");
+    const db2 = LedgerFactory("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.crdt.clock.head).toBeDefined();
+    expect(db2.crdt.clock.head.length).toBe(1);
+    expect(db2.crdt.clock.head).toEqual(db.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.crdt.ready();
+    const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeDefined();
     expect(loader.carLog).toBeDefined();
@@ -426,9 +449,9 @@ describe("Reopening a database", function () {
   });
 
   it("should have carlog after reopen", async function () {
-    const db2 = new Database("test-reopen");
-    await db2._crdt.ready();
-    const blocks = db2._crdt.blockstore as bs.EncryptedBlockstore;
+    const db2 = LedgerFactory("test-reopen");
+    await db2.crdt.ready();
+    const blocks = db2.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeDefined();
     expect(loader.carLog).toBeDefined();
@@ -439,10 +462,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 = new Database("test-reopen");
+      const db = LedgerFactory("test-reopen");
       // assert(db._crdt.xready());
-      await db._crdt.ready();
-      const blocks = db._crdt.blockstore as bs.EncryptedBlockstore;
+      await db.crdt.ready();
+      const blocks = db.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) });
@@ -458,11 +481,11 @@ describe("Reopening a database", function () {
     for (let i = 0; i < 200; i++) {
       // console.log("iteration", i);
       // console.time("db open");
-      const db = new Database("test-reopen", { autoCompact: 1000 }); // try with 10
+      const db = LedgerFactory("test-reopen", { autoCompact: 1000 }); // try with 10
       // assert(db._crdt.ready);
-      await db._crdt.ready();
+      await db.crdt.ready();
       // console.timeEnd("db open");
-      const blocks = db._crdt.blockstore as bs.EncryptedBlockstore;
+      const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
       expect(loader).toBeDefined();
       expect(loader.carLog.length).toBe(i + 1);
@@ -480,11 +503,11 @@ describe("Reopening a database", function () {
   }, 200000);
 });
 
-describe("Reopening a database with indexes", function () {
+describe("Reopening a ledger with indexes", function () {
   interface Doc {
     foo: string;
   }
-  let db: Database;
+  let db: Ledger;
   let idx: Index<string, Doc>;
   let didMap: boolean;
   let mapFn: MapFn<Doc>;
@@ -505,13 +528,13 @@ describe("Reopening a database with indexes", function () {
       didMap = true;
       return doc.foo;
     };
-    idx = index<string, Doc>(sthis, db, "foo", mapFn);
+    idx = index<string, Doc>(db, "foo", mapFn);
   });
 
   it("should persist data", async function () {
     const doc = await db.get<Doc>("test");
     expect(doc.foo).toBe("bar");
-    const idx2 = index<string, Doc>(sthis, db, "foo");
+    const idx2 = index<string, Doc>(db, "foo");
     expect(idx2).toBe(idx);
     const result = await idx2.query();
     expect(result).toBeTruthy();
@@ -522,7 +545,7 @@ describe("Reopening a database with indexes", function () {
   });
 
   it("should reuse the index", async function () {
-    const idx2 = index(sthis, db, "foo", mapFn);
+    const idx2 = index(db, "foo", mapFn);
     expect(idx2).toBe(idx);
     const result = await idx2.query();
     expect(result).toBeTruthy();
@@ -543,9 +566,9 @@ describe("Reopening a database with indexes", function () {
     const db2 = fireproof("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.crdt.clock.head).toBeTruthy();
+    expect(db2.crdt.clock.head.length).toBe(1);
+    expect(db2.crdt.clock.head).toEqual(db.crdt.clock.head);
   });
 
   it("should have the same data on reopen after a query", async function () {
@@ -558,9 +581,9 @@ describe("Reopening a database with indexes", function () {
     const db2 = fireproof("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.crdt.clock.head).toBeTruthy();
+    expect(db2.crdt.clock.head.length).toBe(1);
+    expect(db2.crdt.clock.head).toEqual(db.crdt.clock.head);
   });
 
   // it('should query the same data on reopen', async function () {
@@ -595,11 +618,11 @@ describe("basic js verify", function () {
     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.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.crdt.clock.head[0];
     expect(cid).not.toBe(cid2);
     expect(cid).not.toBe(cid2);
     const cidList = [cid, cid2];
@@ -612,8 +635,8 @@ describe("basic js verify", function () {
 });
 
 describe("same workload twice, same CID", function () {
-  let dbA: Database;
-  let dbB: Database;
+  let dbA: Ledger;
+  let dbB: Ledger;
   let headA: string;
   let headB: string;
 
@@ -621,21 +644,17 @@ describe("same workload twice, same CID", function () {
   // let configA: any;
   // let configB: any;
 
-  // const configA = {
-  //   store: {
-  //     stores: {
-  //       base: storageURL(sthis).build().setParam("storekey", "@test@"),
-  //     },
-  //   },
-  // };
-
-  // const configB = {
-  //   store: {
-  //     stores: {
-  //       base: storageURL(sthis).build().setParam("storekey", "@test@"),
-  //     },
-  //   },
-  // };
+  const configA: ConfigOpts = {
+    storeUrls: {
+      base: storageURL(sthis).build().setParam("storekey", "@test@"),
+    },
+  };
+
+  const configB: ConfigOpts = {
+    storeUrls: {
+      base: storageURL(sthis).build().setParam("storekey", "@test@"),
+    },
+  };
 
   afterEach(async function () {
     await dbA.close();
@@ -646,23 +665,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");
+    // 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);
     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.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");
+    // 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);
     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.crdt.clock.head.toString();
   });
   it("should have head A and B", async function () {
     expect(headA).toBeTruthy();
@@ -671,34 +690,34 @@ 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.crdt.blockstore.loader?.carLog;
     expect(logA).toBeTruthy();
     assert(logA);
-    expect(logA.length).toBe(38);
+    expect(logA.length).toBe(docs.length);
 
-    const logB = dbB._crdt.blockstore.loader?.carLog;
+    const logB = dbB.crdt.blockstore.loader?.carLog;
     expect(logB).toBeTruthy();
     assert(logB);
-    expect(logB.length).toBe(38);
+    expect(logB.length).toBe(docs.length);
 
     const logA2 = logA.map((c) => c.toString());
     const logB2 = logB.map((c) => c.toString());
 
     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.crdt.blockstore.loader?.carLog;
     expect(cmpLogA).toBeTruthy();
     assert(cmpLogA);
     expect(cmpLogA.length).toBe(1);
 
-    const cmpLogB = dbB._crdt.blockstore.loader?.carLog;
+    const cmpLogB = dbB.crdt.blockstore.loader?.carLog;
     expect(cmpLogB).toBeTruthy();
     assert(cmpLogB);
     expect(cmpLogB.length).toBe(1);
@@ -708,7 +727,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,31 +1,36 @@
-import { fireproof as database, Database, DocResponse, DocWithId } from "@fireproof/core";
+import { fireproof, Ledger, DocResponse, DocWithId, index, isLedger } from "@fireproof/core";
+import { mockSuperThis } from "../helpers.js";
 
 describe("Hello World Test", function () {
   it("should pass the hello world test", function () {
-    const result = database("hello"); // call to your library function
+    const result = fireproof("hello"); // call to your library function
     expect(result.name).toBe("hello");
   });
 });
 
-describe("hello public API", function () {
+describe("hello public API", () => {
   interface TestDoc {
     foo: string;
   }
-  let db: Database;
+  let db: Ledger;
   let ok: DocResponse;
   let doc: DocWithId<TestDoc>;
-  afterEach(async function () {
+  // let idx: Index<string, TestDoc>;
+  const sthis = mockSuperThis();
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
-    db = database("test-public-api");
+  beforeEach(async () => {
+    await sthis.start();
+    db = fireproof("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(db instanceof Database).toBeTruthy();
+    expect(isLedger(db)).toBeTruthy();
   });
   it("should put", function () {
     expect(ok).toBeTruthy();
@@ -34,23 +39,22 @@ describe("hello public API", function () {
   it("should get", function () {
     expect(doc.foo).toBe("bar");
   });
-  it("should get when you open it again", async function () {
+  it("should get when you open it again", async () => {
     await db.close();
-    await db.destroy();
-    const db2 = database("test-public-api");
-    doc = await db2.get("test");
+    db = fireproof("test-public-api");
+    doc = await db.get("test");
     expect(doc.foo).toBe("bar");
   });
 });
 
-describe("Simplified Reopening a database", function () {
-  let db: Database;
+describe("Simplified Reopening a ledger", function () {
+  let db: Ledger;
   afterEach(async function () {
     await db.close();
     await db.destroy();
   });
   beforeEach(async function () {
-    db = new Database("test-reopen-simple");
+    db = fireproof("test-reopen-simple");
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
@@ -62,7 +66,7 @@ describe("Simplified Reopening a database", function () {
   });
 
   it("should have the same data on reopen", async function () {
-    const db2 = new Database("test-reopen-simple");
+    const db2 = fireproof("test-reopen-simple");
     const doc = await db2.get<{ foo: string }>("test");
     expect(doc.foo).toBe("bar");
     await db2.close();