@fireproof/core-test 0.22.0-keybag → 0.23.1-dev-issue-1057

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

@@ -1,266 +0,0 @@
-import { createDbMetaEvent } from "@fireproof/core-blockstore";
-import { mockSuperThis, simpleCID } from "../helpers.js";
-import { BuildURI, Result } from "@adviser/cement";
-import { fpDeserialize, fpSerialize } from "@fireproof/core-gateways-base";
-import {
-  DbMetaEvent,
-  FPEnvelopeCar,
-  FPEnvelopeFile,
-  FPEnvelopeMeta,
-  FPEnvelopeTypes,
-  FPEnvelopeWAL,
-  SerializedMeta,
-  WALState,
-} from "@fireproof/core-types-blockstore";
-import { toJSON } from "multiformats/link";
-import { describe, expect, it } from "vitest";
-
-describe("storage-content", () => {
-  const sthis = mockSuperThis();
-  it("car", async () => {
-    const raw = new Uint8Array([55, 56, 57]);
-    const res = await fpDeserialize(sthis, BuildURI.from("http://x.com?store=car&suffix=.car").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeTypes.CAR);
-    expect(res.unwrap().payload).toEqual(raw);
-  });
-
-  it("file", async () => {
-    const raw = new Uint8Array([55, 56, 57]);
-    const res = await fpDeserialize(sthis, BuildURI.from("http://x.com?store=file").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(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 fpDeserialize(sthis, BuildURI.from("http://x.com?store=meta").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeTypes.META);
-    const dbMetas = res.unwrap().payload as 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 fpDeserialize(sthis, BuildURI.from("http://x.com?store=wal").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeTypes.WAL);
-    const walstate = res.unwrap().payload as 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: FPEnvelopeTypes.CAR,
-      payload: new Uint8Array([55, 56, 57]),
-    } satisfies FPEnvelopeCar;
-    const res = await fpSerialize(sthis, msg);
-    expect(res.Ok()).toEqual(msg.payload);
-  });
-
-  it("file", async () => {
-    const msg = {
-      type: FPEnvelopeTypes.FILE,
-      payload: new Uint8Array([55, 56, 57]),
-    } satisfies FPEnvelopeFile;
-    const res = await fpSerialize(sthis, msg);
-    expect(res.Ok()).toEqual(msg.payload);
-  });
-
-  it("meta", async () => {
-    const msg = {
-      type: FPEnvelopeTypes.META,
-      payload: [
-        await createDbMetaEvent(
-          sthis,
-          {
-            cars: [await simpleCID(sthis)],
-          },
-          [await simpleCID(sthis), await simpleCID(sthis)],
-        ),
-      ],
-    } satisfies FPEnvelopeMeta;
-    const ser = await fpSerialize(sthis, msg);
-    const res = await fpDeserialize(sthis, BuildURI.from("http://x.com?store=meta").URI(), ser);
-    const dbMetas = res.unwrap().payload as 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: FPEnvelopeTypes.WAL,
-      payload: {
-        fileOperations: [
-          {
-            cid: await simpleCID(sthis),
-            public: false,
-          },
-        ],
-        noLoaderOps: [
-          {
-            cars: [await simpleCID(sthis)],
-          },
-        ],
-        operations: [
-          {
-            cars: [await simpleCID(sthis)],
-          },
-        ],
-      },
-    } satisfies FPEnvelopeWAL;
-    const ser = await fpSerialize(sthis, msg);
-    const res = await 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 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 fpDeserialize(sthis, BuildURI.from("http://x.com?store=car&suffix=.car").URI(), Result.Ok(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(FPEnvelopeTypes.CAR);
-    expect(res.unwrap().payload).toEqual(raw);
-  });
-
-  it("coerce into fpDeserialize Promise", async () => {
-    const raw = new Uint8Array([55, 56, 57]);
-    const res = await fpDeserialize(sthis, BuildURI.from("http://x.com?store=car&suffix=.car").URI(), Promise.resolve(raw));
-    expect(res.isOk()).toBeTruthy();
-    expect(res.unwrap().type).toEqual(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 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(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 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 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 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: FPEnvelopeTypes.META,
-      payload: [
-        await createDbMetaEvent(
-          sthis,
-          {
-            cars: [await simpleCID(sthis)],
-          },
-          [await simpleCID(sthis), await simpleCID(sthis)],
-        ),
-      ],
-    } satisfies FPEnvelopeMeta;
-    const ser = await 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 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 SerializedMeta[],
-        );
-      },
-    });
-    expect(res.isOk()).toBeTruthy();
-    const meta = res.unwrap() as FPEnvelopeMeta;
-    expect(meta.type).toEqual("meta");
-    expect(Object.keys(meta.payload).includes("key")).toBeFalsy();
-    expect(key).toEqual("key");
-  });
-});

