@fireproof/core 0.21.0-dev-preview-6 → 0.22.0-dev-preview

package/tests/runtime/fp-envelope-serialize.test.ts

@@ -1,254 +0,0 @@
-import { rt, bs } from "@fireproof/core";
-import { mockSuperThis, simpleCID } from "../helpers.js";
-import { BuildURI, Result } from "@adviser/cement";
-import { toJSON } from "multiformats/link";
-
-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=car&suffix=.car").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.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=file").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.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(bs.FPEnvelopeTypes.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(bs.FPEnvelopeTypes.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: bs.FPEnvelopeTypes.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: bs.FPEnvelopeTypes.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: bs.FPEnvelopeTypes.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: bs.FPEnvelopeTypes.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=car&suffix=.car").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.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=car&suffix=.car").URI(), Promise.resolve(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.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=car&suffix=.car").URI(),
-      Promise.resolve(Result.Ok(raw)),
-    );
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(bs.FPEnvelopeTypes.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=car&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=car&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=car&suffix=.car").URI(), raw);
-    expect(res.isErr()).toBeTruthy();
-    expect(res.unwrap_err().message).toEqual("error");
-  });
-
-  it("attach Key to Meta", async () => {
-    const msg = {
-      type: bs.FPEnvelopeTypes.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/runtime/meta-key-hack.test.ts

@@ -1,95 +0,0 @@
-import { BuildURI, URI } from "@adviser/cement";
-import { rt, bs, fireproof, PARAM, ensureSuperThis, Database } from "@fireproof/core";
-
-describe("MetaKeyHack", () => {
-  const storageMap = new Map();
-
-  const sthis = ensureSuperThis();
-  const memGw = new rt.gw.memory.MemoryGateway(sthis, storageMap);
-  bs.registerStoreProtocol({
-    protocol: "hack:",
-    defaultURI: () => URI.from(`hack://localhost?version=hack`),
-    serdegateway: async () => {
-      return new rt.AddKeyToDbMetaGateway(memGw, "v2");
-    },
-  });
-
-  let db: Database;
-  let ctx: { loader: bs.Loadable };
-  beforeAll(async () => {
-    db = fireproof("test", {
-      storeUrls: {
-        base: BuildURI.from("hack://localhost").setParam(PARAM.SELF_REFLECT, "x"),
-      },
-      keyBag: {
-        url: "memory://./dist/kb-dir-partykit?extractKey=_deprecated_internal_api",
-      },
-    });
-    await db.ready();
-    ctx = { loader: db.ledger.crdt.blockstore.loader };
-  });
-
-  it("inject key into meta", async () => {
-    const loader = db.ledger.crdt.blockstore.loader;
-    const metaStore = loader.attachedStores.local().active.meta;
-    const subscribeFn = vitest.fn();
-    const unreg = await metaStore.realGateway.subscribe(
-      ctx,
-      metaStore.url(),
-      // metaStore.url().build().setParam(PARAM.SELF_REFLECT, "x").URI(),
-      subscribeFn,
-    );
-    expect(unreg.isOk()).toBeTruthy();
-    await db.put({ val: "test" });
-
-    const dataStore = loader.attachedStores.local().active.car;
-    const kb = new rt.KeyBag(db.ledger.opts.keyBag);
-    const rDataStoreKeyItem = await kb.getNamedKey(dataStore.url().getParam(PARAM.STORE_KEY) ?? "");
-
-    await rDataStoreKeyItem.Ok().upsert("zBUFMmu5c3VdCa4r2DZTzhR", false);
-    await rDataStoreKeyItem.Ok().upsert("zH1fyizirAiYVxoaQ2XZ3Xj", false);
-
-    expect(rDataStoreKeyItem.isOk()).toBeTruthy();
-    const rUrl = await memGw.buildUrl(metaStore.url(), "main");
-    // console.log(">>>>", rUrl.Ok().toString())
-    const rGet = await memGw.get(rUrl.Ok(), sthis);
-    const metas = JSON.parse(ctx.loader.sthis.txt.decode(rGet.Ok())) as rt.V2SerializedMetaKey;
-    const keyMaterials = metas.keys;
-    const dataStoreKeyMaterial = await rDataStoreKeyItem.Ok().asKeysItem();
-    expect(keyMaterials.length).toBeGreaterThan(0);
-    expect(dataStoreKeyMaterial).toEqual({
-      keys: {
-        ...(await rDataStoreKeyItem
-          .Ok()
-          .get()
-          .then(async (r) => ({
-            [r?.fingerPrint as string]: {
-              default: true,
-              fingerPrint: r?.fingerPrint,
-              key: await r?.extract().then((i) => i.keyStr),
-            },
-          }))),
-        z3boMcLEQxjZAMrVo2j3k9bZJzmSqXkQmh6q7bLZ2nRuo: {
-          default: false,
-          fingerPrint: "z3boMcLEQxjZAMrVo2j3k9bZJzmSqXkQmh6q7bLZ2nRuo",
-          key: "zH1fyizirAiYVxoaQ2XZ3Xj",
-        },
-        zG5F2VWVAs3uAFyLE5rty5WWo7zJ1oBmYTdnraxfhaHG5: {
-          default: false,
-          fingerPrint: "zG5F2VWVAs3uAFyLE5rty5WWo7zJ1oBmYTdnraxfhaHG5",
-          key: "zBUFMmu5c3VdCa4r2DZTzhR",
-        },
-      },
-      name: "@test-data@",
-    });
-
-    // expect(keyMaterials.every((k) => k === dataStoreKeyMaterial.keyStr)).toBeTruthy()
-    // expect(subscribeFn.mock.calls).toEqual([]);
-    expect(subscribeFn).toHaveBeenCalledTimes(2);
-    const addKeyToDbMetaGateway = metaStore.realGateway as rt.AddKeyToDbMetaGateway;
-    expect(
-      subscribeFn.mock.calls.map((i) => i.map((i) => i.payload.map((i: bs.DbMetaEvent) => i.eventCid.toString()))).flat(2),
-    ).toEqual(Array.from(new Set(addKeyToDbMetaGateway.lastDecodedMetas.map((i) => i.metas.map((i) => i.cid)).flat(2))));
-    unreg.Ok()();
-  });
-});

package/tests/setup.file.ts

@@ -1 +0,0 @@
-process.env.FP_STORAGE_URL = "./dist/fp-dir-file";

package/tests/setup.memory.ts

@@ -1,2 +0,0 @@
-process.env.FP_STORAGE_URL = "memory://test";
-process.env.FP_KEYBAG_URL = "memory://keybag";

package/tests/utils.test.ts

@@ -1,192 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ensureURIDefaults } from "../src/utils.js";
-import { BuildURI, Logger } from "@adviser/cement";
-import { PARAM, StoreType, SuperThis } from "@fireproof/core"; // Assuming types are here
-// import { mockSuperThis } from './helpers'; // We'll need a mock for SuperThis
-
-// A minimal mock for SuperThis, to be expanded as needed
-const mockSuperThisMinimal = (): Partial<SuperThis> => {
-  // Helper to create a LogBuilder mock part
-  // The LogBuilder interface is complex, so we mock only what's used by ensureURIDefaults
-  const createLogBuilder = (level: string) => ({
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    Msg: (_message: string) => ({
-      // Using _message for potentially unused parameter
-      AsError: () => new Error(`Mock Error from ${level}`),
-      // Log: () => { /* no-op */ }
-    }),
-    With: function () {
-      return this;
-    }, // Fluent interface
-    Stv: function () {
-      return this;
-    }, // Fluent interface
-  });
-
-  const loggerInstance = {
-    Error: () => createLogBuilder("Error"),
-    Info: () => createLogBuilder("Info"),
-    Warn: () => createLogBuilder("Warn"),
-    Debug: () => createLogBuilder("Debug"),
-    // Add stubs for other Logger methods/properties if ensureURIDefaults uses them
-    // For now, these are the ones that might be expected by the Logger type itself
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    Msg: (_message: string) => createLogBuilder("DefaultMsgLevel"), // Top-level Msg
-    Flush: async () => {
-      /* no-op */
-    },
-    levelHandler: {
-      /* minimal stub or actual mock if needed */
-    },
-    TxtEnDe: { encode: (s: string) => new Uint8Array(s.length), decode: (b: Uint8Array) => b.toString() },
-    Child: function () {
-      return this as unknown as Logger;
-    },
-    With: function () {
-      return this as unknown as Logger;
-    },
-    Stv: function () {
-      return this as unknown as Logger;
-    },
-    // ... and potentially other properties from the Logger interface if TS still complains
-  };
-
-  return {
-    logger: loggerInstance as unknown as Logger, // Using unknown as Logger for partial mock
-    // Add other SuperThis properties if ensureURIDefaults accesses them
-  };
-};
-
-describe("ensureURIDefaults", () => {
-  const baseUri = BuildURI.from("fireproof://mydatabase").URI();
-  const defaultName = "testDb";
-
-  it("should set STORE_KEY to insecure and apply store type when opts.public is true", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const names = { name: defaultName };
-    const opts = { public: true };
-    const store: StoreType = "car";
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, baseUri, store);
-
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe("insecure");
-    expect(resultUri.getParam(PARAM.STORE)).toBe("car");
-    expect(resultUri.getParam(PARAM.NAME)).toBe(defaultName);
-  });
-
-  it("should use opts.storeKey when public is false and storeKey is provided", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const names = { name: defaultName };
-    const opts = { public: false, storeKey: "customKey123" };
-    const store: StoreType = "car";
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, baseUri, store);
-
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe("customKey123");
-    expect(resultUri.getParam(PARAM.STORE)).toBe("car");
-    expect(resultUri.getParam(PARAM.NAME)).toBe(defaultName);
-  });
-
-  it("should use STORE_KEY from names.localURI when public is false and opts.storeKey is not set", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const localStoreKey = "keyFromLocalURI";
-    const localUriWithKey = BuildURI.from("file:///another?storekey=" + localStoreKey).URI();
-    const names = { name: defaultName, localURI: localUriWithKey };
-    const opts = { public: false }; // storeKey is undefined
-    const store: StoreType = "wal";
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, baseUri, store);
-
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe(localStoreKey);
-    expect(resultUri.getParam(PARAM.STORE)).toBe("wal");
-    expect(resultUri.getParam(PARAM.NAME)).toBe(defaultName);
-  });
-
-  it("should generate a new STORE_KEY when public is false and no key is provided", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const names = { name: defaultName, localURI: BuildURI.from("file:///clean").URI() }; // No store_key in localURI
-    const opts = { public: false }; // No storeKey in opts
-    const store: StoreType = "wal";
-    const initialUri = baseUri.clone();
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, initialUri, store);
-
-    const storeKey = resultUri.getParam(PARAM.STORE_KEY);
-    expect(storeKey).toBeDefined();
-    expect(storeKey).not.toBeNull();
-    expect(storeKey).not.toBe("insecure");
-    expect(typeof storeKey).toBe("string");
-    // Add a direct check to satisfy TypeScript's null/undefined check for storeKey
-    if (storeKey) {
-      expect(storeKey.length).toBeGreaterThan(0); // Ensure it's not an empty string
-    } else {
-      // This case should not be reached if the above expects pass, but it satisfies TS
-      expect(storeKey).toBe("actually a string"); // This will fail if storeKey is not a string, or null/undefined
-    }
-    expect(resultUri.getParam(PARAM.STORE)).toBe(store);
-  });
-
-  it('should preserve suffix if opts.public is true (and store is not "car")', () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const names = { name: defaultName };
-    const opts = { public: true };
-    const store: StoreType = "wal";
-    const suffixValue = "somesuffix";
-    const initialUriWithSuffix = BuildURI.from(baseUri).setParam(PARAM.SUFFIX, suffixValue).URI();
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, initialUriWithSuffix, store);
-
-    expect(resultUri.hasParam(PARAM.SUFFIX)).toBe(true);
-    expect(resultUri.getParam(PARAM.SUFFIX)).toBe(suffixValue);
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe("insecure");
-  });
-
-  it("should preserve suffix if opts.public is false", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const names = { name: defaultName };
-    const opts = { public: false, storeKey: "somekey" }; // Provide a storeKey for private
-    const store: StoreType = "wal";
-    const suffixValue = "keepsuffix";
-    const initialUriWithSuffix = BuildURI.from(baseUri).setParam(PARAM.SUFFIX, suffixValue).URI();
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, initialUriWithSuffix, store);
-
-    expect(resultUri.hasParam(PARAM.SUFFIX)).toBe(true);
-    expect(resultUri.getParam(PARAM.SUFFIX)).toBe(suffixValue);
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe("somekey");
-  });
-
-  it("should generate STORE_KEY with -idx and set PARAM.INDEX when ctx.idx is true and public is false", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const names = { name: defaultName }; // No localURI with storeKey
-    const opts = { public: false }; // No explicit storeKey
-    const store: StoreType = "wal";
-    const ctx = { idx: true };
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, baseUri, store, ctx);
-
-    expect(resultUri.hasParam(PARAM.INDEX)).toBe(true);
-    expect(resultUri.getParam(PARAM.INDEX)).toBe("idx");
-    // Assuming storeType2DataMetaWal('wal') results in 'wal' for the key name
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe(`@${defaultName}-wal-idx@`);
-  });
-
-  it("should use opts.uri as base and correctly apply other params (e.g., public affects STORE_KEY)", () => {
-    const sthis = mockSuperThisMinimal() as SuperThis;
-    const customUriString = "fireproof://custombase/path";
-    const optsUri = BuildURI.from(customUriString).URI();
-    const names = { name: defaultName };
-    // Set public to true to check interaction: STORE_KEY should be 'insecure'
-    const opts = { uri: optsUri, public: true };
-    const store: StoreType = "file"; // Changed 'data' to 'file' (a valid StoreType)
-    // This baseUri should be overridden by opts.uri
-    const originalUri = BuildURI.from("fireproof://original/ignored").URI();
-
-    const resultUri = ensureURIDefaults(sthis, names, opts, originalUri, store);
-
-    expect(resultUri.pathname.startsWith(optsUri.pathname)).toBe(true);
-    expect(resultUri.getParam(PARAM.STORE_KEY)).toBe("insecure");
-    expect(resultUri.getParam(PARAM.STORE)).toBe(store);
-    expect(resultUri.getParam(PARAM.NAME)).toBe(defaultName);
-  });
-});

