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

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

@@ -0,0 +1,307 @@
+import { BuildURI, CoerceURI, URI } from "@adviser/cement";
+import { fireproof, PARAM, rt, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers.js";
+
+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.gw.file.sysFileSystemFactory(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.gw.file.sysFileSystemFactory(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",
+        runtime: "node",
+        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,
+        runtime: "node",
+        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,
+        runtime: "node",
+        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.gw.file.sysFileSystemFactory(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",
+        // runtime: "node",
+        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/fp-envelope-serialize.test.ts

@@ -0,0 +1,256 @@
+import { rt, bs } from "@fireproof/core";
+import { mockSuperThis, simpleCID } from "../helpers.js";
+import { BuildURI, Result } from "@adviser/cement";
+import { toJSON } from "multiformats/link";
+
+const FPEnvelopeType = bs.FPEnvelopeType;
+
+describe("storage-content", () => {
+  const sthis = mockSuperThis();
+  it("car", async () => {
+    const raw = new Uint8Array([55, 56, 57]);
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), Result.Ok(raw));
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().payload).toEqual(raw);
+  });
+
+  it("file", async () => {
+    const raw = new Uint8Array([55, 56, 57]);
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data").URI(), Result.Ok(raw));
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.FILE);
+    expect(res.unwrap().payload).toEqual(raw);
+  });
+
+  it("meta", async () => {
+    const ref = [
+      {
+        cid: "bafyreiaqmtw5jfudn6r6dq7mcmytc2z5z3ggohcj3gco3omjsp3hr73fpy",
+        data: "MomRkYXRhoWZkYk1ldGFYU3siY2FycyI6W3siLyI6ImJhZzR5dnFhYmNpcWNod29zeXQ3dTJqMmxtcHpyM2w3aWRlaTU1YzNmNnJ2Z3U3cXRmYXRoMnl2NnZuaWtjeXEifV19Z3BhcmVudHOA",
+        parents: [(await simpleCID(sthis)).toString(), (await simpleCID(sthis)).toString()],
+      },
+    ];
+    const raw = sthis.txt.encode(JSON.stringify(ref));
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=meta").URI(), Result.Ok(raw));
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.META);
+    const dbMetas = res.unwrap().payload as bs.DbMetaEvent[];
+    expect(dbMetas.length).toBe(1);
+    const dbMeta = dbMetas[0];
+    expect(dbMeta.parents.map((i) => i.toString())).toStrictEqual(ref[0].parents);
+    expect(dbMeta.eventCid.toString()).toEqual("bafyreiaqmtw5jfudn6r6dq7mcmytc2z5z3ggohcj3gco3omjsp3hr73fpy");
+    expect(dbMeta.dbMeta.cars.map((i) => i.toString())).toEqual([
+      "bag4yvqabciqchwosyt7u2j2lmpzr3l7idei55c3f6rvgu7qtfath2yv6vnikcyq",
+    ]);
+  });
+
+  it("wal", async () => {
+    const ref = {
+      fileOperations: [
+        {
+          cid: "bafyreiaqmtw5jfudn6r6dq7mcmytc2z5z3ggohcj3gco3omjsp3hr73fpy",
+          public: false,
+        },
+      ],
+      noLoaderOps: [
+        {
+          cars: [
+            {
+              "/": "bag4yvqabciqchwosyt7u2j2lmpzr3l7idei55c3f6rvgu7qtfath2yv6vnikcyq",
+            },
+          ],
+        },
+      ],
+      operations: [
+        {
+          cars: [{ "/": "bag4yvqabciqchwosyt7u2j2lmpzr3l7idei55c3f6rvgu7qtfath2yv6vnikcyq" }],
+        },
+      ],
+    };
+    const raw = sthis.txt.encode(JSON.stringify(ref));
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=wal").URI(), Result.Ok(raw));
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.WAL);
+    const walstate = res.unwrap().payload as bs.WALState;
+    expect(
+      walstate.fileOperations.map((i) => ({
+        ...i,
+        cid: i.cid.toString(),
+      })),
+    ).toEqual(ref.fileOperations);
+    expect(
+      walstate.noLoaderOps.map((i) => ({
+        cars: i.cars.map((i) => toJSON(i)),
+      })),
+    ).toEqual(ref.noLoaderOps);
+    expect(
+      walstate.operations.map((i) => ({
+        cars: i.cars.map((i) => toJSON(i)),
+      })),
+    ).toEqual(ref.operations);
+  });
+});
+
+describe("de-serialize", () => {
+  const sthis = mockSuperThis();
+  it("car", async () => {
+    const msg = {
+      type: FPEnvelopeType.CAR,
+      payload: new Uint8Array([55, 56, 57]),
+    } satisfies bs.FPEnvelopeCar;
+    const res = await rt.gw.fpSerialize(sthis, msg);
+    expect(res.Ok()).toEqual(msg.payload);
+  });
+
+  it("file", async () => {
+    const msg = {
+      type: FPEnvelopeType.FILE,
+      payload: new Uint8Array([55, 56, 57]),
+    } satisfies bs.FPEnvelopeFile;
+    const res = await rt.gw.fpSerialize(sthis, msg);
+    expect(res.Ok()).toEqual(msg.payload);
+  });
+
+  it("meta", async () => {
+    const msg = {
+      type: FPEnvelopeType.META,
+      payload: [
+        await bs.createDbMetaEvent(
+          sthis,
+          {
+            cars: [await simpleCID(sthis)],
+          },
+          [await simpleCID(sthis), await simpleCID(sthis)],
+        ),
+      ],
+    } satisfies bs.FPEnvelopeMeta;
+    const ser = await rt.gw.fpSerialize(sthis, msg);
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=meta").URI(), ser);
+    const dbMetas = res.unwrap().payload as bs.DbMetaEvent[];
+    expect(dbMetas.length).toBe(1);
+    const dbMeta = dbMetas[0];
+    expect(dbMeta.parents).toEqual(msg.payload[0].parents);
+    expect(dbMeta.dbMeta).toEqual(msg.payload[0].dbMeta);
+    expect(dbMeta.eventCid).toEqual(msg.payload[0].eventCid);
+  });
+
+  it("wal", async () => {
+    const msg = {
+      type: FPEnvelopeType.WAL,
+      payload: {
+        fileOperations: [
+          {
+            cid: await simpleCID(sthis),
+            public: false,
+          },
+        ],
+        noLoaderOps: [
+          {
+            cars: [await simpleCID(sthis)],
+          },
+        ],
+        operations: [
+          {
+            cars: [await simpleCID(sthis)],
+          },
+        ],
+      },
+    } satisfies bs.FPEnvelopeWAL;
+    const ser = await rt.gw.fpSerialize(sthis, msg);
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=wal").URI(), ser);
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual("wal");
+    const walstate = res.unwrap().payload as bs.WALState;
+    expect(walstate.fileOperations).toEqual(msg.payload.fileOperations);
+    expect(walstate.noLoaderOps).toEqual(msg.payload.noLoaderOps);
+    expect(walstate.operations).toEqual(msg.payload.operations);
+  });
+
+  it("coerce into fpDeserialize Result", async () => {
+    const raw = new Uint8Array([55, 56, 57]);
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), Result.Ok(raw));
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().payload).toEqual(raw);
+  });
+
+  it("coerce into fpDeserialize Promise", async () => {
+    const raw = new Uint8Array([55, 56, 57]);
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), Promise.resolve(raw));
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().payload).toEqual(raw);
+  });
+
+  it("coerce into fpDeserialize Promise Result", async () => {
+    const raw = new Uint8Array([55, 56, 57]);
+    const res = await rt.gw.fpDeserialize(
+      sthis,
+      BuildURI.from("http://x.com?store=data&suffix=.car").URI(),
+      Promise.resolve(Result.Ok(raw)),
+    );
+    expect(res.isOk()).toBeTruthy();
+    expect(res.unwrap().type).toEqual(FPEnvelopeType.CAR);
+    expect(res.unwrap().payload).toEqual(raw);
+  });
+
+  it("coerce into fpDeserialize Promise Result.Err", async () => {
+    const raw = Promise.resolve(Result.Err<Uint8Array>("error"));
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), raw);
+    expect(res.isErr()).toBeTruthy();
+    expect(res.unwrap_err().message).toEqual("error");
+  });
+
+  it("coerce into fpDeserialize Promise.reject", async () => {
+    const raw = Promise.reject(new Error("error"));
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), raw);
+    expect(res.isErr()).toBeTruthy();
+    expect(res.unwrap_err().message).toEqual("error");
+  });
+
+  it("coerce into fpDeserialize Result.Err", async () => {
+    const raw = Result.Err<Uint8Array>("error");
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=data&suffix=.car").URI(), raw);
+    expect(res.isErr()).toBeTruthy();
+    expect(res.unwrap_err().message).toEqual("error");
+  });
+
+  it("attach Key to Meta", async () => {
+    const msg = {
+      type: FPEnvelopeType.META,
+      payload: [
+        await bs.createDbMetaEvent(
+          sthis,
+          {
+            cars: [await simpleCID(sthis)],
+          },
+          [await simpleCID(sthis), await simpleCID(sthis)],
+        ),
+      ],
+    } satisfies bs.FPEnvelopeMeta;
+    const ser = await rt.gw.fpSerialize(sthis, msg, {
+      meta: async (sthis, payload) => {
+        return Result.Ok(sthis.txt.encode(JSON.stringify(payload.map((i) => ({ ...i, key: "key" })))));
+      },
+    });
+    let key = "";
+    const res = await rt.gw.fpDeserialize(sthis, BuildURI.from("http://x.com?store=meta").URI(), ser, {
+      meta: async (sthis, payload) => {
+        const json = JSON.parse(sthis.txt.decode(payload));
+        key = json[0].key;
+        return Result.Ok(
+          json.map((i: { key?: string }) => {
+            delete i.key;
+            return i;
+          }) as rt.gw.SerializedMeta[],
+        );
+      },
+    });
+    expect(res.isOk()).toBeTruthy();
+    const meta = res.unwrap() as bs.FPEnvelopeMeta;
+    expect(meta.type).toEqual("meta");
+    expect(Object.keys(meta.payload).includes("key")).toBeFalsy();
+    expect(key).toEqual("key");
+  });
+});

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

@@ -0,0 +1,79 @@
+import { fireproof } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers.js";
+
+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",
+        runtime: "browser",
+        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",
+        runtime: "browser",
+        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",
+        runtime: "browser",
+        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",
+        runtime: "browser",
+        storekey: "@my-app-wal@",
+        urlGen: "default",
+        version: "v0.19-indexdb",
+      },
+      style: "path",
+    });
+    await db.close();
+  });
+});