@fireproof/core 0.19.101 → 0.19.102

package/tests/fireproof/config.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { dataDir, fireproof, rt } from "@fireproof/core";
+import { runtimeFn, URI } from "@adviser/cement";
+import { mockSuperThis } from "../helpers";
+
+describe("runtime", () => {
+  it("runtime", () => {
+    const isNode = !!(typeof process === "object" && process.versions?.node);
+    expect(runtimeFn()).toEqual({
+      isBrowser: !isNode,
+      isDeno: false,
+      isNodeIsh: isNode,
+      isReactNative: false,
+    });
+  });
+});
+
+describe("fireproof/config", () => {
+  let _my_app = "my-app";
+  function my_app() {
+    return _my_app;
+  }
+  function params(store: string) {
+    return Object.entries({
+      store,
+      name: my_app(),
+      storekey: `@${my_app()}:${store}@`,
+      version: rt.FILESTORE_VERSION,
+    });
+  }
+  const sthis = mockSuperThis();
+  beforeAll(async () => {
+    await sthis.start();
+    if (runtimeFn().isNodeIsh) {
+      const fpStorageUrl = sthis.env.get("FP_STORAGE_URL");
+      if (fpStorageUrl) {
+        const url = URI.from(fpStorageUrl);
+        _my_app = `my-app-${url.protocol.replace(/:$/, "")}:${url.getParam("fs") || "fs"}`;
+      }
+    }
+  });
+
+  if (!runtimeFn().isNodeIsh) {
+    it("default", async () => {
+      const db = fireproof(my_app());
+      await db.put({ name: "my-app" });
+      expect(db.name).toBe(my_app());
+
+      const fileStore = await db.blockstore.loader?.fileStore();
+      expect(fileStore?.url().toString()).toMatch(
+        new RegExp(`indexdb://fp\\?name=my-app&store=data&storekey=%40my-app%3Adata%40&version=${rt.INDEXDB_VERSION}`),
+      );
+      const metaStore = await db.blockstore.loader?.metaStore();
+      expect(metaStore?.url().toString()).toMatch(
+        new RegExp(`indexdb://fp\\?name=my-app&store=meta&storekey=%40my-app%3Ameta%40&version=${rt.INDEXDB_VERSION}`),
+      );
+
+      const carStore = await db.blockstore.loader?.carStore();
+      expect(carStore?.url().toString()).toMatch(
+        new RegExp(`indexdb://fp\\?name=my-app&store=data&storekey=%40my-app%3Adata%40&version=${rt.INDEXDB_VERSION}`),
+      );
+
+      await db.close();
+    });
+    return;
+  }
+  it("node default", async () => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    sthis.env.delete("FP_STORAGE_URL");
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, rt.FILESTORE_VERSION, my_app());
+
+    const sysfs = await rt.getFileSystem(URI.from(baseDir));
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    expect(baseDir).toMatch(new RegExp(`/\\.fireproof/${rt.FILESTORE_VERSION}/${my_app()}`));
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+
+    for (const [param, value] of Object.entries({
+      store: "data",
+      name: my_app(),
+      storekey: `@${my_app()}:data@`,
+      version: rt.FILESTORE_VERSION,
+    })) {
+      expect(carStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+
+    const fileStore = await db.blockstore.loader?.fileStore();
+    for (const [param, value] of params("data")) {
+      expect(fileStore?.url().getParam(param)).toBe(value);
+    }
+    const metaStore = await db.blockstore.loader?.metaStore();
+    for (const [param, value] of params("meta")) {
+      expect(metaStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    sthis.env.set("FP_STORAGE_URL", old);
+    await db.close();
+  });
+
+  it("set by env", async () => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    const testUrl = URI.merge(`./dist/env`, old);
+    sthis.env.set("FP_STORAGE_URL", testUrl.toString());
+
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, rt.FILESTORE_VERSION, my_app());
+
+    const sysfs = await rt.getFileSystem(testUrl);
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    for (const [param, value] of params("data")) {
+      expect(carStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const fileStore = await db.blockstore.loader?.fileStore();
+    for (const [param, value] of params("data")) {
+      expect(fileStore?.url().getParam(param)).toBe(value);
+    }
+    const metaStore = await db.blockstore.loader?.metaStore();
+    for (const [param, value] of params("meta")) {
+      expect(metaStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+    sthis.env.set("FP_STORAGE_URL", old);
+  });
+
+  it("file path", async () => {
+    let baseDir = "./dist/data".replace(/\?.*$/, "").replace(/^file:\/\//, "");
+    baseDir = sthis.pathOps.join(baseDir, rt.FILESTORE_VERSION, my_app());
+
+    const base = "./dist/data";
+    const sysfs = await rt.getFileSystem(URI.from(base));
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), { store: { stores: { base } } });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    for (const [param, value] of params("data")) {
+      expect(carStore?.url().getParam(param)).toBe(value);
+    }
+    const fileStore = await db.blockstore.loader?.fileStore();
+    for (const [param, value] of params("data")) {
+      expect(fileStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const metaStore = await db.blockstore.loader?.metaStore();
+    for (const [param, value] of params("meta")) {
+      expect(metaStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+  });
+});

package/tests/fireproof/crdt.test.ts

@@ -1,9 +1,8 @@
-import { CRDT, DatabaseOpts, toStoreURIRuntime } from "@fireproof/core";
+import { CRDT } from "@fireproof/core";
 import { bs } from "@fireproof/core";
 import { CRDTMeta, DocValue } from "@fireproof/core";
 import { Index, index } from "@fireproof/core";
 import { mockSuperThis } from "../helpers";
-import { defaultKeyBagOpts } from "../../src/runtime/key-bag";
 
 describe("Fresh crdt", function () {
   let crdt: CRDT<{ hello: string } | { points: number }>;
@@ -14,12 +13,7 @@ describe("Fresh crdt", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, "test-crdt-cold"),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis);
   });
   it("should have an empty head", async function () {
     const head = crdt.clock.head;
@@ -56,12 +50,7 @@ describe("CRDT with one record", function () {
 
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, `test@${sthis.nextId()}`),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis, `test@${sthis.nextId()}`);
     firstPut = await crdt.bulk([{ id: "hello", value: { hello: "world" } }]);
   });
   it("should have a one-element head", async function () {
@@ -111,12 +100,7 @@ describe("CRDT with a multi-write", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, "test-crdt-cold"),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis);
     firstPut = await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
@@ -181,12 +165,7 @@ describe("CRDT with two multi-writes", function () {
   });
   beforeEach(async () => {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, `test-multiple-writes@${sthis.nextId()}`),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis);
     firstPut = await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
@@ -234,12 +213,7 @@ describe("Compact a named CRDT with writes", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, `named-crdt-compaction`),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis, "named-crdt-compaction");
     for (let i = 0; i < 10; i++) {
       const bulk = [
         { id: "ace", value: { points: 11 } },
@@ -295,17 +269,12 @@ describe("CRDT with an index", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, "test-crdt-cold"),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT<CRDTTestType>(sthis, dbOpts);
+    crdt = new CRDT<CRDTTestType>(sthis);
     await crdt.bulk([
       { id: "ace", value: { points: 11 } },
       { id: "king", value: { points: 10 } },
     ]);
-    idx = await index<number, CRDTTestType>({ crdt: crdt }, "points");
+    idx = await index<number, CRDTTestType>(sthis, { _crdt: crdt }, "points");
   });
   it("should query the data", async function () {
     const got = await idx.query({ range: [9, 12] });
@@ -314,7 +283,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>({ crdt: crdt }, "points");
+    const rIdx = await index<number, CRDTTestType>(sthis, { _crdt: crdt }, "points");
     expect(rIdx).toBeTruthy();
     expect(rIdx.name).toBe("points");
     const got = await rIdx.query({ range: [9, 12] });
@@ -323,7 +292,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({ crdt: crdt }, "points", (doc) => doc._id)
+    const e = await index(sthis, { _crdt: crdt }, "points", (doc) => doc._id)
       .query()
       .catch((err) => err);
     expect(e.message).toMatch(/cannot apply/);
@@ -346,25 +315,15 @@ describe("Loader with a committed transaction", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, dbname),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis, dbname);
     blockstore = crdt.blockstore as bs.EncryptedBlockstore;
     expect(blockstore.loader).toBeTruthy();
     loader = blockstore.loader;
     done = await crdt.bulk([{ id: "foo", value: { foo: "bar" } }]);
   });
-  // 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 have a name", function () {
+    expect(loader.name).toBe(dbname);
+  });
   it("should commit a transaction", function () {
     expect(done.head).toBeTruthy();
     // expect(done.cars).toBeTruthy();
@@ -399,12 +358,7 @@ describe("Loader with two committed transactions", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, "test-loader"),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis, "test-loader");
     blockstore = crdt.blockstore as bs.EncryptedBlockstore;
     expect(blockstore.loader).toBeTruthy();
     loader = blockstore.loader;
@@ -454,12 +408,7 @@ describe("Loader with many committed transactions", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    const dbOpts: DatabaseOpts = {
-      keyBag: defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, "test-loader-many"),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-    };
-    crdt = new CRDT(sthis, dbOpts);
+    crdt = new CRDT(sthis, "test-loader-many");
     blockstore = crdt.blockstore as bs.EncryptedBlockstore;
     expect(blockstore.loader).toBeTruthy();
     loader = blockstore.loader;

package/tests/fireproof/database.test.ts

@@ -1,19 +1,5 @@
-import { URI } from "@adviser/cement";
 import { buildBlobFiles, FileWithCid, mockSuperThis } from "../helpers.js";
-import {
-  bs,
-  Database,
-  DocResponse,
-  DocFileMeta,
-  DocWithId,
-  DocFiles,
-  toStoreURIRuntime,
-  keyConfigOpts,
-  DatabaseFactory,
-  DatabaseShell,
-} from "@fireproof/core";
-import { fileGatewayFactoryItem } from "../../src/blockstore/register-store-protocol.js";
-import { FILESTORE_VERSION } from "../../src/runtime/index.js";
+import { bs, Database, DocResponse, DocFileMeta, DocWithId, DocFiles } from "@fireproof/core";
 
 describe("basic Database", () => {
   let db: Database;
@@ -24,9 +10,7 @@ describe("basic Database", () => {
   });
   beforeEach(async () => {
     await sthis.start();
-    db = DatabaseFactory(undefined, {
-      logger: sthis.logger,
-    });
+    db = new Database();
   });
   it("should put", async () => {
     /** @type {Doc} */
@@ -54,7 +38,7 @@ describe("basic Database with record", function () {
   interface Doc {
     readonly value: string;
   }
-  let db: DatabaseShell;
+  let db: Database;
   const sthis = mockSuperThis();
   afterEach(async () => {
     await db.close();
@@ -62,7 +46,7 @@ describe("basic Database with record", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("factory-name") as DatabaseShell;
+    db = new Database();
     const ok = await db.put<Doc>({ _id: "hello", value: "world" });
     expect(ok.id).toBe("hello");
   });
@@ -94,13 +78,13 @@ describe("basic Database with record", function () {
     expect(rows[0].value._id).toBe("hello");
   });
   it("is not persisted", async function () {
-    const db2 = DatabaseFactory("factory-name") as DatabaseShell;
+    const db2 = new Database();
     const { rows } = await db2.changes([]);
-    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");
+    expect(rows.length).toBe(0);
+    const doc = await db2.get("hello").catch((e) => e);
+    expect(doc.message).toBeTruthy();
     await db2.close();
+    await db2.destroy();
   });
 });
 
@@ -116,7 +100,7 @@ describe("named Database with record", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-db-name");
+    db = new Database("test-db-name");
     /** @type {Doc} */
     const doc = { _id: "hello", value: "world" };
     const ok = await db.put(doc);
@@ -152,7 +136,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();
@@ -243,7 +227,7 @@ describe("basic Database parallel writes / public", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("test-parallel-writes", { public: true });
+    db = new Database("test-parallel-writes", { public: true });
     for (let i = 0; i < 10; i++) {
       const doc = { _id: `id-${i}`, hello: "world" };
       writes.push(db.put(doc));
@@ -251,7 +235,7 @@ describe("basic Database parallel writes / public", function () {
     await Promise.all(writes);
   });
   it("should have one head", function () {
-    const crdt = db.crdt;
+    const crdt = db._crdt;
     expect(crdt.clock.head.length).toBe(1);
   });
   it("should write all", async function () {
@@ -288,7 +272,7 @@ describe("basic Database parallel writes / public", function () {
   });
   it("has changes", 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));
     for (let i = 0; i < 10; i++) {
@@ -299,9 +283,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();
@@ -323,7 +307,7 @@ describe("basic Database with subscription", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("factory-name");
+    db = new Database();
     didRun = 0;
     waitForSub = new Promise((resolve) => {
       unsubscribe = db.subscribe((docs) => {
@@ -367,8 +351,9 @@ describe("basic Database with no update subscription", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = DatabaseFactory("factory-name");
+    db = new Database();
     didRun = 0;
+
     unsubscribe = db.subscribe(() => {
       didRun++;
     });
@@ -405,7 +390,7 @@ describe("database with files input", () => {
   beforeEach(async function () {
     await sthis.start();
     imagefiles = await buildBlobFiles();
-    db = DatabaseFactory("fireproof-with-images");
+    db = new Database("fireproof-with-images");
     const doc = {
       _id: "images-main",
       type: "files",
@@ -487,150 +472,3 @@ 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.");
-      },
-      test: function (): Promise<bs.TestGateway> {
-        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 = fileGatewayFactoryItem();
-    expect(gw.defaultURI(sthis).toString()).toBe(
-      `file://${sthis.env.get("HOME")}/.fireproof/${FILESTORE_VERSION.replace(/-.*$/, "")}`,
-    );
-  });
-});