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

package/tests/fireproof/crdt.test.ts

@@ -1,4 +1,4 @@
-import { CRDT, ensureSuperThis } from "@fireproof/core";
+import { CRDT, defaultWriteQueueOpts, ensureSuperThis, DatabaseOpts, toStoreURIRuntime, rt } from "@fireproof/core";
 import { bs } from "@fireproof/core";
 import { CRDTMeta, DocValue } from "@fireproof/core";
 import { Index, index } from "@fireproof/core";
@@ -12,7 +12,13 @@ describe("Fresh crdt", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis);
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-crdt-cold"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
   });
   it("should have an empty head", async function () {
     const head = crdt.clock.head;
@@ -49,7 +55,13 @@ describe("CRDT with one record", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis, `test@${sthis.nextId()}`);
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, `test@${sthis.nextId().str}`),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     firstPut = await crdt.bulk([{ id: "hello", value: { hello: "world" } }]);
   });
   it("should have a one-element head", async function () {
@@ -99,7 +111,13 @@ describe("CRDT with a multi-write", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis);
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-crdt-cold"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     firstPut = await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
@@ -164,7 +182,13 @@ describe("CRDT with two multi-writes", function () {
   });
   beforeEach(async () => {
     await sthis.start();
-    crdt = new CRDT(sthis);
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, `test-multiple-writes@${sthis.nextId().str}`),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     firstPut = await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
@@ -212,7 +236,13 @@ describe("Compact a named CRDT with writes", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis, "named-crdt-compaction");
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, `named-crdt-compaction`),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     for (let i = 0; i < 10; i++) {
       const bulk = [
         { id: "ace", value: { points: 11 } },
@@ -268,12 +298,18 @@ describe("CRDT with an index", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT<CRDTTestType>(sthis);
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-crdt-cold"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT<CRDTTestType>(sthis, dbOpts);
     await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
     ]);
-    idx = await index<number, CRDTTestType>(sthis, { _crdt: crdt }, "points");
+    idx = await index<number, CRDTTestType>({ crdt: crdt }, "points");
   });
   it("should query the data", async function () {
     const got = await idx.query({ range: [9, 12] });
@@ -282,7 +318,7 @@ describe("CRDT with an index", function () {
     expect(got.rows[0].key).toBe(10);
   });
   it("should register the index", async function () {
-    const rIdx = await index<number, CRDTTestType>(sthis, { _crdt: crdt }, "points");
+    const rIdx = await index<number, CRDTTestType>({ crdt: crdt }, "points");
     expect(rIdx).toBeTruthy();
     expect(rIdx.name).toBe("points");
     const got = await rIdx.query({ range: [9, 12] });
@@ -291,7 +327,7 @@ describe("CRDT with an index", function () {
     expect(got.rows[0].key).toBe(10);
   });
   it("creating a different index with same name should not work", async function () {
-    const e = await index(sthis, { _crdt: crdt }, "points", (doc) => doc._id)
+    const e = await index({ crdt: crdt }, "points", (doc) => doc._id)
       .query()
       .catch((err) => err);
     expect(e.message).toMatch(/cannot apply/);
@@ -314,15 +350,26 @@ describe("Loader with a committed transaction", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis, dbname);
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, dbname),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     blockstore = crdt.blockstore as bs.EncryptedBlockstore;
     expect(blockstore.loader).toBeTruthy();
-    loader = blockstore.loader;
+    loader = blockstore.loader as bs.Loader;
     done = await crdt.bulk([{ id: "foo", value: { foo: "bar" } }]);
   });
-  it("should have a name", function () {
-    expect(loader.name).toBe(dbname);
-  });
+  // it("should have a name", function () {
+  //   expect(loader.ebOpts.storeUrls).toEqual({
+  //     data: "file://./dist/fp-dir-file?name=test-loader&store=data&storekey=%40test-loader-data%40&suffix=.car&urlGen=fromEnv",
+  //     file: "file://./dist/fp-dir-file?name=test-loader&store=data&storekey=%40test-loader-data%40&urlGen=fromEnv",
+  //     meta: "file://./dist/fp-dir-file?name=test-loader&store=meta&storekey=%40test-loader-meta%40&urlGen=fromEnv",
+  //     wal: "file://./dist/fp-dir-file?name=test-loader&store=wal&storekey=%40test-loader-wal%40&urlGen=fromEnv",
+  //   });
+  // });
   it("should commit a transaction", function () {
     expect(done.head).toBeTruthy();
     // expect(done.cars).toBeTruthy();
@@ -357,10 +404,16 @@ describe("Loader with two committed transactions", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis, "test-loader");
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-loader"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     blockstore = crdt.blockstore as bs.EncryptedBlockstore;
     expect(blockstore.loader).toBeTruthy();
-    loader = blockstore.loader;
+    loader = blockstore.loader as bs.Loader;
     done1 = await crdt.bulk([{ id: "apple", value: { foo: "bar" } }]);
     done2 = await crdt.bulk([{ id: "orange", value: { foo: "bar" } }]);
   });
@@ -407,10 +460,16 @@ describe("Loader with many committed transactions", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    crdt = new CRDT(sthis, "test-loader-many");
+    const dbOpts: DatabaseOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-loader-many"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT(sthis, dbOpts);
     blockstore = crdt.blockstore as bs.EncryptedBlockstore;
     expect(blockstore.loader).toBeTruthy();
-    loader = blockstore.loader;
+    loader = blockstore.loader as bs.Loader;
     dones = [];
     for (let i = 0; i < count; i++) {
       const did = await crdt.bulk([{ id: `apple${i}`, value: { foo: "bar" } }]);

package/tests/fireproof/database.test.ts

@@ -1,16 +1,31 @@
-import { buildBlobFiles, FileWithCid } from "../helpers.js";
-import { bs, Database, DocResponse, DocFileMeta, DocWithId, DocFiles, ensureSuperThis } from "@fireproof/core";
+import { URI } from "@adviser/cement";
+import { buildBlobFiles, FileWithCid, mockSuperThis } from "../helpers.js";
+import {
+  bs,
+  Database,
+  DocResponse,
+  DocFileMeta,
+  DocWithId,
+  DocFiles,
+  toStoreURIRuntime,
+  keyConfigOpts,
+  DatabaseFactory,
+  DatabaseShell,
+  ensureSuperThis,
+} from "@fireproof/core";
 
 describe("basic Database", () => {
   let db: Database;
-  const sthis = ensureSuperThis();
+  const sthis = mockSuperThis();
   afterEach(async () => {
     await db.close();
     await db.destroy();
   });
   beforeEach(async () => {
     await sthis.start();
-    db = new Database();
+    db = DatabaseFactory(undefined, {
+      logger: sthis.logger,
+    });
   });
   it("should put", async () => {
     /** @type {Doc} */
@@ -38,7 +53,7 @@ describe("basic Database with record", function () {
   interface Doc {
     readonly value: string;
   }
-  let db: Database;
+  let db: DatabaseShell;
   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 = DatabaseFactory("factory-name") as DatabaseShell;
     const ok = await db.put<Doc>({ _id: "hello", value: "world" });
     expect(ok.id).toBe("hello");
   });
@@ -78,13 +93,13 @@ 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 = DatabaseFactory("factory-name") as DatabaseShell;
     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();
   });
 });
 
@@ -100,7 +115,7 @@ describe("named Database with record", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-db-name");
+    db = DatabaseFactory("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();
@@ -217,7 +232,41 @@ describe("named Database with record", function () {
 //     await Promise.all(writes)
 //   })
 
-describe("basic Database parallel writes / public", function () {
+describe("basic Database parallel writes / public ordered", () => {
+  let db: Database;
+  const writes: Promise<DocResponse>[] = [];
+  const sthis = mockSuperThis();
+  afterEach(async () => {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async () => {
+    await sthis.start();
+    db = DatabaseFactory("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 Database parallel writes / public", () => {
   let db: Database;
   const writes: Promise<DocResponse>[] = [];
   const sthis = ensureSuperThis();
@@ -225,20 +274,22 @@ describe("basic Database parallel writes / public", function () {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     await sthis.start();
-    db = new Database("test-parallel-writes", { public: true });
+    db = DatabaseFactory("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();
@@ -307,7 +359,7 @@ describe("basic Database with subscription", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database();
+    db = DatabaseFactory("factory-name");
     didRun = 0;
     waitForSub = new Promise((resolve) => {
       unsubscribe = db.subscribe((docs) => {
@@ -351,9 +403,8 @@ describe("basic Database with no update subscription", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database();
+    db = DatabaseFactory("factory-name");
     didRun = 0;
-
     unsubscribe = db.subscribe(() => {
       didRun++;
     });
@@ -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 = DatabaseFactory("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(/-.*$/, "")}`,
+    );
+  });
+});