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

package/runtime/wait-pr-multiformats/index.js

@@ -1,3 +0,0 @@
-export * as block from "./block.js";
-export * as codec from "./codec-interface.js";
-//# sourceMappingURL=index.js.map

package/runtime/wait-pr-multiformats/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/runtime/wait-pr-multiformats/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC"}

package/tests/blockstore/fp-envelope.test.ts-off

@@ -1,65 +0,0 @@
-
-describe("FPEnvelope", () => {
-    // const sthis = mockSuperThis();
-    // it("unknown bytes", () => {
-    //     expect(bs.FPMsgMatch2Envelope(Uint8Array.from([1, 2, 3]), "bla").Err().message).toStrictEqual(
-    //         "failed to decode envelope: Error: CBOR decode error: too many terminals, data makes no sense"
-    //     );
-    // });
-
-    // it("unknown type", () => {
-    //     expect(bs.FPMsgMatch2Envelope(encode({ type: "blax", payload: 4 }), "bla"))
-    //         .toStrictEqual(Result.Err("expected type to be bla"));
-    // })
-
-    // it("no type", () => {
-    //     expect(bs.FPMsgMatch2Envelope(encode({ type: "blax", payload: 4 })))
-    //         .toStrictEqual(Result.Ok({ type: "blax", payload: 4 }));
-    // })
-
-    // it("car type", () => {
-    //     expect(bs.FPMsg2Car(bs.Car2FPMsg(Uint8Array.from([1, 2, 3])).Ok().payload).Ok()).toStrictEqual(Uint8Array.from([1, 2, 3]));
-    // })
-
-    // it("file type", () => {
-    //     expect(bs.FPMsg2File(bs.File2FPMsg(Uint8Array.from([1, 2, 3])).Ok().payload).Ok()).toStrictEqual(Uint8Array.from([1, 2, 3]));
-    // })
-
-    // it("meta type", async () => {
-    //     const ref = {
-    //         eventCid: await simpleCID(sthis),
-    //         dbMeta: {
-    //            cars: [
-    //             await simpleCID(sthis)
-    //            ]
-    //         },
-    //         parents: [
-    //             await simpleCID(sthis),
-    //             await simpleCID(sthis)
-    //         ]
-    //     } satisfies DbMetaEvent;
-    //     expect(bs.FPMsg2Meta(bs.Meta2FPMsg([ref])).Ok()).toEqual(ref);
-    // })
-
-    // it("wal type", () => {
-    //     const ref: bs.WALState = {
-    //         fileOperations: [],
-    //         noLoaderOps: [],
-    //         operations: [
-    //             {
-    //                 cars: [
-    //                     CID.parse("bag4yvqabciqdzvfxrxfi6feubspyz666zegmp3z5w556mr4ykya2kkdm22r7pyy")
-    //                 ]
-    //             },
-    //             {
-    //                 cars: [
-    //                     CID.parse("bag4yvqabciqd2ul2tw4mdcpvfq2pdqhvnqp2ktuyrtcl3j3gwhxbjzjt62xzeaq")
-    //                 ]
-    //             }
-    //         ]
-    //     };
-    //     const res = bs.FPMsg2WAL(bs.WAL2FPMsg(sthis, ref).Ok()).Ok();
-    //     expect(res).toStrictEqual(ref);
-    //     expect(res.operations[0].cars[0].version).toStrictEqual(1);
-    // })
-})

package/tests/blockstore/fragment-gateway.test.ts-off

