@fireproof/core 0.20.0-dev-preview-40 → 0.20.0-dev-preview-50

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

@@ -7,7 +7,7 @@ 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));
+    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);
@@ -15,7 +15,7 @@ describe("storage-content", () => {
 
   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));
+    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);
@@ -167,7 +167,7 @@ describe("de-serialize", () => {
 
   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));
+    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);
@@ -175,7 +175,7 @@ describe("de-serialize", () => {
 
   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));
+    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);
@@ -185,7 +185,7 @@ describe("de-serialize", () => {
     const raw = new Uint8Array([55, 56, 57]);
     const res = await rt.gw.fpDeserialize(
       sthis,
-      BuildURI.from("http://x.com?store=data&suffix=.car").URI(),
+      BuildURI.from("http://x.com?store=car&suffix=.car").URI(),
       Promise.resolve(Result.Ok(raw)),
     );
     expect(res.isOk()).toBeTruthy();
@@ -195,21 +195,21 @@ describe("de-serialize", () => {
 
   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);
+    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=data&suffix=.car").URI(), raw);
+    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=data&suffix=.car").URI(), raw);
+    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");
   });

package/tests/gateway/indexeddb/loader-config.test.ts

@@ -16,13 +16,13 @@ describe("fireproof config indexeddb", () => {
     await db.put({ name: "my-app" });
     expect(db.ledger.name).toBe(my_app());
 
-    const fileStore = await db.ledger.crdt.blockstore.loader.fileStore();
+    const fileStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.file;
     expect(fileStore?.url().asObj()).toEqual({
       pathname: "fp",
       protocol: "indexeddb:",
       searchParams: {
         name: "my-app",
-        store: "data",
+        store: "file",
         runtime: "browser",
         storekey: "@my-app-data@",
         urlGen: "default",
@@ -31,13 +31,13 @@ describe("fireproof config indexeddb", () => {
       style: "path",
     });
 
-    const dataStore = await db.ledger.crdt.blockstore.loader.carStore();
+    const dataStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.car;
     expect(dataStore?.url().asObj()).toEqual({
       pathname: "fp",
       protocol: "indexeddb:",
       searchParams: {
         name: "my-app",
-        store: "data",
+        store: "car",
         runtime: "browser",
         storekey: "@my-app-data@",
         suffix: ".car",
@@ -46,7 +46,7 @@ describe("fireproof config indexeddb", () => {
       },
       style: "path",
     });
-    const metaStore = await db.ledger.crdt.blockstore.loader.metaStore();
+    const metaStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
     expect(metaStore?.url().asObj()).toEqual({
       pathname: "fp",
       protocol: "indexeddb:",
@@ -60,7 +60,7 @@ describe("fireproof config indexeddb", () => {
       },
       style: "path",
     });
-    const WALStore = await db.ledger.crdt.blockstore.loader.WALStore();
+    const WALStore = await db.ledger.crdt.blockstore.loader.attachedStores.local().active.wal;
     expect(WALStore?.url().asObj()).toEqual({
       pathname: "fp",
       protocol: "indexeddb:",

package/tests/helpers.ts

@@ -1,5 +1,16 @@
 import { BuildURI, MockLogger, runtimeFn, toCryptoRuntime, URI, utils, LogCollector } from "@adviser/cement";
-import { ensureSuperThis, rt, SuperThis, SuperThisOpts, bs, PARAM } from "@fireproof/core";
+import {
+  ensureSuperThis,
+  rt,
+  SuperThis,
+  SuperThisOpts,
+  bs,
+  PARAM,
+  Attachable,
+  Attached,
+  CarTransaction,
+  Falsy,
+} from "@fireproof/core";
 import { CID } from "multiformats";
 import { sha256 } from "multiformats/hashes/sha2";
 import * as json from "multiformats/codecs/json";
@@ -67,7 +78,7 @@ export function simpleBlockOpts(sthis: SuperThis, name?: string) {
       file: url,
       wal: url,
       meta: url,
-      data: url,
+      car: url,
     },
   };
 }
@@ -77,3 +88,71 @@ export async function simpleCID(sthis: SuperThis) {
   const hash = await sha256.digest(bytes);
   return CID.create(1, json.code, hash);
 }
+
+class MockLoader implements bs.Loadable {
+  readonly sthis: SuperThis;
+  readonly ebOpts: bs.BlockstoreRuntime;
+  readonly carLog: bs.CarLog;
+  readonly attachedStores: bs.AttachedStores;
+  readonly taskManager: bs.TaskManager;
+
+  constructor(sthis: SuperThis) {
+    this.sthis = sthis;
+    this.ebOpts = {} as bs.BlockstoreRuntime;
+    this.carLog = new bs.CarLog();
+    this.taskManager = new bs.TaskManager(sthis, () => Promise.resolve(), {
+      removeAfter: 3,
+      retryTimeout: 50,
+    });
+    this.attachedStores = new bs.AttachedRemotesImpl(this);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  attach(attached: Attachable): Promise<Attached> {
+    throw new Error("Method not implemented.");
+  }
+  ready(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  close(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  keyBag(): Promise<rt.KeyBag> {
+    return rt.kb.getKeyBag(this.sthis, {});
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  handleDbMetasFromStore(metas: bs.DbMeta[], store: bs.ActiveStore): Promise<void> {
+    // throw new Error("Method not implemented.");
+    return Promise.resolve();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  commit<T = unknown>(t: CarTransaction, done: T, opts: bs.CommitOpts): Promise<bs.CarGroup> {
+    throw new Error("Method not implemented.");
+  }
+  destroy(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getBlock(cid: bs.AnyLink, store: bs.ActiveStore): Promise<bs.AnyBlock | Falsy> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  loadFileCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<bs.CarCacheItem> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  loadCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<bs.CarCacheItem> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  commitFiles(t: CarTransaction, done: bs.TransactionMeta): Promise<bs.CarGroup> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  entries(cache?: boolean): AsyncIterableIterator<bs.AnyBlock> {
+    throw new Error("Method not implemented.");
+  }
+}
+export function mockLoader(sthis: SuperThis): bs.Loadable {
+  return new MockLoader(sthis);
+}

package/tests/react/useFireproof.test.tsx

@@ -2,7 +2,7 @@ import { renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it } from "vitest";
 
 import { Database, fireproof, useFireproof } from "use-fireproof";
-import { LiveQueryResult, UseDocumentResult } from "../../src/react/useFireproof.js";
+import { LiveQueryResult, UseDocumentResult } from "use-fireproof";
 
 describe("HOOK: useFireproof", () => {
   it("should be defined", () => {
@@ -20,24 +20,20 @@ describe("HOOK: useFireproof", () => {
 });
 
 describe("HOOK: useFireproof useLiveQuery has results", () => {
-  const dbName = "dbnameuseFP";
+  const dbName = "useLiveQueryHasResults";
   let db: Database,
     query: LiveQueryResult<{ foo: string }, string>,
     database: ReturnType<typeof useFireproof>["database"],
     useLiveQuery: ReturnType<typeof useFireproof>["useLiveQuery"];
 
+  let cnt = 0;
+
   beforeEach(async () => {
     db = fireproof(dbName);
-    await db.put({ foo: "aha" });
-    await db.put({ foo: "bar" });
-    await db.put({ foo: "caz" });
-
-    renderHook(() => {
-      const result = useFireproof(dbName);
-      database = result.database;
-      useLiveQuery = result.useLiveQuery;
-      query = useLiveQuery<{ foo: string }>("foo");
-    });
+    await db.put({ foo: "aha", cnt });
+    await db.put({ foo: "bar", cnt });
+    await db.put({ foo: "caz", cnt });
+    cnt++;
   });
 
   it("should have setup data", async () => {
@@ -49,19 +45,29 @@ describe("HOOK: useFireproof useLiveQuery has results", () => {
   });
 
   it("queries correctly", async () => {
+    renderHook(() => {
+      const result = useFireproof(dbName);
+      database = result.database;
+      useLiveQuery = result.useLiveQuery;
+      query = useLiveQuery<{ foo: string }>("foo");
+    });
+
     await waitFor(() => {
+      // act(() => {
+      // expect(query.rows).toBe([]);
       expect(query.rows.length).toBe(3);
       expect(query.rows[0].doc?.foo).toBe("aha");
       expect(query.rows[1].doc?.foo).toBe("bar");
       expect(query.rows[2].doc?.foo).toBe("caz");
+      // });
     });
   });
 
   afterEach(async () => {
     await db.close();
     await db.destroy();
-    await database.close();
-    await database.destroy();
+    await database?.close();
+    await database?.destroy();
   });
 });
 
@@ -269,9 +275,8 @@ describe("HOOK: useFireproof useDocument has results reset sync", () => {
 
     const allDocs = await db.allDocs<{ input: string }>();
     expect(allDocs.rows.length).toBe(3);
-    expect(allDocs.rows[0].value.input).toBe("first");
-    expect(allDocs.rows[1].value.input).toBe("new");
-    expect(allDocs.rows[2].value.input).toBe("fresh");
+    const inputs = allDocs.rows.map((r) => r.value.input);
+    expect(inputs).toEqual(expect.arrayContaining(["first", "new", "fresh"]));
   });
 
   afterEach(async () => {
@@ -511,3 +516,40 @@ describe("HOOK: useFireproof race condition: calling save() without await overwr
     await db.destroy();
   });
 });
+
+describe("useFireproo calling submit()", () => {
+  const dbName = "submitDb";
+  let db: Database, docResult: UseDocumentResult<{ input: string }>;
+
+  beforeEach(async () => {
+    db = fireproof(dbName);
+
+    // Render a new hook instance
+    renderHook(() => {
+      const { useDocument } = useFireproof(dbName);
+      docResult = useDocument<{ input: string }>({ input: "" });
+    });
+  });
+
+  it("demonstrates that calling docResult.save() and docResult.reset() in the same tick can overwrite reset", async () => {
+    // Merge some changes into doc
+    docResult.merge({ input: "some data" });
+
+    docResult.submit();
+
+    // Let the async subscription produce a new doc in case the doc is reloaded with an _id
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // If the reset worked, doc._id should STILL be undefined.
+    // If the subscription wins, doc._id will be defined => test fails.
+    await waitFor(() => {
+      expect(docResult.doc._id).toBeUndefined();
+      expect(docResult.doc.input).toBe("");
+    });
+  });
+
+  afterEach(async () => {
+    await db.close();
+    await db.destroy();
+  });
+});