@fireproof/core 0.21.0-dev-preview-7 → 0.22.0-keybag

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/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",
-  },
-});