@@ -1,106 +0,0 @@
-import { Result, URI } from "@adviser/cement";
-import { bs, ensureSuperThis } from "@fireproof/core";
-
-class TraceGateway implements bs.Gateway {
-  readonly buildUrlFn = vitest.fn();
-
-  readonly fragSize: number;
-  constructor(fragSize = 0) {
-    this.fragSize = fragSize;
-  }
-
-  buildUrl(baseUrl: URI, key: string): Promise<Result<URI>> {
-    this.buildUrlFn(baseUrl, key);
-    return Promise.resolve(Result.Ok(baseUrl.build().setParam("key", key).URI()));
-  }
-  readonly startFn = vitest.fn();
-  start(baseUrl: URI): Promise<Result<URI>> {
-    this.startFn(baseUrl);
-    const burl = baseUrl.build();
-    if (this.fragSize) {
-      burl.setParam("fragSize", this.fragSize.toString());
-    }
-    return Promise.resolve(Result.Ok(burl.URI()));
-  }
-  readonly closeFn = vitest.fn();
-  close(baseUrl: URI): Promise<bs.VoidResult> {
-    this.closeFn(baseUrl);
-    return Promise.resolve(Result.Ok(undefined));
-  }
-  readonly destroyFn = vitest.fn();
-  destroy(baseUrl: URI): Promise<bs.VoidResult> {
-    this.destroyFn(baseUrl);
-    return Promise.resolve(Result.Ok(undefined));
-  }
-  readonly getFn = vitest.fn();
-  putCalls = 0;
-  async get(url: URI): Promise<Result<Uint8Array>> {
-    const idx = this.putCalls++;
-    this.getFn(url);
-    return Result.Ok(this.putFn.mock.calls[idx][1]);
-  }
-  readonly putFn = vitest.fn();
-  async put(url: URI, data: Uint8Array): Promise<Result<void>> {
-    this.putFn(url, data);
-    return Result.Ok(undefined);
-  }
-  readonly deleteFn = vitest.fn();
-  async delete(url: URI): Promise<Result<void>> {
-    this.deleteFn(url);
-    return Result.Ok(undefined);
-  }
-}
-
-describe("FragmentGateway", () => {
-  const sthis = ensureSuperThis();
-  it("passthrough", async () => {
-    const innerGW = new TraceGateway();
-    const fgw = new bs.FragmentGateway(sthis, innerGW);
-    const url = URI.from("http://example.com?key=3333");
-
-    expect(await fgw.put(url, new Uint8Array([1, 2, 3, 4]))).toEqual(Result.Ok(undefined));
-    expect(innerGW.putFn).toHaveBeenCalledWith(url, new Uint8Array([1, 2, 3, 4]));
-
-    expect(await fgw.get(url)).toEqual(Result.Ok(new Uint8Array([1, 2, 3, 4])));
-    expect(innerGW.getFn).toHaveBeenCalledWith(url);
-  });
-
-  function slice(total: number, headerSize: number, fragSize: number): { len?: string; ofs: string }[] {
-    const res = [];
-    for (let ofs = 0; ofs < total; ofs += fragSize - headerSize) {
-      res.push({ len: total.toString(), ofs: ofs.toString() });
-    }
-    return res;
-  }
-
-  it("enable frag", async () => {
-    const innerGW = new TraceGateway(128);
-    const fgw = new bs.FragmentGateway(sthis, innerGW);
-    const url = (await fgw.start(URI.from("http://example.com?key=3333"))).Ok();
-    const buf = new Uint8Array(1024).fill(1).map((_, i) => i);
-
-    expect(await fgw.put(url, buf)).toEqual(Result.Ok(undefined));
-
-    const ref = slice(1024, fgw.headerSize, 128);
-
-    expect(
-      innerGW.putFn.mock.calls.map((i) => {
-        return {
-          len: i[0].getParam("len"),
-          ofs: i[0].getParam("ofs"),
-        };
-      }),
-    ).toEqual(ref);
-
-    expect((await fgw.get(url)).Ok()).toEqual(buf);
-    ref[0].len = undefined;
-    expect(
-      innerGW.getFn.mock.calls.map((i) => {
-        return {
-          len: i[0].getParam("len"),
-          ofs: i[0].getParam("ofs"),
-        };
-      }),
-    ).toEqual(ref);
-  });
-});

package/tests/blockstore/interceptor-gateway.test.ts

