@fireproof/core 0.20.0-dev-preview-41 → 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

@@ -22,7 +22,7 @@ describe("fireproof config indexeddb", () => {
       protocol: "indexeddb:",
       searchParams: {
         name: "my-app",
-        store: "data",
+        store: "file",
         runtime: "browser",
         storekey: "@my-app-data@",
         urlGen: "default",
@@ -37,7 +37,7 @@ describe("fireproof config indexeddb", () => {
       protocol: "indexeddb:",
       searchParams: {
         name: "my-app",
-        store: "data",
+        store: "car",
         runtime: "browser",
         storekey: "@my-app-data@",
         suffix: ".car",

package/tests/helpers.ts

@@ -14,8 +14,6 @@ import {
 import { CID } from "multiformats";
 import { sha256 } from "multiformats/hashes/sha2";
 import * as json from "multiformats/codecs/json";
-import { CarReader } from "@ipld/car";
-import { TaskManager } from "../src/blockstore/task-manager.js";
 
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -96,13 +94,16 @@ class MockLoader implements bs.Loadable {
   readonly ebOpts: bs.BlockstoreRuntime;
   readonly carLog: bs.CarLog;
   readonly attachedStores: bs.AttachedStores;
-  readonly taskManager: TaskManager;
+  readonly taskManager: bs.TaskManager;
 
   constructor(sthis: SuperThis) {
     this.sthis = sthis;
     this.ebOpts = {} as bs.BlockstoreRuntime;
-    this.carLog = [];
-    this.taskManager = new TaskManager(sthis, () => Promise.resolve());
+    this.carLog = new bs.CarLog();
+    this.taskManager = new bs.TaskManager(sthis, () => Promise.resolve(), {
+      removeAfter: 3,
+      retryTimeout: 50,
+    });
     this.attachedStores = new bs.AttachedRemotesImpl(this);
   }
 
@@ -136,11 +137,11 @@ class MockLoader implements bs.Loadable {
     throw new Error("Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  loadFileCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<CarReader> {
+  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<CarReader> {
+  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

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", () => {
@@ -26,18 +26,14 @@ describe("HOOK: useFireproof useLiveQuery has results", () => {
     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();
   });
 });