@fireproof/core 0.19.99 → 0.19.101

package/tests/fireproof/indexer.test.ts

@@ -1,4 +1,4 @@
-import { Index, index, Database, CRDT, IndexRows } from "@fireproof/core";
+import { Index, index, Database, CRDT, IndexRows, DatabaseOpts, toStoreURIRuntime, bs, rt, DatabaseFactory } from "@fireproof/core";
 import { mockSuperThis } from "../helpers";
 
 interface TestType {
@@ -14,24 +14,24 @@ describe("basic Index", () => {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("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.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.name).toBe("test-indexer");
+    expect(indexer.crdt).toBe(db.crdt);
+    // expect(indexer.crdt.name).toBe("test-indexer");
     expect(indexer.name).toBe("hello");
     expect(indexer.mapFn).toBeTruthy();
   });
@@ -101,17 +101,17 @@ describe("Index query with compound key", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("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.crdt, "hello", (doc) => {
       return [doc.title, doc.score];
     });
     await indexer.ready();
@@ -131,16 +131,16 @@ describe("basic Index with map fun", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("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.crdt, "hello", (doc, map) => {
       map(doc.title);
     });
     await indexer.ready();
@@ -164,11 +164,11 @@ describe("basic Index with map fun with value", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("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.crdt, "hello", (doc, map) => {
       map(doc.title, doc.title.length);
     });
   });
@@ -199,17 +199,17 @@ describe("Index query with map and compound key", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("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.crdt, "hello", (doc, emit) => {
       emit([doc.title, doc.score]);
     });
     await indexer.ready();
