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

package/tests/fireproof/{database.test.ts → ledger.test.ts}

@@ -1,16 +1,31 @@
-import { buildBlobFiles, FileWithCid } from "../helpers.js";
-import { bs, Database, DocResponse, DocFileMeta, DocWithId, DocFiles, ensureSuperThis } from "@fireproof/core";
-
-describe("basic Database", () => {
-  let db: Database;
-  const sthis = ensureSuperThis();
+import { URI } from "@adviser/cement";
+import { buildBlobFiles, FileWithCid, mockSuperThis } from "../helpers.js";
+import {
+  bs,
+  Ledger,
+  DocResponse,
+  DocFileMeta,
+  DocWithId,
+  DocFiles,
+  toStoreURIRuntime,
+  keyConfigOpts,
+  LedgerFactory,
+  LedgerShell,
+  ensureSuperThis,
+} from "@fireproof/core";
+
+describe("basic Ledger", () => {
+  let db: Ledger;
+  const sthis = mockSuperThis();
   afterEach(async () => {
     await db.close();
     await db.destroy();
   });
   beforeEach(async () => {
     await sthis.start();
-    db = new Database();
+    db = LedgerFactory(undefined, {
+      logger: sthis.logger,
+    });
   });
   it("should put", async () => {
     /** @type {Doc} */
@@ -34,11 +49,11 @@ describe("basic Database", () => {
   });
 });
 
-describe("basic Database with record", function () {
+describe("basic Ledger with record", function () {
   interface Doc {
     readonly value: string;
   }
-  let db: Database;
+  let db: LedgerShell;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -46,7 +61,7 @@ describe("basic Database with record", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database();
+    db = LedgerFactory("factory-name") as LedgerShell;
     const ok = await db.put<Doc>({ _id: "hello", value: "world" });
     expect(ok.id).toBe("hello");
   });
@@ -78,21 +93,21 @@ describe("basic Database with record", function () {
     expect(rows[0].value._id).toBe("hello");
   });
   it("is not persisted", async function () {
-    const db2 = new Database();
+    const db2 = LedgerFactory("factory-name") as LedgerShell;
     const { rows } = await db2.changes([]);
-    expect(rows.length).toBe(0);
-    const doc = await db2.get("hello").catch((e) => e);
-    expect(doc.message).toBeTruthy();
+    expect(rows.length).toBe(1);
+    expect(db2.ref).toBe(db.ref);
+    const doc = await db2.get<Doc>("hello").catch((e) => e);
+    expect(doc.value).toBe("world");
     await db2.close();
-    await db2.destroy();
   });
 });
 
-describe("named Database with record", function () {
+describe("named Ledger with record", function () {
   interface Doc {
     readonly value: string;
   }
-  let db: Database;
+  let db: Ledger;
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
@@ -100,7 +115,7 @@ describe("named Database with record", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-db-name");
+    db = LedgerFactory("test-db-name");
     /** @type {Doc} */
     const doc = { _id: "hello", value: "world" };
     const ok = await db.put(doc);
@@ -136,7 +151,7 @@ describe("named Database with record", function () {
   it("should have a key", async function () {
     const { rows } = await db.changes([]);
     expect(rows.length).toBe(1);
-    const blocks = db._crdt.blockstore as bs.EncryptedBlockstore;
+    const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
     await loader.ready();
@@ -202,13 +217,13 @@ describe("named Database with record", function () {
   });
 });
 
-// describe('basic Database parallel writes / public', function () {
-//   /** @type {Database} */
+// describe('basic Ledger parallel writes / public', function () {
+//   /** @type {Ledger} */
 //   let db
 //   const writes = []
 //   beforeEach(async function () {
 //     await resetDirectory(dataDir, 'test-parallel-writes')
-//     db = new Database('test-parallel-writes', { public: true })
+//     db = new Ledger('test-parallel-writes', { public: true })
 //     /** @type {Doc} */
 //     for (let i = 0; i < 10; i++) {
 //       const doc = { _id: `id-${i}`, hello: 'world' }
@@ -217,28 +232,64 @@ describe("named Database with record", function () {
 //     await Promise.all(writes)
 //   })
 
-describe("basic Database parallel writes / public", function () {
-  let db: Database;
+describe("basic Ledger parallel writes / public ordered", () => {
+  let db: Ledger;
+  const writes: Promise<DocResponse>[] = [];
+  const sthis = mockSuperThis();
+  afterEach(async () => {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async () => {
+    await sthis.start();
+    db = LedgerFactory("test-parallel-writes-ordered", { writeQueue: { chunkSize: 1 } });
+    for (let i = 0; i < 10; i++) {
+      const doc = { _id: `id-${i}`, hello: "world" };
+      writes.push(db.put(doc));
+    }
+    await Promise.all(writes);
+  });
+
+  it("should have one head", () => {
+    const crdt = db.crdt;
+    expect(crdt.clock.head.length).toBe(1);
+  });
+
+  it("has changes ordered", async function () {
+    const { rows, clock } = await db.changes([]);
+    expect(clock[0]).toBe(db.crdt.clock.head[0]);
+    expect(rows.length).toBe(10);
+    for (let i = 0; i < 10; i++) {
+      expect(rows[i].key).toBe("id-" + i);
+      expect(rows[i].clock).toBeTruthy();
+    }
+  });
+});
+
+describe("basic Ledger parallel writes / public", () => {
+  let db: Ledger;
   const writes: Promise<DocResponse>[] = [];
   const sthis = ensureSuperThis();
   afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
-    db = new Database("test-parallel-writes", { public: true });
+    db = LedgerFactory("test-parallel-writes", { writeQueue: { chunkSize: 32 } });
     for (let i = 0; i < 10; i++) {
       const doc = { _id: `id-${i}`, hello: "world" };
       writes.push(db.put(doc));
     }
     await Promise.all(writes);
   });
-  it("should have one head", function () {
-    const crdt = db._crdt;
+  it("should resolve to one head", async () => {
+    const crdt = db.crdt;
+    expect(crdt.clock.head.length).toBe(9);
+    await db.put({ _id: "id-10", hello: "world" });
     expect(crdt.clock.head.length).toBe(1);
   });
-  it("should write all", async function () {
+  it("should write all", async () => {
     for (let i = 0; i < 10; i++) {
       const id = `id-${i}`;
       const doc = await db.get<{ hello: string }>(id);
@@ -270,11 +321,12 @@ describe("basic Database parallel writes / public", function () {
       expect(e.message).toMatch(/Not found/);
     }
   });
-  it("has changes", async function () {
+  it("has changes not ordered", async function () {
     const { rows, clock } = await db.changes([]);
-    expect(clock[0]).toBe(db._crdt.clock.head[0]);
+    expect(clock[0]).toBe(db.crdt.clock.head[0]);
     expect(rows.length).toBe(10);
-    // rows.sort((a, b) => a.key.localeCompare(b.key));
+    rows.sort((a, b) => a.key.localeCompare(b.key));
+    // console.log(rows);
     for (let i = 0; i < 10; i++) {
       expect(rows[i].key).toBe("id-" + i);
       expect(rows[i].clock).toBeTruthy();
@@ -283,9 +335,9 @@ describe("basic Database parallel writes / public", function () {
   it("should not have a key", async function () {
     const { rows } = await db.changes([]);
     expect(rows.length).toBe(10);
-    expect(db.opts.public).toBeTruthy();
-    expect(db._crdt.opts.public).toBeTruthy();
-    const blocks = db._crdt.blockstore as bs.EncryptedBlockstore;
+    // expect(db.opts.public).toBeTruthy();
+    // expect(db._crdt.opts.public).toBeTruthy();
+    const blocks = db.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
     await loader.ready();
@@ -294,8 +346,8 @@ describe("basic Database parallel writes / public", function () {
   });
 });
 
-describe("basic Database with subscription", function () {
-  let db: Database;
+describe("basic Ledger with subscription", function () {
+  let db: Ledger;
   let didRun: number;
   let unsubscribe: () => void;
   let lastDoc: DocWithId<NonNullable<unknown>>;
@@ -307,7 +359,7 @@ describe("basic Database with subscription", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database();
+    db = LedgerFactory("factory-name");
     didRun = 0;
     waitForSub = new Promise((resolve) => {
       unsubscribe = db.subscribe((docs) => {
@@ -340,8 +392,8 @@ describe("basic Database with subscription", function () {
   });
 });
 
-describe("basic Database with no update subscription", function () {
-  let db: Database;
+describe("basic Ledger with no update subscription", function () {
+  let db: Ledger;
   let didRun: number;
   let unsubscribe: () => void;
   const sthis = ensureSuperThis();
@@ -351,9 +403,8 @@ describe("basic Database with no update subscription", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database();
+    db = LedgerFactory("factory-name");
     didRun = 0;
-
     unsubscribe = db.subscribe(() => {
       didRun++;
     });
@@ -377,8 +428,8 @@ describe("basic Database with no update subscription", function () {
   });
 });
 
-describe("database with files input", () => {
-  let db: Database;
+describe("ledger with files input", () => {
+  let db: Ledger;
   let imagefiles: FileWithCid[] = [];
   let result: DocResponse;
   const sthis = ensureSuperThis();
@@ -390,7 +441,7 @@ describe("database with files input", () => {
   beforeEach(async function () {
     await sthis.start();
     imagefiles = await buildBlobFiles();
-    db = new Database("fireproof-with-images");
+    db = LedgerFactory("fireproof-with-images");
     const doc = {
       _id: "images-main",
       type: "files",
@@ -472,3 +523,148 @@ describe("database with files input", () => {
     expect(file.size).toBe(imagefiles[0].file.size);
   });
 });
+
+describe("StoreURIRuntime", () => {
+  const sthis = mockSuperThis();
+  let safeEnv: string | undefined;
+  let unreg: () => void;
+  beforeEach(async () => {
+    await sthis.start();
+    safeEnv = sthis.env.get("FP_STORAGE_URL");
+    sthis.env.set("FP_STORAGE_URL", "my://bla/storage");
+    unreg = bs.registerStoreProtocol({
+      protocol: "murks",
+      isDefault: true,
+      defaultURI: function (): URI {
+        return URI.from("murks://fp");
+      },
+      gateway: function (): Promise<bs.Gateway> {
+        throw new Error("Function not implemented.");
+      },
+    });
+  });
+  afterEach(() => {
+    sthis.env.set("FP_STORAGE_URL", safeEnv);
+    unreg();
+  });
+  it("default toStoreURIRuntime", () => {
+    expect(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, "test")))).toEqual({
+      data: {
+        data: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&urlGen=fromEnv",
+        meta: "my://bla/storage?name=test&store=meta&storekey=%40test-meta%40&urlGen=fromEnv",
+        wal: "my://bla/storage?name=test&store=wal&storekey=%40test-wal%40&urlGen=fromEnv",
+      },
+      idx: {
+        data: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&urlGen=fromEnv",
+        meta: "my://bla/storage?index=idx&name=test&store=meta&storekey=%40test-meta-idx%40&urlGen=fromEnv",
+        wal: "my://bla/storage?index=idx&name=test&store=wal&storekey=%40test-wal-idx%40&urlGen=fromEnv",
+      },
+    });
+    // keyConfigOpts(sthis: SuperThis, name: string, opts?: ConfigOpts): string {
+  });
+  it("no name toStoreURIRuntime", () => {
+    expect(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis)))).toEqual({
+      data: {
+        data: "my://bla/storage?name=storage&store=data&storekey=%40storage-data%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?name=storage&store=data&storekey=%40storage-data%40&urlGen=fromEnv",
+        meta: "my://bla/storage?name=storage&store=meta&storekey=%40storage-meta%40&urlGen=fromEnv",
+        wal: "my://bla/storage?name=storage&store=wal&storekey=%40storage-wal%40&urlGen=fromEnv",
+      },
+      idx: {
+        data: "my://bla/storage?index=idx&name=storage&store=data&storekey=%40storage-data-idx%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?index=idx&name=storage&store=data&storekey=%40storage-data-idx%40&urlGen=fromEnv",
+        meta: "my://bla/storage?index=idx&name=storage&store=meta&storekey=%40storage-meta-idx%40&urlGen=fromEnv",
+        wal: "my://bla/storage?index=idx&name=storage&store=wal&storekey=%40storage-wal-idx%40&urlGen=fromEnv",
+      },
+    });
+  });
+
+  it("set toStoreURIRuntime", () => {
+    expect(
+      JSON.parse(
+        JSON.stringify(
+          toStoreURIRuntime(sthis, "xxx", {
+            base: "my://storage-base",
+            data: {
+              data: "my://storage-data?name=yyy",
+              meta: "my://storage-meta",
+            },
+            idx: {
+              data: "my://storage-idx-data?name=yyy&index=bla",
+              meta: "my://storage-idx-meta",
+            },
+          }),
+        ),
+      ),
+    ).toEqual({
+      data: {
+        data: "my://storage-data?name=yyy&store=data&storekey=%40yyy-data%40&suffix=.car",
+        file: "my://storage-data?name=yyy&store=data&storekey=%40yyy-data%40",
+        meta: "my://storage-meta?name=storage-meta&store=meta&storekey=%40storage-meta-meta%40",
+        wal: "my://storage-base?name=xxx&store=wal&storekey=%40xxx-wal%40",
+      },
+      idx: {
+        data: "my://storage-idx-data?index=bla&name=yyy&store=data&storekey=%40yyy-data-idx%40&suffix=.car",
+        file: "my://storage-idx-data?index=bla&name=yyy&store=data&storekey=%40yyy-data-idx%40",
+        meta: "my://storage-idx-meta?index=idx&name=storage-idx-meta&store=meta&storekey=%40storage-idx-meta-meta-idx%40",
+        wal: "my://storage-base?index=idx&name=xxx&store=wal&storekey=%40xxx-wal-idx%40",
+      },
+    });
+  });
+
+  it("default-reg toStoreURIRuntime", () => {
+    sthis.env.delete("FP_STORAGE_URL");
+    expect(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, "maxi")))).toEqual({
+      data: {
+        data: "murks://fp?name=maxi&store=data&storekey=%40maxi-data%40&suffix=.car&urlGen=default",
+        file: "murks://fp?name=maxi&store=data&storekey=%40maxi-data%40&urlGen=default",
+        meta: "murks://fp?name=maxi&store=meta&storekey=%40maxi-meta%40&urlGen=default",
+        wal: "murks://fp?name=maxi&store=wal&storekey=%40maxi-wal%40&urlGen=default",
+      },
+      idx: {
+        data: "murks://fp?index=idx&name=maxi&store=data&storekey=%40maxi-data-idx%40&suffix=.car&urlGen=default",
+        file: "murks://fp?index=idx&name=maxi&store=data&storekey=%40maxi-data-idx%40&urlGen=default",
+        meta: "murks://fp?index=idx&name=maxi&store=meta&storekey=%40maxi-meta-idx%40&urlGen=default",
+        wal: "murks://fp?index=idx&name=maxi&store=wal&storekey=%40maxi-wal-idx%40&urlGen=default",
+      },
+    });
+  });
+
+  it("keyConfigOpts", () => {
+    expect(JSON.parse(keyConfigOpts(sthis, "test"))).toEqual([
+      {
+        name: "test",
+      },
+      {
+        stores: [
+          {
+            data: {
+              data: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&suffix=.car&urlGen=fromEnv",
+              file: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&urlGen=fromEnv",
+              meta: "my://bla/storage?name=test&store=meta&storekey=%40test-meta%40&urlGen=fromEnv",
+              wal: "my://bla/storage?name=test&store=wal&storekey=%40test-wal%40&urlGen=fromEnv",
+            },
+          },
+          {
+            idx: {
+              data: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&suffix=.car&urlGen=fromEnv",
+              file: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&urlGen=fromEnv",
+              meta: "my://bla/storage?index=idx&name=test&store=meta&storekey=%40test-meta-idx%40&urlGen=fromEnv",
+              wal: "my://bla/storage?index=idx&name=test&store=wal&storekey=%40test-wal-idx%40&urlGen=fromEnv",
+            },
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("check file protocol defaultURI", () => {
+    const gw = bs.defaultGatewayFactoryItem();
+    expect(gw.defaultURI(sthis).toString()).toBe(
+      "murks://fp",
+      // `file://${sthis.env.get("HOME")}/.fireproof/${FILESTORE_VERSION.replace(/-.*$/, "")}`,
+    );
+  });
+});

package/tests/fireproof/multiple-ledger.test.ts

@@ -1,7 +1,7 @@
-import { Database, ensureSuperThis, fireproof } from "@fireproof/core";
+import { Ledger, ensureSuperThis, fireproof } from "@fireproof/core";
 
 interface DBItem {
-  readonly db: Database;
+  readonly db: Ledger;
   readonly name: string;
 }
 

package/tests/fireproof/utils.test.ts

@@ -1,7 +1,5 @@
-import { URI } from "@adviser/cement";
-import { rt, getStore, ensureSuperLog, ensureSuperThis } from "@fireproof/core";
-
-// only for test
+import { runtimeFn, URI } from "@adviser/cement";
+import { rt, getStore, inplaceFilter, ensureSuperThis, ensureSuperLog } from "@fireproof/core";
 import { UUID } from "uuidv7";
 
 describe("utils", () => {
@@ -33,14 +31,16 @@ describe("utils", () => {
   ];
   it("getfilename plain", () => {
     for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version`);
+      const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version&suffix=${store.suffix}`);
       expect(rt.getFileName(url, logger)).toEqual(`${store.type}/key${store.suffix}`);
     }
   });
 
   it("getfilename index", () => {
     for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?index=idx&store=${store.type}&name=name&key=key&version=version`);
+      const url = URI.from(
+        `file://./x/path?index=idx&store=${store.type}&name=name&key=key&version=version&suffix=${store.suffix}`,
+      );
       expect(rt.getFileName(url, logger)).toEqual(`idx-${store.type}/key${store.suffix}`);
     }
   });
@@ -80,4 +80,45 @@ describe("utils", () => {
     const id = sthis.timeOrderedNextId(0xcafebabebeef).str;
     expect(id.slice(0, 15)).toBe("cafebabe-beef-7");
   });
+
+  it("inplaceFilter empty", () => {
+    const s: string[] = [];
+    expect(inplaceFilter(s, () => false)).toEqual([]);
+    expect(inplaceFilter(s, () => true)).toEqual([]);
+  });
+
+  it("inplaceFilter sized filtered", () => {
+    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
+    expect(inplaceFilter(s, () => false)).toEqual([]);
+  });
+  it("inplaceFilter sized unfiltered", () => {
+    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
+    const ref = [...s];
+    expect(inplaceFilter(s, () => true)).toEqual(ref);
+  });
+
+  it("inplaceFilter sized mod 7", () => {
+    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
+    const ref = [...s];
+    for (let i = 99; i >= 0; i--) {
+      if (!(i % 7)) {
+        ref.splice(i, 1);
+      }
+    }
+    expect(inplaceFilter(s, (_, j) => !!(j % 7))).toEqual(ref);
+    expect(s.length).toBe(85);
+  });
+});
+
+describe("runtime", () => {
+  it("runtime", () => {
+    const isNode = !!(typeof process === "object" && process.versions?.node);
+    expect(runtimeFn()).toEqual({
+      isBrowser: !isNode,
+      isCFWorker: false,
+      isDeno: false,
+      isNodeIsh: isNode,
+      isReactNative: false,
+    });
+  });
 });