@fireproof/core 0.19.101 → 0.19.103

package/tests/fireproof/fireproof.test.ts

@@ -1,21 +1,8 @@
-import { mockSuperThis, sleep, storageURL } from "../helpers.js";
-import { docs } from "./fireproof.fixture.js";
+import { mockSuperThis, sleep } from "../helpers.js";
+import { docs } from "./fireproof.test.fixture.js";
 import { CID } from "multiformats/cid";
 
-import {
-  ConfigOpts,
-  Database,
-  DatabaseFactory,
-  DocResponse,
-  DocWithId,
-  Index,
-  IndexRows,
-  MapFn,
-  bs,
-  fireproof,
-  index,
-  isDatabase,
-} from "@fireproof/core";
+import { Database, DocResponse, DocWithId, Index, IndexRows, MapFn, bs, fireproof, index } from "@fireproof/core";
 
 export function carLogIncludesGroup(list: bs.AnyLink[], cid: CID) {
   return list.some((c) => c.equals(cid));
@@ -97,7 +84,7 @@ describe("public API", function () {
   });
   it("should be a database instance", function () {
     expect(db).toBeTruthy();
-    expect(isDatabase(db)).toBeTruthy();
+    expect(db instanceof Database).toBeTruthy();
   });
   it("should put", function () {
     expect(ok).toBeTruthy();
@@ -126,7 +113,7 @@ describe("basic database", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-basic");
+    db = new Database("test-basic");
   });
   it("can put with id", async function () {
     const ok = await db.put({ _id: "test", foo: "bar" });
@@ -142,7 +129,7 @@ describe("basic database", function () {
   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 }>(db, "test-index", (doc) => doc.foo);
+    const idx = index<string, { foo: string }>(sthis, db, "test-index", (doc) => doc.foo);
     const result = await idx.query();
     expect(result).toBeTruthy();
     expect(result.rows).toBeTruthy();
@@ -152,7 +139,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(db, "foo");
+    const idx = index(sthis, db, "foo");
     const result = await idx.query();
     expect(result).toBeTruthy();
     expect(result.rows).toBeTruthy();
@@ -191,14 +178,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 = new Database("test-benchmark-compaction", { autoCompact: 3 });
   });
-  it.skip("insert during compaction", async function () {
+  it("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;
@@ -219,7 +206,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();
 
@@ -246,8 +233,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 = new Database("test-benchmark", { autoCompact: 100000, public: true });
+    // db = new Database(null, {autoCompact: 100000})
   });
 
   // run benchmarking tests
@@ -260,8 +247,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;
@@ -297,7 +284,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 = new Database("test-benchmark", { autoCompact: 100000, public: true });
     const doc = await newDb.get<{ foo: string }>("test");
     expect(doc.foo).toBe("fast");
     // console.timeEnd("open new DB");
@@ -327,7 +314,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);
@@ -339,10 +326,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 = new Database("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();
 
@@ -405,13 +392,13 @@ describe("Reopening a database", function () {
     // erase the existing test data
     await sthis.start();
 
-    db = DatabaseFactory("test-reopen", { autoCompact: 100000 });
+    db = new Database("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 () {
@@ -420,18 +407,18 @@ describe("Reopening a database", function () {
   });
 
   it("should have the same data on reopen", async function () {
-    const db2 = DatabaseFactory("test-reopen");
+    const db2 = new Database("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();
@@ -439,9 +426,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 = new Database("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();
@@ -452,10 +439,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 = new Database("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) });
@@ -471,11 +458,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 = new Database("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);
@@ -518,13 +505,13 @@ describe("Reopening a database with indexes", function () {
       didMap = true;
       return doc.foo;
     };
-    idx = index<string, Doc>(db, "foo", mapFn);
+    idx = index<string, Doc>(sthis, 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>(db, "foo");
+    const idx2 = index<string, Doc>(sthis, db, "foo");
     expect(idx2).toBe(idx);
     const result = await idx2.query();
     expect(result).toBeTruthy();
@@ -535,7 +522,7 @@ describe("Reopening a database with indexes", function () {
   });
 
   it("should reuse the index", async function () {
-    const idx2 = index(db, "foo", mapFn);
+    const idx2 = index(sthis, db, "foo", mapFn);
     expect(idx2).toBe(idx);
     const result = await idx2.query();
     expect(result).toBeTruthy();
@@ -556,9 +543,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 () {
@@ -571,9 +558,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 () {
@@ -608,11 +595,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];
@@ -634,17 +621,21 @@ describe("same workload twice, same CID", function () {
   // let configA: any;
   // let configB: any;
 
-  const configA: ConfigOpts = {
-    storeUrls: {
-      base: storageURL(sthis).build().setParam("storekey", "@test@"),
-    },
-  };
-
-  const configB: ConfigOpts = {
-    storeUrls: {
-      base: storageURL(sthis).build().setParam("storekey", "@test@"),
-    },
-  };
+  // const configA = {
+  //   store: {
+  //     stores: {
+  //       base: storageURL(sthis).build().setParam("storekey", "@test@"),
+  //     },
+  //   },
+  // };
+
+  // const configB = {
+  //   store: {
+  //     stores: {
+  //       base: storageURL(sthis).build().setParam("storekey", "@test@"),
+  //     },
+  //   },
+  // };
 
   afterEach(async function () {
     await dbA.close();
@@ -656,22 +647,22 @@ describe("same workload twice, same CID", 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);
+    dbA = fireproof("test-dual-workload-a");
     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", configB);
+    dbB = fireproof("test-dual-workload-b");
     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();
@@ -680,15 +671,15 @@ 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(docs.length);
+    expect(logA.length).toBe(38);
 
-    const logB = dbB.crdt.blockstore.loader?.carLog;
+    const logB = dbB._crdt.blockstore.loader?.carLog;
     expect(logB).toBeTruthy();
     assert(logB);
-    expect(logB.length).toBe(docs.length);
+    expect(logB.length).toBe(38);
 
     const logA2 = logA.map((c) => c.toString());
     const logB2 = logB.map((c) => c.toString());
@@ -702,12 +693,12 @@ describe("same workload twice, same CID", 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);

package/tests/fireproof/hello.test.ts

@@ -1,36 +1,31 @@
-import { fireproof, Database, DocResponse, DocWithId, index, isDatabase } from "@fireproof/core";
-import { mockSuperThis } from "../helpers";
+import { fireproof as database, Database, DocResponse, DocWithId } from "@fireproof/core";
 
 describe("Hello World Test", function () {
   it("should pass the hello world test", function () {
-    const result = fireproof("hello"); // call to your library function
-    expect(result.name()).toBe("hello");
+    const result = database("hello"); // call to your library function
+    expect(result.name).toBe("hello");
   });
 });
 
-describe("hello public API", () => {
+describe("hello public API", function () {
   interface TestDoc {
     foo: string;
   }
   let db: Database;
   let ok: DocResponse;
   let doc: DocWithId<TestDoc>;
-  // let idx: Index<string, TestDoc>;
-  const sthis = mockSuperThis();
-  afterEach(async () => {
+  afterEach(async function () {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-public-api");
-    index<string, TestDoc>(db, "test-index", (doc) => doc.foo);
+  beforeEach(async function () {
+    db = database("test-public-api");
     ok = await db.put({ _id: "test", foo: "bar" });
     doc = await db.get("test");
   });
   it("should have a database", function () {
     expect(db).toBeTruthy();
-    expect(isDatabase(db)).toBeTruthy();
+    expect(db instanceof Database).toBeTruthy();
   });
   it("should put", function () {
     expect(ok).toBeTruthy();
@@ -39,10 +34,11 @@ describe("hello public API", () => {
   it("should get", function () {
     expect(doc.foo).toBe("bar");
   });
-  it("should get when you open it again", async () => {
+  it("should get when you open it again", async function () {
     await db.close();
-    db = fireproof("test-public-api");
-    doc = await db.get("test");
+    await db.destroy();
+    const db2 = database("test-public-api");
+    doc = await db2.get("test");
     expect(doc.foo).toBe("bar");
   });
 });
@@ -54,7 +50,7 @@ describe("Simplified Reopening a database", function () {
     await db.destroy();
   });
   beforeEach(async function () {
-    db = fireproof("test-reopen-simple");
+    db = new Database("test-reopen-simple");
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
@@ -66,7 +62,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 = new Database("test-reopen-simple");
     const doc = await db2.get<{ foo: string }>("test");
     expect(doc.foo).toBe("bar");
     await db2.close();