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

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();
+  });
+});

package/tests/helpers.ts

@@ -1,7 +1,8 @@
-import { runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
-import { dataDir, rt, SuperThis } from "@fireproof/core";
-
-export { dataDir };
+import { BuildURI, MockLogger, runtimeFn, toCryptoRuntime, URI, utils, LogCollector } from "@adviser/cement";
+import { ensureSuperThis, rt, SuperThis, SuperThisOpts, bs, PARAM } from "@fireproof/core";
+import { CID } from "multiformats";
+import { sha256 } from "multiformats/hashes/sha2";
+import * as json from "multiformats/codecs/json";
 
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -37,16 +38,42 @@ export function storageURL(sthis: SuperThis): URI {
   return merged;
 }
 
-// export type MockSuperThis = SuperThis & { logCollector: LogCollector };
-// // eslint-disable-next-line @typescript-eslint/no-unused-vars
-// export function mockSuperThis(sthis?: Partial<SuperThisOpts>): MockSuperThis {
-//   const mockLog = MockLogger();
-//   const ethis = ensureSuperThis({
-//     logger: mockLog.logger,
-//     ctx: {
-//       logCollector: mockLog.logCollector,
-//     },
-//   }) as MockSuperThis;
-//   ethis.logCollector = mockLog.logCollector;
-//   return ethis;
-// }
+export type MockSuperThis = SuperThis & { ctx: { readonly logCollector: LogCollector } };
+export function mockSuperThis(sthis?: Partial<SuperThisOpts>): MockSuperThis {
+  const mockLog = MockLogger({
+    pass: new utils.ConsoleWriterStreamDefaultWriter(new utils.ConsoleWriterStream()),
+  });
+  return ensureSuperThis({
+    ...sthis,
+    logger: mockLog.logger,
+    ctx: {
+      logCollector: mockLog.logCollector,
+    },
+  }) as MockSuperThis;
+}
+
+export function noopUrl(name?: string): URI {
+  const burl = BuildURI.from("memory://noop");
+  burl.setParam(PARAM.NAME, name || "test");
+  return burl.URI();
+}
+
+export function simpleBlockOpts(sthis: SuperThis, name?: string) {
+  const url = noopUrl(name);
+  return {
+    keyBag: rt.kb.defaultKeyBagOpts(sthis),
+    storeRuntime: bs.toStoreRuntime(sthis),
+    storeUrls: {
+      file: url,
+      wal: url,
+      meta: url,
+      data: url,
+    },
+  };
+}
+
+export async function simpleCID(sthis: SuperThis) {
+  const bytes = json.encode({ hello: sthis.nextId().str });
+  const hash = await sha256.digest(bytes);
+  return CID.create(1, json.code, hash);
+}

package/tests/react/useFireproof.test.tsx

@@ -13,7 +13,7 @@ describe("HOOK: useFireproof", () => {
       const { database, useLiveQuery, useDocument } = useFireproof("dbname");
       expect(typeof useLiveQuery).toBe("function");
       expect(typeof useDocument).toBe("function");
-      expect(database?.constructor.name).toBe("Database");
+      expect(database?.constructor.name).toMatch(/^Database/);
     });
   });
 });

package/tests/www/todo.html

@@ -75,8 +75,9 @@
 
         let compactor = "🚗";
         function drawInfo() {
-          document.querySelector("#carLog").innerText =
-            ` ⏰ ${db._crdt.clock.head.length} ${compactor} ${cx.loader.carLog.length}  📩 ${1}`;
+          document.querySelector("#carLog").innerText = ` ⏰ ${db._crdt.clock.head.length} ${compactor} ${
+            cx.loader.carLog.length
+          }  📩 ${1}`;
         }
         const doRedraw = async () => {
           drawInfo();
@@ -164,7 +165,7 @@
           const timeout =
             10 +
             Math.pow(db._crdt.clock.head.length + cx.loader.taskManager.queue.length, 2) *
-              (Math.floor(Math.random() * 2000) + 2000);
+              (Math.floor(Math.random() * 1000) + 1000);
           // console.log('go worker', timeout/ 1000)
           worker = setTimeout(async () => {
             await Promise.all(
@@ -195,6 +196,25 @@
         };
         window.toggleWorker = toggleWorker;
 
+        async function writeStorm(e) {
+          e.preventDefault();
+          compactor = "🐦‍🔥";
+          drawInfo();
+
+          const dcs = await db.allDocs();
+          const lastRow = dcs.rows[dcs.rows.length - 1];
+          const theDoc = lastRow.value;
+          for (let i = 0; i < 50; i++) {
+            theDoc.clicks = (theDoc.clicks || 0) + 1;
+            theDoc.completed = !theDoc.completed;
+            await db.put(theDoc);
+          }
+
+          drawInfo();
+          compactor = "🚗";
+        }
+        window.writeStorm = writeStorm;
+
         async function doCompact(e) {
           e.preventDefault();
           compactor = "🚕";
@@ -221,6 +241,7 @@
 
     <p>This version of the Fireprof test app uses PartyKit as the storage backend. Refresh is automatic and live.</p>
 
+    <button id="rocket" onclick="writeStorm(event)">🚀</button>
     <button id="robot" onclick="toggleWorker(event)">🤖</button>
     <span id="carLog" onclick="doCompact(event)"></span>
     <span id="cxInfo"></span>