package/runtime/key-bag.test.ts

@@ -1,243 +0,0 @@
-import { Result, URI } from "@adviser/cement";
-import { getKeyBag, KeyBagProviderMemory } from "@fireproof/core-keybag";
-import { ensureSuperThis } from "@fireproof/core-runtime";
-import { KeyBagIf, V2KeysItem, V2StorageKeyItem } from "@fireproof/core-types-base";
-import { isKeyUpsertResultModified, KeysByFingerprint } from "@fireproof/core-types-blockstore";
-import { base58btc } from "multiformats/bases/base58";
-import { assert, describe, expect, it } from "vitest";
-
-// const v2Keybag = {
-//   name: "@test-v1-keys-wal@",
-//   keys: {
-//     z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ: {
-//       default: true,
-//       fingerPrint: "z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ",
-//       key: "zL89nmBmogeRptW9b7e9j7L",
-//     },
-//   },
-// };
-
-const v1Keybag = {
-  name: "@test-v1-keys-wal@",
-  key: "zL89nmBmogeRptW9b7e9j7L",
-};
-
-async function keyExtracted(
-  rKbf: Result<KeysByFingerprint>,
-  fingerPrint?: string,
-): Promise<{ fingerPrint: string; key: string } | undefined> {
-  const kbf = await rKbf.Ok().get(fingerPrint);
-  if (!kbf) {
-    return undefined;
-  }
-  return {
-    fingerPrint: kbf.fingerPrint,
-    key: (await kbf.extract()).keyStr,
-  };
-}
-
-async function calculateFingerprint(rKbf: Result<KeysByFingerprint>, kb: KeyBagIf): Promise<string> {
-  const item = await rKbf.Ok().get();
-  const v2Item = await (
-    item as unknown as {
-      asV2StorageKeyItem: () => Promise<V2StorageKeyItem>;
-    }
-  ).asV2StorageKeyItem();
-  const keyBytes = base58btc.decode(v2Item.key);
-  const hash = await kb.rt.crypto.digestSHA256(keyBytes);
-  return base58btc.encode(new Uint8Array(hash));
-}
-
-describe("KeyBag", () => {
-  it("v1 migration", async () => {
-    const sthis = ensureSuperThis();
-    await sthis.start();
-
-    const kp = new KeyBagProviderMemory(URI.from("memory://./dist/tests/"), sthis);
-    kp.set(v1Keybag as unknown as V2KeysItem);
-
-    const kb = await getKeyBag(sthis, {
-      url: "memory://./dist/tests/?extractKey=_deprecated_internal_api",
-    });
-    const rKbf = await kb.getNamedKey("@test-v1-keys-wal@");
-    expect(rKbf.isOk()).toBeTruthy();
-
-    const fpr = await calculateFingerprint(rKbf, kb);
-
-    expect(await rKbf.Ok().asV2KeysItem()).toEqual({
-      keys: {
-        z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ: {
-          default: true,
-          fingerPrint: fpr,
-          key: "zL89nmBmogeRptW9b7e9j7L",
-        },
-      },
-      name: "@test-v1-keys-wal@",
-    });
-
-    const kb2 = await getKeyBag(sthis, {
-      url: "memory://./dist/tests/?extractKey=_deprecated_internal_api",
-    });
-    for (const rkbf of [rKbf, await kb2.getNamedKey("@test-v1-keys-wal@")]) {
-      expect(await keyExtracted(rkbf)).toEqual({
-        fingerPrint: "z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ",
-        key: "zL89nmBmogeRptW9b7e9j7L",
-      });
-      expect(await keyExtracted(rkbf, "z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ")).toEqual({
-        fingerPrint: "z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ",
-        key: "zL89nmBmogeRptW9b7e9j7L",
-      });
-      expect(await keyExtracted(rkbf, "kaputt-x")).toBeUndefined();
-    }
-    expect(await kp.get(v1Keybag.name)).toEqual({
-      keys: {
-        z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ: {
-          default: true,
-          fingerPrint: "z7oNYUrGpALe6U5ePvhdD3ufHdLerw4wPWHJERE3383zJ",
-          key: "zL89nmBmogeRptW9b7e9j7L",
-        },
-      },
-      name: "@test-v1-keys-wal@",
-    });
-  });
-
-  it("implicit creation", async () => {
-    const sthis = ensureSuperThis();
-    await sthis.start();
-
-    const kp = new KeyBagProviderMemory(URI.from("memory://./dist/tests/"), sthis);
-    kp.set(v1Keybag as unknown as V2KeysItem);
-
-    const kb = await getKeyBag(sthis, {
-      url: "memory://./dist/tests/?extractKey=_deprecated_internal_api",
-    });
-    const key1Material = kb.rt.crypto.randomBytes(kb.rt.keyLength);
-    const rKbf = await kb.getNamedKey("kaputt", false, key1Material);
-    expect(rKbf.isOk()).toBeTruthy();
-    const one = await rKbf.Ok().asV2KeysItem();
-    expect(Object.keys(one.keys).length).toBe(1);
-    const key1Fpr = (await rKbf.Ok().get())?.fingerPrint;
-    expect(await keyExtracted(rKbf)).toEqual({
-      fingerPrint: key1Fpr,
-      key: base58btc.encode(key1Material),
-    });
-
-    const key2Material = kb.rt.crypto.randomBytes(kb.rt.keyLength);
-    const rKey2 = await rKbf.Ok().upsert(key2Material);
-    const key2 = rKey2.Ok();
-    if (!isKeyUpsertResultModified(key2)) {
-      assert("key2 not modified");
-      return;
-    }
-
-    const keys2 = await rKbf.Ok().asV2KeysItem();
-    expect(Object.keys(keys2.keys).length).toBe(2);
-
-    expect(await kp.get("kaputt")).toEqual(keys2);
-
-    const rKbf2 = await kb.getNamedKey("kaputt");
-
-    expect(Object.keys(await rKbf2.Ok().asV2KeysItem()).length).toBe(2);
-
-    expect((await rKbf2.Ok().get())?.fingerPrint).toEqual(key1Fpr);
-
-    const asKeysItem = await rKbf.Ok().asV2KeysItem();
-    expect(asKeysItem.name).toEqual("kaputt");
-    expect(Array.from(Object.values(asKeysItem.keys))).toEqual([
-      {
-        default: true,
-        fingerPrint: key1Fpr,
-        key: base58btc.encode(key1Material),
-      },
-      {
-        default: false,
-        fingerPrint: key2.kfp.fingerPrint,
-        key: base58btc.encode(key2Material),
-      },
-    ]);
-
-    const key3Material = kb.rt.crypto.randomBytes(kb.rt.keyLength);
-    const rKey3 = await rKbf2.Ok().upsert(key3Material, true);
-    const key3 = rKey3.Ok();
-    if (!isKeyUpsertResultModified(key3)) {
-      assert("key3 not modified");
-      return;
-    }
-
-    expect(
-      Object.keys(
-        await rKbf2
-          .Ok()
-          .asV2KeysItem()
-          .then((i) => i.keys),
-      ).length,
-    ).toBe(3);
-    const v2Key3 = await (key3.kfp as unknown as { asV2StorageKeyItem: () => Promise<V2StorageKeyItem> }).asV2StorageKeyItem();
-
-    expect(await kp.get("kaputt")).toEqual({
-      keys: {
-        ...resetDefault(one.keys),
-        ...resetDefault(keys2.keys),
-        [v2Key3.fingerPrint]: v2Key3,
-      },
-      name: "kaputt",
-    });
-  });
-
-  it("simple default", async () => {
-    const sthis = ensureSuperThis();
-    await sthis.start();
-
-    const kb = await getKeyBag(sthis);
-
-    const keyName = "simple" + sthis.nextId().str;
-
-    const rKbf1 = await kb.getNamedKey(keyName);
-    const kfp1 = await rKbf1
-      .Ok()
-      .get()
-      .then((i) => (i as unknown as { asV2StorageKeyItem: () => Promise<V2StorageKeyItem> }).asV2StorageKeyItem());
-    expect(kfp1?.fingerPrint).toBeTypeOf("string");
-
-    const rKbf2 = await kb.getNamedKey(keyName);
-    expect(await rKbf2.Ok().get()).toBeDefined();
-    const kfp2 = await rKbf2.Ok().get();
-    expect(kfp1?.fingerPrint).toBe(kfp2?.fingerPrint);
-
-    expect(await kb.rt.getBagProvider().then((i) => i.get(keyName))).toEqual({
-      keys: {
-        [kfp1?.fingerPrint as string]: {
-          default: true,
-          fingerPrint: kfp1?.fingerPrint,
-          key: kfp1?.key,
-        },
-      },
-      name: keyName,
-    });
-  });
-  it("test stable id", async () => {
-    const sthis = ensureSuperThis();
-    await sthis.start();
-
-    const kp = new KeyBagProviderMemory(URI.from("memory://./dist/tests/"), sthis);
-    kp.set(v1Keybag as unknown as V2KeysItem);
-
-    const kb = await getKeyBag(sthis, {
-      url: "memory://./dist/tests/?extractKey=_deprecated_internal_api",
-    });
-
-    const name = "default-key" + Math.random();
-    const rMyKey = await kb.getNamedKey(name);
-
-    for (let i = 0; i < 10; ++i) {
-      expect(await kb.getNamedKey(name).then((i) => i.Ok().id)).toEqual(rMyKey.Ok().id);
-    }
-  });
-});
-
-function resetDefault(keys: Record<string, V2StorageKeyItem>) {
-  return Array.from(Object.values(keys)).reduce(
-    (acc, i) => ({ ...acc, [i.fingerPrint]: { ...i, default: false } }),
-    {} as Record<string, V2StorageKeyItem>,
-  );
-}