@@ -229,16 +229,16 @@ describe("basic Index with string fun", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("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(sthis, db.crdt, "title");
     await indexer.ready();
   });
   it("should get results", async function () {
@@ -265,31 +265,43 @@ describe("basic Index upon cold start", function () {
   let mapFn: (doc: TestType) => string;
   let result: IndexRows<string, TestType>;
   const sthis = mockSuperThis();
+  let dbOpts: DatabaseOpts;
   // result, mapFn;
   afterEach(async function () {
     await crdt.close();
     await crdt.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    // db = database()
-    crdt = new CRDT<TestType>(sthis, "test-indexer-cold", { persistIndexes: true });
+    const logger = sthis.logger.With().Module("IndexerTest").Logger();
+    logger.Debug().Msg("enter beforeEach");
+    dbOpts = {
+      keyBag: rt.kb.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-indexer-cold"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT<TestType>(sthis, dbOpts);
     await crdt.bulk([
       { id: "abc1", value: { title: "amazing" } },
       { id: "abc2", value: { title: "creative" } },
       { id: "abc3", value: { title: "bazillas" } },
     ]);
+    logger.Debug().Msg("post bulk beforeEach");
     didMap = 0;
     mapFn = (doc) => {
       didMap++;
       return doc.title;
     };
-    indexer = await index<string, TestType>(sthis, { _crdt: crdt }, "hello", mapFn);
+    indexer = await index<string, TestType>({ crdt: crdt }, "hello", mapFn);
+    logger.Debug().Msg("post index beforeEach");
     await indexer.ready();
+    logger.Debug().Msg("post indexer.ready beforeEach");
     // new Index(db._crdt.indexBlockstore, db._crdt, 'hello', mapFn)
     result = await indexer.query();
+
+    logger.Debug().Msg("post indexer.query beforeEach");
     expect(indexer.indexHead).toEqual(crdt.clock.head);
   });
   it("should call map on first query", function () {
@@ -302,12 +314,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, "test-indexer-cold", { persistIndexes: true });
+    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
     await crdt2.ready();
     const { result, head } = await crdt2.changes();
     expect(result).toBeTruthy();
     await crdt2.ready();
-    const indexer2 = await index<string, TestType>(sthis, { _crdt: crdt2 }, "hello", mapFn);
+    const indexer2 = await index<string, TestType>({ crdt: crdt2 }, "hello", mapFn);
     await indexer2.ready();
     const result2 = await indexer2.query();
     expect(indexer2.indexHead).toEqual(head);
@@ -317,8 +329,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, "test-indexer-cold", { persistIndexes: true });
-    const indexer2 = await index(sthis, { _crdt: crdt2 }, "hello", mapFn);
+    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
+    const indexer2 = await index({ crdt: crdt2 }, "hello", mapFn);
     const { result, head } = await crdt2.changes([]);
     expect(result.length).toEqual(3);
     expect(head.length).toEqual(1);
@@ -342,10 +354,8 @@ 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, "test-indexer-cold");
-    const result = await index<string, TestType>(sthis, { _crdt: crdt2 }, "hello", (doc) =>
-      doc.title.split("").reverse().join(""),
-    ).query();
+    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
+    const result = await index<string, TestType>({ crdt: crdt2 }, "hello", (doc) => doc.title.split("").reverse().join("")).query();
     expect(result.rows.length).toEqual(3);
     expect(result.rows[0].key).toEqual("evitaerc"); // creative
   });
@@ -359,20 +369,20 @@ describe("basic Index with no data", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
-    indexer = new Index<string, TestType>(sthis, db._crdt, "hello", (doc) => {
+    db = DatabaseFactory("test-indexer");
+    indexer = new Index<string, TestType>(sthis, db.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.crdt);
     expect(indexer.name).toEqual("hello");
     expect(indexer.mapFn).toBeTruthy();
   });

package/tests/fireproof/utils.test.ts

@@ -1,8 +1,6 @@
-import { URI } from "@adviser/cement";
+import { runtimeFn, URI } from "@adviser/cement";
 import { rt, getStore, ensureSuperLog } from "@fireproof/core";
 import { mockSuperThis } from "../helpers";
-
-// only for test
 import { UUID } from "uuidv7";
 
 describe("utils", () => {
@@ -21,7 +19,7 @@ describe("utils", () => {
   const storeOpts = [
     {
       type: "data",
-      suffix: ".car",
+      suffix: ".tar",
     },
     {
       type: "wal",
@@ -34,14 +32,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}`);
     }
   });
@@ -82,3 +82,15 @@ describe("utils", () => {
     expect(id.slice(0, 15)).toBe("cafebabe-beef-7");
   });
 });
+
+describe("runtime", () => {
+  it("runtime", () => {
+    const isNode = !!(typeof process === "object" && process.versions?.node);
+    expect(runtimeFn()).toEqual({
+      isBrowser: !isNode,
+      isDeno: false,
+      isNodeIsh: isNode,
+      isReactNative: false,
+    });
+  });
+});

package/tests/gateway/file/loader-config.test.ts

@@ -0,0 +1,303 @@
+import { BuildURI, CoerceURI, URI } from "@adviser/cement";
+import { fireproof, PARAM, rt, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers";
+
+function dataDir(sthis: SuperThis, name?: string, base?: CoerceURI): URI {
+  if (!base) {
+    const home = sthis.env.get("HOME") || "./";
+    base =
+      sthis.env.get("FP_STORAGE_URL") ||
+      `file://${sthis.pathOps.join(home, ".fireproof", rt.FILESTORE_VERSION.replace(/-.*$/, ""))}?${PARAM.URL_GEN}=default`;
+  }
+  return URI.from(base.toString())
+    .build()
+    .setParam(PARAM.NAME, name || "")
+    .URI();
+}
+
+const _my_app = "my-app";
+function my_app() {
+  return _my_app;
+}
+
+describe("config file gateway", () => {
+  const sthis = mockSuperThis();
+  const isMemFS: { fs?: string } = {};
+
+  beforeAll(async () => {
+    await sthis.start();
+    const url = URI.from(sthis.env.get("FP_STORAGE_URL"));
+    if (url.getParam("fs") === "mem") {
+      isMemFS.fs = "mem";
+    }
+  });
+
+  it("loader", async () => {
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name()).toBe(my_app());
+
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+
+    const dataStore = await db.crdt.blockstore.loader?.carStore();
+    expect(dataStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "data",
+        suffix: ".car",
+        storekey: "@my-app-data@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const WALStore = await db.crdt.blockstore.loader?.WALStore();
+    expect(WALStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "wal",
+        storekey: "@my-app-wal@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    await db.close();
+  });
+
+  it("file path", async () => {
+    let baseDir = "./dist/data".replace(/\?.*$/, "").replace(/^file:\/\//, "");
+    baseDir = sthis.pathOps.join(baseDir, /* testCfg(sthis, "data").version, */ my_app());
+    const base = BuildURI.from("./dist/data");
+    if (isMemFS.fs) {
+      base.setParam("fs", isMemFS.fs);
+    }
+    const sysfs = await rt.getFileSystem(base.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), { storeUrls: { base } });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect(db.name()).toBe(my_app());
+    const carStore = await db.crdt.blockstore.loader?.carStore();
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        suffix: ".car",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        ...isMemFS,
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+  });
+
+  it("homedir default", async () => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    sthis.env.delete("FP_STORAGE_URL");
+    // this switches file: protocol not memory:
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, my_app());
+
+    const base = BuildURI.from(baseDir);
+    if (isMemFS.fs) {
+      base.setParam("fs", isMemFS.fs);
+    }
+    const sysfs = await rt.getFileSystem(base.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    expect(baseDir).toMatch(new RegExp(`/\\.fireproof/${rt.FILESTORE_VERSION.replace(/-file/, "")}/${my_app()}`));
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name()).toBe(my_app());
+    const carStore = await db.crdt.blockstore.loader?.carStore();
+
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        ...isMemFS,
+        suffix: ".car",
+        urlGen: "default",
+        store: "data",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        ...isMemFS,
+        urlGen: "default",
+        store: "data",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        ...isMemFS,
+        urlGen: "default",
+        store: "meta",
+        name: my_app(),
+        storekey: `@${my_app()}-meta@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    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");
+    // assert(!old, "FP_STORAGE_URL must set")
+    const testUrl = BuildURI.from(old);
+    // sthis.env.set("FP_STORAGE_URL", testUrl.toString());
+
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, /* testCfg(sthis, "data").version, */ my_app());
+
+    const sysfs = await rt.getFileSystem(testUrl.URI());
+    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.crdt.blockstore.loader?.carStore();
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        ...isMemFS,
+        urlGen: "fromEnv",
+        store: "data",
+        suffix: ".car",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: `./dist/fp-dir-file`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        ...isMemFS,
+        urlGen: "fromEnv",
+        store: "data",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: `./dist/fp-dir-file`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        ...isMemFS,
+        urlGen: "fromEnv",
+        store: "meta",
+        name: my_app(),
+        storekey: `@${my_app()}-meta@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+    sthis.env.set("FP_STORAGE_URL", old);
+  });
+});

package/tests/gateway/indexdb/loader-config.test.ts

@@ -0,0 +1,75 @@
+import { fireproof } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers";
+
+describe("fireproof config indexdb", () => {
+  const _my_app = "my-app";
+  function my_app() {
+    return _my_app;
+  }
+  const sthis = mockSuperThis();
+  beforeAll(async () => {
+    await sthis.start();
+  });
+
+  it("indexdb-loader", async () => {
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name()).toBe(my_app());
+
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexdb:",
+      searchParams: {
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        urlGen: "default",
+        version: "v0.19-indexdb",
+      },
+      style: "path",
+    });
+
+    const dataStore = await db.crdt.blockstore.loader?.carStore();
+    expect(dataStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexdb:",
+      searchParams: {
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        suffix: ".car",
+        urlGen: "default",
+        version: "v0.19-indexdb",
+      },
+      style: "path",
+    });
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexdb:",
+      searchParams: {
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        urlGen: "default",
+        version: "v0.19-indexdb",
+      },
+      style: "path",
+    });
+    const WALStore = await db.crdt.blockstore.loader?.WALStore();
+    expect(WALStore?.url().asObj()).toEqual({
+      pathname: "fp",
+      protocol: "indexdb:",
+      searchParams: {
+        name: "my-app",
+        store: "wal",
+        storekey: "@my-app-wal@",
+        urlGen: "default",
+        version: "v0.19-indexdb",
+      },
+      style: "path",
+    });
+    await db.close();
+  });
+});