package/tests/vitest.file.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-import tsconfigPaths from "vite-tsconfig-paths";
-
-export default defineConfig({
-  plugins: [tsconfigPaths()],
-  test: {
-    name: "file",
-    exclude: ["tests/react/**", "examples/**", "tests/gateway/indexeddb"],
-    include: ["tests/**/*test.?(c|m)[jt]s?(x)"],
-    globals: true,
-    setupFiles: "./tests/setup.file.ts",
-  },
-});

package/tests/vitest.indexeddb.config.ts

@@ -1,37 +0,0 @@
-/// <reference types="@vitest/browser/providers/playwright" />
-/// <reference types="@vitest/browser/providers/webdriverio" />
-
-import { defineConfig } from "vitest/config";
-
-import tsconfigPaths from "vite-tsconfig-paths";
-
-export default defineConfig({
-  plugins: [tsconfigPaths()],
-  test: {
-    name: "indexeddb",
-    exclude: ["examples/**", "tests/gateway/file"],
-    include: ["tests/**/*test.?(c|m)[jt]s?(x)"],
-    browser: {
-      enabled: true,
-      headless: true,
-      provider: "playwright",
-      // provider: "webdriverio",
-      // name: "chrome",
-      instances: [
-        {
-          browser: "chromium",
-          //setupFile: './chromium-setup.js',
-        },
-      ],
-
-      // name: process.env.FP_BROWSER || "chrome", // browser name is required
-      // instances: [
-      //   {
-      //     browser: process.env.FP_BROWSER || "chrome", // browser name is required
-      //   },
-      // ],
-    },
-    globals: true,
-    setupFiles: "./tests/setup.indexeddb.ts",
-  },
-});

package/tests/vitest.memory.config.ts

@@ -1,25 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-import tsconfigPaths from "vite-tsconfig-paths";
-
-export default defineConfig({
-  plugins: [tsconfigPaths()],
-  test: {
-    name: "memory",
-    exclude: [
-      "tests/react/**",
-      "**/smoke/**",
-      "**/scripts/**",
-      "**/examples/**",
-      "tests/gateway/indexeddb",
-      "tests/gateway/file",
-      "tests/blockstore/keyed-crypto-indexeddb-file.test.ts",
-    ],
-    include: ["tests/**/*test.?(c|m)[jt]s?(x)"],
-    coverage: {
-      exclude: ["**/smoke/**", "**/scripts/**", "**/examples/**"],
-    },
-    globals: true,
-    setupFiles: "./tests/setup.memory.ts",
-  },
-});