package/runtime/meta-key-hack.test.ts

@@ -1,103 +0,0 @@
-import { BuildURI, URI } from "@adviser/cement";
-import { fireproof } from "@fireproof/core-base";
-import { registerStoreProtocol } from "@fireproof/core-blockstore";
-import { MemoryGateway } from "@fireproof/core-gateways-memory";
-import { DbMetaEvent, Loadable, V2SerializedMetaKey } from "@fireproof/core-types-blockstore";
-import { AddKeyToDbMetaGateway } from "@fireproof/core-gateways-base";
-import { beforeAll, describe, expect, it, vitest } from "vitest";
-import { KeyBag } from "@fireproof/core-keybag";
-import { ensureSuperThis } from "@fireproof/core-runtime";
-import { Database, PARAM } from "@fireproof/core-types-base";
-
-describe("MetaKeyHack", () => {
-  const storageMap = new Map();
-
-  const sthis = ensureSuperThis();
-  const memGw = new MemoryGateway(sthis, storageMap);
-  registerStoreProtocol({
-    protocol: "hack:",
-    defaultURI: () => URI.from(`hack://localhost?version=hack`),
-    serdegateway: async () => {
-      return new AddKeyToDbMetaGateway(memGw, "v2");
-    },
-  });
-
-  let db: Database;
-  let ctx: { loader: 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 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 V2SerializedMetaKey;
-    const keyMaterials = metas.keys;
-    const dataStoreKeyMaterial = await rDataStoreKeyItem.Ok().asV2KeysItem();
-    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 AddKeyToDbMetaGateway;
-    expect(
-      subscribeFn.mock.calls.map((i) => i.map((i) => i.payload.map((i: 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/setup.file.ts

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

package/setup.memory.ts

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

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": [
-    "/home/runner/work/fireproof/fireproof/tsconfig.dist.json"
-  ],
-  "compilerOptions": {
-    "noEmit": false,
-    "outDir": "./"
-  },
-  "include": [
-    "**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    ".git",
-    ".vscode"
-  ]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    projects: ["vitest.file.config.ts", "vitest.memory.config.ts", "vitest.indexeddb.config.ts"],
-    globalSetup: "global-setup.ts",
-  },
-});

package/vitest.file.config.ts

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

package/vitest.indexeddb.config.ts

@@ -1,34 +0,0 @@
-/// <reference types="@vitest/browser/providers/playwright" />
-/// <reference types="@vitest/browser/providers/webdriverio" />
-
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    name: "indexeddb",
-    exclude: ["dist/**", "node_modules/**", "examples/**", "gateway/file"],
-    include: ["**/*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: "./setup.indexeddb.ts",
-  },
-});