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

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) {
@@ -96,7 +95,7 @@ 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(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("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("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("test-benchmark", { autoCompact: 100000, public: true });
+    // db = fireproof(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("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("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("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("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("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("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("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;
   }
@@ -566,9 +564,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.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 () {
@@ -581,9 +579,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.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 () {
@@ -618,11 +616,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.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
+    // 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.ledger.crdt.clock.head.toString();
 
-    // 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
     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.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,4 +1,4 @@
-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 () {
@@ -28,7 +28,7 @@ describe("hello public API", () => {
     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();
   });
@@ -47,7 +47,7 @@ describe("hello public API", () => {
   });
 });
 
-describe("Simplified Reopening a database", function () {
+describe("Simplified Reopening a ledger", function () {
   let db: Database;
   afterEach(async function () {
     await db.close();

package/tests/fireproof/indexer.test.ts

@@ -1,16 +1,17 @@
 import {
   Index,
   index,
-  Database,
   CRDT,
   IndexRows,
   toStoreURIRuntime,
   bs,
   rt,
-  DatabaseFactory,
   defaultWriteQueueOpts,
   ensureSuperThis,
-  DatabaseOpts,
+  LedgerOpts,
+  Database,
+  CRDTImpl,
+  fireproof,
 } from "@fireproof/core";
 
 interface TestType {
@@ -19,7 +20,7 @@ interface TestType {
 }
 
 describe("basic Index", () => {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<string, TestType>;
   let didMap: boolean;
   const sthis = ensureSuperThis();
@@ -31,18 +32,18 @@ describe("basic Index", () => {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
+    db = fireproof("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db.crdt, "hello", (doc) => {
+    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
       didMap = true;
       return doc.title;
     });
     await indexer.ready();
   });
   it("should have properties", function () {
-    expect(indexer.crdt).toBe(db.crdt);
+    expect(indexer.crdt).toBe(db.ledger.crdt);
     // expect(indexer.crdt.name).toBe("test-indexer");
     expect(indexer.name).toBe("hello");
     expect(indexer.mapFn).toBeTruthy();
@@ -107,7 +108,7 @@ describe("basic Index", () => {
 });
 
 describe("Index query with compound key", function () {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<[string, number], TestType>;
   const sthis = ensureSuperThis();
   afterEach(async function () {
@@ -118,12 +119,12 @@ describe("Index query with compound key", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
+    db = fireproof("test-indexer");
     await db.put({ title: "amazing", score: 1 });
     await db.put({ title: "creative", score: 2 });
     await db.put({ title: "creative", score: 20 });
     await db.put({ title: "bazillas", score: 3 });
-    indexer = new Index<[string, number], TestType>(sthis, db.crdt, "hello", (doc) => {
+    indexer = new Index<[string, number], TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
       return [doc.title, doc.score];
     });
     await indexer.ready();
@@ -137,7 +138,7 @@ describe("Index query with compound key", function () {
 });
 
 describe("basic Index with map fun", function () {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<string, TestType>;
   const sthis = ensureSuperThis();
   afterEach(async function () {
@@ -148,11 +149,11 @@ describe("basic Index with map fun", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
+    db = fireproof("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db.crdt, "hello", (doc, map) => {
+    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "hello", (doc, map) => {
       map(doc.title);
     });
     await indexer.ready();
@@ -167,7 +168,7 @@ describe("basic Index with map fun", function () {
 });
 
 describe("basic Index with map fun with value", function () {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<string, TestType, number>;
   const sthis = ensureSuperThis();
   afterEach(async function () {
@@ -176,11 +177,11 @@ describe("basic Index with map fun with value", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
+    db = fireproof("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType, number>(sthis, db.crdt, "hello", (doc, map) => {
+    indexer = new Index<string, TestType, number>(sthis, db.ledger.crdt, "hello", (doc, map) => {
       map(doc.title, doc.title.length);
     });
   });
@@ -205,7 +206,7 @@ describe("basic Index with map fun with value", function () {
 });
 
 describe("Index query with map and compound key", function () {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<[string, number], TestType>;
   const sthis = ensureSuperThis();
   afterEach(async function () {
@@ -216,12 +217,12 @@ describe("Index query with map and compound key", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
+    db = fireproof("test-indexer");
     await db.put({ title: "amazing", score: 1 });
     await db.put({ title: "creative", score: 2 });
     await db.put({ title: "creative", score: 20 });
     await db.put({ title: "bazillas", score: 3 });
-    indexer = new Index<[string, number], TestType>(sthis, db.crdt, "hello", (doc, emit) => {
+    indexer = new Index<[string, number], TestType>(sthis, db.ledger.crdt, "hello", (doc, emit) => {
       emit([doc.title, doc.score]);
     });
     await indexer.ready();
@@ -235,7 +236,7 @@ describe("Index query with map and compound key", function () {
 });
 
 describe("basic Index with string fun", function () {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<string, TestType>;
   const sthis = ensureSuperThis();
   afterEach(async function () {
@@ -246,11 +247,11 @@ describe("basic Index with string fun", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
+    db = fireproof("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index(sthis, db.crdt, "title");
+    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "title");
     await indexer.ready();
   });
   it("should get results", async function () {
@@ -271,13 +272,13 @@ describe("basic Index upon cold start", function () {
     title: string;
     score?: number;
   }
-  let crdt: CRDT<TestType>;
+  let crdt: CRDT;
   let indexer: Index<string, TestType>;
   let didMap: number;
   let mapFn: (doc: TestType) => string;
   let result: IndexRows<string, TestType>;
   const sthis = ensureSuperThis();
-  let dbOpts: DatabaseOpts;
+  let dbOpts: LedgerOpts;
   // result, mapFn;
   afterEach(async function () {
     await crdt.close();
@@ -295,7 +296,7 @@ describe("basic Index upon cold start", function () {
       storeUrls: toStoreURIRuntime(sthis, "test-indexer-cold"),
       storeEnDe: bs.ensureStoreEnDeFile({}),
     };
-    crdt = new CRDT<TestType>(sthis, dbOpts);
+    crdt = new CRDTImpl(sthis, dbOpts);
     await crdt.bulk([
       { id: "abc1", value: { title: "amazing" } },
       { id: "abc2", value: { title: "creative" } },
@@ -307,7 +308,7 @@ describe("basic Index upon cold start", function () {
       didMap++;
       return doc.title;
     };
-    indexer = await index<string, TestType>({ crdt: crdt }, "hello", mapFn);
+    indexer = await index<string, TestType>(crdt, "hello", mapFn);
     logger.Debug().Msg("post index beforeEach");
     await indexer.ready();
     logger.Debug().Msg("post indexer.ready beforeEach");
@@ -327,12 +328,12 @@ describe("basic Index upon cold start", function () {
     expect(result.rows.length).toEqual(3);
   });
   it("should work on cold load", async function () {
-    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
+    const crdt2 = new CRDTImpl(sthis, dbOpts);
     await crdt2.ready();
     const { result, head } = await crdt2.changes();
     expect(result).toBeTruthy();
     await crdt2.ready();
-    const indexer2 = await index<string, TestType>({ crdt: crdt2 }, "hello", mapFn);
+    const indexer2 = await index<string, TestType>(crdt2, "hello", mapFn);
     await indexer2.ready();
     const result2 = await indexer2.query();
     expect(indexer2.indexHead).toEqual(head);
@@ -342,8 +343,8 @@ describe("basic Index upon cold start", function () {
   });
   it.skip("should not rerun the map function on seen changes", async function () {
     didMap = 0;
-    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
-    const indexer2 = await index({ crdt: crdt2 }, "hello", mapFn);
+    const crdt2 = new CRDTImpl(sthis, dbOpts);
+    const indexer2 = await index(crdt2, "hello", mapFn);
     const { result, head } = await crdt2.changes([]);
     expect(result.length).toEqual(3);
     expect(head.length).toEqual(1);
@@ -367,15 +368,15 @@ describe("basic Index upon cold start", function () {
     expect(didMap).toEqual(1);
   });
   it("should ignore meta when map function definiton changes", async function () {
-    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
-    const result = await index<string, TestType>({ crdt: crdt2 }, "hello", (doc) => doc.title.split("").reverse().join("")).query();
+    const crdt2 = new CRDTImpl(sthis, dbOpts);
+    const result = await index<string, TestType>(crdt2, "hello", (doc) => doc.title.split("").reverse().join("")).query();
     expect(result.rows.length).toEqual(3);
     expect(result.rows[0].key).toEqual("evitaerc"); // creative
   });
 });
 
 describe("basic Index with no data", function () {
-  let db: Database<TestType>;
+  let db: Database;
   let indexer: Index<string, TestType>;
   let didMap: boolean;
   const sthis = ensureSuperThis();
@@ -387,15 +388,15 @@ describe("basic Index with no data", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-indexer");
-    indexer = new Index<string, TestType>(sthis, db.crdt, "hello", (doc) => {
+    db = fireproof("test-indexer");
+    indexer = new Index<string, TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
       didMap = true;
       return doc.title;
     });
     await indexer.ready();
   });
   it("should have properties", function () {
-    expect(indexer.crdt).toEqual(db.crdt);
+    expect(indexer.crdt).toEqual(db.ledger.crdt);
     expect(indexer.name).toEqual("hello");
     expect(indexer.mapFn).toBeTruthy();
   });