@@ -1,254 +0,0 @@
-import { BuildURI, Result, URI } from "@adviser/cement";
-import { bs, rt, fireproof, SuperThis } from "@fireproof/core";
-
-class TestInterceptor extends bs.PassThroughGateway {
-  readonly fn = vitest.fn();
-
-  async buildUrl(ctx: bs.SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<bs.SerdeGatewayBuildUrlReturn>> {
-    const ret = await super.buildUrl(ctx, baseUrl, key);
-    this.fn("buildUrl", ret);
-    return ret;
-  }
-
-  async start(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayStartReturn>> {
-    const ret = await super.start(ctx, baseUrl);
-    this.fn("start", ret);
-    return ret;
-  }
-  async close(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayCloseReturn>> {
-    const ret = await super.close(ctx, baseUrl);
-    this.fn("close", ret);
-    return ret;
-  }
-  async delete(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayDeleteReturn>> {
-    const ret = await super.delete(ctx, baseUrl);
-    this.fn("delete", ret);
-    return ret;
-  }
-  async destroy(ctx: bs.SerdeGatewayCtx, baseUrl: URI): Promise<Result<bs.SerdeGatewayDestroyReturn>> {
-    const ret = await super.destroy(ctx, baseUrl);
-    this.fn("destroy", ret);
-    return ret;
-  }
-  async put<T>(ctx: bs.SerdeGatewayCtx, url: URI, body: bs.FPEnvelope<T>): Promise<Result<bs.SerdeGatewayPutReturn<T>>> {
-    const ret = await super.put<T>(ctx, url, body);
-    this.fn("put", ret);
-    return ret;
-  }
-  async get<S>(ctx: bs.SerdeGatewayCtx, url: URI): Promise<Result<bs.SerdeGatewayGetReturn<S>>> {
-    const ret = await super.get<S>(ctx, url);
-    this.fn("get", ret);
-    return ret;
-  }
-  async subscribe(
-    ctx: bs.SerdeGatewayCtx,
-    url: URI,
-    callback: (meta: bs.FPEnvelopeMeta) => Promise<void>,
-  ): Promise<Result<bs.SerdeGatewaySubscribeReturn>> {
-    const ret = await super.subscribe(ctx, url, callback);
-    this.fn("subscribe", ret);
-    return ret;
-  }
-}
-
-export class URITrackGateway implements bs.Gateway {
-  readonly uris: Set<string>;
-  readonly memgw: rt.gw.memory.MemoryGateway;
-
-  constructor(sthis: SuperThis, memorys: Map<string, Uint8Array>, uris: Set<string>) {
-    this.memgw = new rt.gw.memory.MemoryGateway(sthis, memorys);
-    this.uris = uris;
-  }
-
-  uriAdd(uri: URI) {
-    if (!uri.getParam("itis")) {
-      throw new Error("itis not set");
-    }
-    if (this.uris.has(uri.toString())) {
-      throw new Error(`uri already added:${uri.toString()}`);
-    }
-    this.uris.add(uri.toString());
-  }
-
-  buildUrl(baseUrl: URI, key: string): Promise<Result<URI>> {
-    this.uriAdd(baseUrl);
-    return this.memgw.buildUrl(baseUrl, key);
-  }
-  start(baseUrl: URI): Promise<Result<URI>> {
-    this.uriAdd(baseUrl);
-    return this.memgw.start(baseUrl);
-  }
-  close(uri: URI): Promise<bs.VoidResult> {
-    this.uriAdd(uri);
-    return this.memgw.close(uri);
-  }
-  destroy(baseUrl: URI): Promise<bs.VoidResult> {
-    this.uriAdd(baseUrl);
-    return this.memgw.destroy(baseUrl);
-  }
-
-  put(url: URI, bytes: Uint8Array, sthis: SuperThis): Promise<bs.VoidResult> {
-    // console.log("put", url.getParam(PARAM.KEY), url.toString());
-    this.uriAdd(url);
-    return this.memgw.put(url.build().cleanParams("itis").URI(), bytes, sthis);
-  }
-
-  async get(url: URI, sthis: SuperThis): Promise<bs.GetResult> {
-    this.uriAdd(url);
-    const ret = await this.memgw.get(url.build().cleanParams("itis").URI(), sthis);
-    // if (ret.isErr()) {
-    //   console.log("get-err", url.getParam(PARAM.KEY), url.toString());
-    // }
-    return ret;
-  }
-  delete(url: URI): Promise<bs.VoidResult> {
-    this.uriAdd(url);
-    return this.memgw.delete(url);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  subscribe(url: URI, callback: (meta: Uint8Array) => void, sthis: SuperThis): Promise<bs.UnsubscribeResult> {
-    this.uriAdd(url);
-    return Promise.resolve(
-      Result.Ok(() => {
-        /* noop */
-      }),
-    );
-  }
-
-  async getPlain(url: URI, key: string): Promise<Result<Uint8Array>> {
-    this.uriAdd(url);
-    return this.memgw.getPlain(url, key);
-  }
-}
-
-describe("InterceptorGateway", () => {
-  it("passthrough", async () => {
-    const gwi = new TestInterceptor();
-    const db = fireproof("interceptor-gateway", {
-      gatewayInterceptor: gwi,
-    });
-    expect(
-      await db.put({
-        _id: "foo",
-        foo: 4,
-      }),
-    );
-    expect(await db.get("foo")).toEqual({
-      _id: "foo",
-      foo: 4,
-    });
-    await db.close();
-    await db.destroy();
-    // await sleep(1000);
-    expect(gwi.fn.mock.calls.length).toBe(54);
-    // might be a stupid test
-    expect(gwi.fn.mock.calls.map((i) => i[0]).sort() /* not ok there are some operation */).toEqual(
-      [
-        "start",
-        "start",
-        "buildUrl",
-        "get",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "buildUrl",
-        "get",
-        "get",
-        "start",
-        "start",
-        "buildUrl",
-        "get",
-        "get",
-        "buildUrl",
-        "put",
-        "put",
-        "buildUrl",
-        "put",
-        "buildUrl",
-        "put",
-        "put",
-        "put",
-        "put",
-        "put",
-        "start",
-        "start",
-        "start",
-        "start",
-        "close",
-        "close",
-        "close",
-        "close",
-        "buildUrl",
-        "get",
-        "close",
-        "close",
-        "close",
-        "close",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "destroy",
-        "subscribe",
-        "subscribe",
-      ].sort() /* not ok there are some operation */,
-    );
-  });
-
-  it("use the uri-interceptor", async () => {
-    let callCount = 0;
-    const gwUris = new Set<string>();
-    const unreg = bs.registerStoreProtocol({
-      protocol: "uriTest:",
-      isDefault: false,
-      defaultURI: () => {
-        return BuildURI.from("uriTest://").pathname("ram").URI();
-      },
-      gateway: async (sthis) => {
-        return new URITrackGateway(sthis, new Map<string, Uint8Array>(), gwUris);
-      },
-    });
-    const db = fireproof("interceptor-gateway", {
-      storeUrls: {
-        base: "uriTest://inspector-gateway",
-      },
-      gatewayInterceptor: bs.URIInterceptor.withMapper(async (uri: URI) =>
-        uri
-          .build()
-          .setParam("itis", "" + ++callCount)
-          .URI(),
-      ),
-    });
-    await Promise.all(
-      Array(5)
-        .fill(0)
-        .map((_, i) => db.put({ _id: "foo" + i, foo: i })),
-    );
-    expect((await db.allDocs<{ foo: number }>()).rows.map((i) => i.value.foo)).toEqual(
-      Array(5)
-        .fill(0)
-        .map((_, i) => i),
-    );
-    await db.close();
-    expect(callCount).toBe(gwUris.size);
-    expect(
-      Array.from(gwUris)
-        .map((i) => URI.from(i).getParam("itis"))
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        .sort((a, b) => +a! - +b!),
-    ).toEqual(
-      Array(gwUris.size)
-        .fill(1)
-        .map((_, i) => "" + (i + 1)),
-    );
-    unreg();
-  });
-});

package/tests/blockstore/keyed-crypto-indexeddb-file.test.ts

@@ -1,128 +0,0 @@
-import { bs, ensureSuperThis, PARAM, rt } from "@fireproof/core";
-import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
-import { base58btc } from "multiformats/bases/base58";
-import { mockLoader, mockSuperThis } from "../helpers.js";
-import { KeyBagProviderIndexedDB } from "@fireproof/core/indexeddb";
-
-describe("KeyBag indexeddb and file", () => {
-  let url: URI;
-  const sthis = mockSuperThis();
-  beforeAll(async () => {
-    await sthis.start();
-    if (runtimeFn().isBrowser) {
-      url = URI.from("indexeddb://fp-keybag");
-    } else {
-      url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-    }
-  });
-  it("default-path", async () => {
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.delete("FP_KEYBAG_URL");
-    const kb = await rt.kb.getKeyBag(sthis);
-    if (runtimeFn().isBrowser) {
-      expect(kb.rt.url.toString()).toBe(`indexeddb://fp-keybag`);
-    } else {
-      expect(kb.rt.url.toString()).toBe(`file://${sthis.env.get("HOME")}/.fireproof/keybag`);
-    }
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-  it("from env", async () => {
-    const old = sthis.env.get("FP_KEYBAG_URL");
-    sthis.env.set("FP_KEYBAG_URL", url.toString());
-    const kb = await rt.kb.getKeyBag(sthis);
-    expect(kb.rt.url.toString()).toBe(url.toString());
-    sthis.env.set("FP_KEYBAG_URL", old);
-  });
-  it("simple add", async () => {
-    const kb = await rt.kb.getKeyBag(sthis, {
-      url: url.toString(),
-      crypto: toCryptoRuntime({
-        randomBytes: (size) => new Uint8Array(size).map((_, i) => i),
-      }),
-    });
-    const name = "setkey" + Math.random();
-    expect((await kb.getNamedKey(name, true)).isErr()).toBeTruthy();
-
-    const key = base58btc.encode(kb.rt.crypto.randomBytes(kb.rt.keyLength));
-    const res = await kb.getNamedKey(name, false, key);
-    expect(res.isOk()).toBeTruthy();
-    expect((await kb.getNamedKey(name, true)).Ok()).toEqual(res.Ok());
-
-    const name2 = "implicit" + Math.random();
-    const created = await kb.getNamedKey(name2);
-    expect(created.isOk()).toBeTruthy();
-
-    expect((await kb.getNamedKey(name2)).Ok()).toEqual(created.Ok());
-
-    let diskBag: rt.kb.KeysItem;
-    let diskBag2: rt.kb.KeysItem;
-    const provider = await kb.rt.getBagProvider();
-    if (runtimeFn().isBrowser) {
-      const p = provider as KeyBagProviderIndexedDB;
-      diskBag = await p._prepare().then((db) => db.get("bag", name));
-      diskBag2 = await p._prepare().then((db) => db.get("bag", name2));
-    } else {
-      const p = provider as rt.gw.file.KeyBagProviderFile;
-      const { sysFS } = await p._prepare(name);
-
-      diskBag = await sysFS.readfile((await p._prepare(name)).fName).then((data) => {
-        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeysItem;
-      });
-      diskBag2 = await sysFS.readfile((await p._prepare(name2)).fName).then((data) => {
-        return JSON.parse(sthis.txt.decode(data)) as rt.kb.KeysItem;
-      });
-    }
-    expect((await rt.kb.toKeyWithFingerPrint(kb, Object.values(diskBag.keys)[0].key)).Ok().fingerPrint).toEqual(
-      (await res.Ok().get())?.fingerPrint,
-    );
-    expect((await rt.kb.toKeyWithFingerPrint(kb, Object.values(diskBag2.keys)[0].key)).Ok().fingerPrint).toEqual(
-      (await created.Ok().get())?.fingerPrint,
-    );
-    const algo = {
-      name: "AES-GCM",
-      iv: kb.rt.crypto.randomBytes(12),
-      tagLength: 128,
-    };
-    const data = kb.rt.crypto.randomBytes(122);
-    const rkc = (await res.Ok().get()) as bs.KeyWithFingerPrint;
-    const ckc = (await created.Ok().get()) as bs.KeyWithFingerPrint;
-    expect(await kb.rt.crypto.encrypt(algo, rkc.key, data)).toEqual(await kb.rt.crypto.encrypt(algo, ckc.key, data));
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag.keys)[0].key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, ckc.key, data),
-    );
-    expect(await kb.rt.crypto.encrypt(algo, await kb.subtleKey(Object.values(diskBag2.keys)[0].key), data)).toEqual(
-      await kb.rt.crypto.encrypt(algo, ckc.key, data),
-    );
-  });
-});
-
-describe("KeyedCryptoStore", () => {
-  let loader: bs.Loadable;
-  // let logger: Logger;
-  let baseUrl: URI;
-  const sthis = ensureSuperThis();
-  beforeEach(async () => {
-    await sthis.start();
-    // logger = MockLogger().logger;
-    // let kbUrl: URI;
-    if (runtimeFn().isBrowser) {
-      // kbUrl = URI.from("indexeddb://fp-keybag");
-      baseUrl = URI.from("indexeddb://fp-keyed-crypto-store");
-    } else {
-      // kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-      baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
-    }
-    baseUrl = baseUrl.build().defParam(PARAM.NAME, "test").URI();
-    loader = mockLoader(sthis);
-  });
-  it("no crypto", async () => {
-    const url = baseUrl.build().setParam(PARAM.STORE_KEY, "insecure").URI();
-    for (const pstore of (await bs.createAttachedStores(url, loader, "insecure")).stores.baseStores) {
-      const store = await pstore;
-      // await store.start();
-      const kc = await store.keyedCrypto();
-      expect(kc.constructor.name).toBe("noCrypto");
-      // expect(kc.isEncrypting).toBe(false);
-    }
-  });
-});