@fireproof/core 0.20.0-dev-preview-41 → 0.20.0-dev-preview-51

package/tests/fireproof/crdt.test.ts

@@ -240,11 +240,16 @@ describe("Compact a named CRDT with writes", function () {
   });
   beforeEach(async () => {
     await sthis.start();
+    // sthis.env.set(
+    //   "FP_STORAGE_URL",
+    //   BuildURI.from(sthis.env.get("FP_STORAGE_URL")).setParam(PARAM.STORE_KEY, "insecure").toString(),
+    // );
+    // console.log("FP_STORAGE_URL", sthis.env.get("FP_STORAGE_URL"));
     const dbOpts: LedgerOpts = {
       name: "test-crdt",
       writeQueue: defaultWriteQueueOpts({}),
       keyBag: rt.defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, `named-crdt-compaction`),
+      storeUrls: toStoreURIRuntime(sthis, `named-crdt-compaction-${sthis.nextId().str}`),
       storeEnDe: bs.ensureStoreEnDeFile({}),
     };
     crdt = new CRDTImpl(sthis, dbOpts);
@@ -255,6 +260,7 @@ describe("Compact a named CRDT with writes", function () {
       ];
       await crdt.bulk(bulk);
     }
+    // await sleep(1000);
   });
   it("has data", async () => {
     const got = (await crdt.get("ace")) as DocValue<CRDTTestType>;
@@ -266,8 +272,41 @@ describe("Compact a named CRDT with writes", function () {
     for await (const blk of crdt.blockstore.entries()) {
       blz.push(blk);
     }
-    expect(blz.length).toBe(13);
-  });
+    //    expect(blz.map((i) => sthis.txt.decode(i.bytes) + "\n=================\n")).toEqual([
+    //
+    //    ])
+    expect(blz.map((i) => i.cid.toString())).toEqual([
+      "bafyreicuomyooryb747esregkhooc4phr656tocowyo6dwcocq22h7qdhu",
+      "bafyreig5jhovaiocwk3vfafzdspgtwinftjygyghjzigkc554muhdmp5ba",
+      "bafyreiegj7yumreue7llzqroebigscedyzrkeir3zneg5q7zia77itowy4",
+      "bafyreihobual6tt3hgdfve4h5uzt7fey62se3dfecbuj6f4ndkkwquke4u",
+      "bafyreibqqcs3r6mhpr3525na6jtqnjcf6dmgskk27x4a2jb3r2qveqgexm",
+      "bafyreibr7udlekt4xgavn54i4zfsdlrmi4r76iq6gh3bdq4xh52px6to3e",
+      "bafyreidg2eyas62nvwvi6ggq44tsldj4kwmupyk2xtwmxbwf77g3noqtp4",
+      "bafyreigbzxzj4eh7ljfvzlc7smdextuuk7gvep5mpnb3igaj5r2qzjlfye",
+      "bafyreicr7takuntpofvk52xerdcoiq7wdt73ef54acoya2geig2ywkqlsi",
+      "bafyreihmmgm5sufvnsgjic4fbizkdbajpy2yrklyieadstbtegfr4qko2m",
+      "bafyreibnu44uyu3ggqwgmnlxodw6dyta3qg7e5qldsjq7bkbv452ova6oa",
+      "bafyreieh4nlzg7enfczmj4z7uxvgrnykh7ajw7crxjrncqfrzj47ip6t6m",
+      "bafyreigqqrccymfvvdfetjd2twsdzjwxbb6cn6tedqntvpgp5vboky2ol4",
+      "bafyreid6kkobhgdmce2cyroepyos3jwumtdrfuzi6suldlxzjsgagc3fvi",
+      "bafyreibo2d56wo5ldey24hygtmsfhdxsqgdpmtne5oitehxjppipru33ma",
+      "bafyreifjv6havcza3is7w6ii345f5akba7e34xqcxwoqozmsnihkivykum",
+      "bafyreig6eroqeg3y7am4bnrun3yzbvd656epzxjyivdpzwqo3j3vpuwysi",
+      "bafyreibpsnfsducp7refempcyqnte54j7ueh4ysdlabggihclbddfnuzxm",
+      "bafyreicfkkygbzz5zawr3xbfah2gy3e7w4opzysew4tini7xnksujj4gf4",
+      "bafyreiddjm5xkpfa5vmyhoj5opocrwo6zbdnmqyhouc5ttfxoilmaf25bm",
+      "bafyreibp7vlgfexaknaoxpemnnwadyfa4cfuc3euzlkslskks2n44wwspu",
+      "bafyreichwj7izzpxeyjkhwl26pq45m4hnhxcgzqfk5ffeqkscafleiwfzm",
+      "bafyreidzjjqou36q2ghqdue4buq7536w4sl5aejni6tw25mzsusl26gtwu",
+      "bafyreibxibqhi6wh5klrje7ne4htffeqyyqfd6y7x2no6wnhid4nixizau",
+      "bafyreidnvv4mwvweup5w52ddre2sl4syhvczm6ejqsmuekajowdl2cf2q4",
+      "bafyreihh6nbfbhgkf5lz7hhsscjgiquw426rxzr3fprbgonekzmyvirrhe",
+      "bafyreiejg3twlaxr7gfvvhtxrhvwaydytdv4guidmtvaz5dskm6gp73ryi",
+      "bafyreiblui55o25dopc5faol3umsnuohb5carto7tot4kicnkfc37he4h4",
+    ]);
+    // expect(blz.length).toBe(13);
+  }, 1000000);
   it("should start with changes", async () => {
     const { result } = await crdt.changes();
     expect(result.length).toBe(2);
@@ -332,7 +371,7 @@ describe("CRDT with an index", function () {
     expect(got.rows[0].id).toBe("king");
     expect(got.rows[0].key).toBe(10);
   });
-  it("creating a different index with same name should not work", async () => {
+  it.skip("creating a different index with same name should not work", async () => {
     const e = await index(crdt, "points", (doc) => doc._id)
       .query()
       .catch((err) => err);
@@ -377,16 +416,16 @@ describe("Loader with a committed transaction", function () {
   it("should commit a transaction", function () {
     expect(done.head).toBeTruthy();
     // expect(done.cars).toBeTruthy();
-    expect(loader.carLog.length).toBe(1);
+    expect(loader.carLog.length).toBe(1 + 1 /* genesis */);
   });
   it("can load the car", async () => {
-    const blk = loader.carLog[0][0];
+    const blk = loader.carLog.asArray()[0][0];
     expect(blk).toBeTruthy();
     const reader = await loader.loadCar(blk, loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(0);
+    expect(parsed.cars.length).toBe(0 + 1 /* genesis */);
     expect(parsed.meta).toBeTruthy();
     expect(parsed.meta.head).toBeTruthy();
   });
@@ -427,20 +466,20 @@ describe("Loader with two committed transactions", function () {
     expect(done1.head).not.toBe(done2.head);
     // expect(done1.cars).not.toBe(done2.cars);
     // expect(blockstore.transactions.size).toBe(2);
-    expect(loader.carLog.length).toBe(2);
+    expect(loader.carLog.length).toBe(2 + 1 /* genesis */);
     // expect(loader.carLog.indexOf(done1.cars)).toBe(1);
     // expect(loader.carLog.map((cs) => cs.toString()).indexOf(done1.cars.toString())).toBe(1);
     // expect(loader.carLog.indexOf(done2.cars)).toBe(0);
     // expect(loader.carLog.map((cs) => cs.toString()).indexOf(done2.cars.toString())).toBe(0);
   });
   it("can load the car", async () => {
-    const blk = loader.carLog[0][0];
+    const blk = loader.carLog.asArray()[0][0];
     expect(blk).toBeTruthy();
     const reader = await loader.loadCar(blk, loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(1);
+    expect(parsed.cars.length).toBe(1 + 1 /* genesis */);
     expect(parsed.meta).toBeTruthy();
     expect(parsed.meta.head).toBeTruthy();
   });
@@ -482,16 +521,16 @@ describe("Loader with many committed transactions", function () {
       // expect(done.cars).toBeTruthy();
     }
     expect(blockstore.transactions.size).toBe(0); // cleaned up on commit
-    expect(loader.carLog.length).toBe(count);
+    expect(loader.carLog.length).toBe(count + 1 /* genesis */);
   });
   it("can load the car", async () => {
-    const blk = loader.carLog[2][0];
+    const blk = loader.carLog.asArray()[2][0];
     // expect(dones[5].cars).toBeTruthy();
     const reader = await loader.loadCar(blk, loader.attachedStores.local());
     expect(reader).toBeTruthy();
     const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
     expect(parsed.cars).toBeTruthy();
-    expect(parsed.cars.length).toBe(7);
+    expect(parsed.cars.length).toBe(7 + 1 /* genesis */);
     expect(parsed.meta).toBeTruthy();
     expect(parsed.meta.head).toBeTruthy();
   });

package/tests/fireproof/database.test.ts

@@ -136,6 +136,60 @@ describe("named Ledger with record", function () {
     expect(doc._id).toBe("hello");
     expect(doc.value).toBe("universe");
   });
+  it("should update with Date value", async function () {
+    const date = new Date();
+    const dateStr = date.toISOString();
+    const ok = await db.put({ _id: "hello", value: date });
+    expect(ok.id).toBe("hello");
+    const doc = await db.get<Doc>("hello");
+    expect(doc).toBeTruthy();
+    expect(doc._id).toBe("hello");
+    expect(doc.value).toBe(dateStr);
+    expect(typeof doc.value).toBe("string");
+    const parsed = new Date(doc.value);
+    expect(parsed).toStrictEqual(date);
+  });
+  it("should update with null value", async function () {
+    const ok = await db.put({ _id: "hello", value: null });
+    expect(ok.id).toBe("hello");
+    const doc = await db.get<Doc>("hello");
+    expect(doc).toBeTruthy();
+    expect(doc._id).toBe("hello");
+    expect(doc.value).toBeNull();
+    expect(Object.keys(doc).includes("value")).toBeTruthy();
+  });
+  it("should update with undefined value", async function () {
+    const ok = await db.put({ _id: "hello", value: undefined });
+    expect(ok.id).toBe("hello");
+    const doc = await db.get<Doc>("hello");
+    expect(doc).toBeTruthy();
+    expect(doc._id).toBe("hello");
+
+    // expect 'value' not to be in keys
+    expect(Object.keys(doc).includes("value")).toBeFalsy();
+  });
+  it("should update with NaN value", async function () {
+    const ok = await db.put({ _id: "hello", value: NaN });
+    expect(ok.id).toBe("hello");
+    const doc = await db.get<Doc>("hello");
+    expect(doc).toBeTruthy();
+    expect(doc._id).toBe("hello");
+
+    // expect 'value' not to be in keys
+    expect(Object.keys(doc).includes("value")).toBeFalsy();
+  });
+  it("should not update with Infinity value", async function () {
+    const ok = await db.put({ _id: "hello", value: Infinity }).catch((e) => e);
+    expect(ok.message).toMatch(/IPLD/);
+  });
+  it("should not update with undefined array value", async function () {
+    const ok = await db.put({ _id: "hello", value: [undefined] }).catch((e) => e);
+    expect(ok.message).toMatch(/IPLD/);
+  });
+  it("should not update with NaN array value", async function () {
+    const ok = await db.put({ _id: "hello", value: [NaN] }).catch((e) => e);
+    expect(ok.message).toMatch(/IPLD/);
+  });
   it("should del last record", async () => {
     const ok = await db.del("hello");
     expect(ok.id).toBe("hello");
@@ -409,7 +463,7 @@ describe("basic Ledger with no update subscription", function () {
       didRun++;
     });
   });
-  it("should run on put", async () => {
+  it("xshould run on put", async function () {
     const all = await db.allDocs();
     expect(all.rows.length).toBe(0);
     /** @type {Doc} */
@@ -418,7 +472,7 @@ describe("basic Ledger with no update subscription", function () {
     const ok = await db.put(doc);
     expect(ok.id).toBe("hello");
     expect(didRun).toBe(1);
-  });
+  }, 10000);
   it("should unsubscribe", async () => {
     unsubscribe();
     const doc = { _id: "hello", message: "again" };
@@ -521,7 +575,7 @@ describe("ledger with files input", () => {
 
     expect(file.type).toBe(imagefiles[0].file.type);
     expect(file.size).toBe(imagefiles[0].file.size);
-  });
+  }, 1000000);
 });
 
 describe("StoreURIRuntime", () => {
@@ -551,14 +605,14 @@ describe("StoreURIRuntime", () => {
   it("default toStoreURIRuntime", () => {
     expect(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, "test")))).toEqual({
       data: {
-        car: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&suffix=.car&urlGen=fromEnv",
-        file: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&urlGen=fromEnv",
+        car: "my://bla/storage?name=test&store=car&storekey=%40test-data%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?name=test&store=file&storekey=%40test-data%40&urlGen=fromEnv",
         meta: "my://bla/storage?name=test&store=meta&storekey=%40test-meta%40&urlGen=fromEnv",
         wal: "my://bla/storage?name=test&store=wal&storekey=%40test-wal%40&urlGen=fromEnv",
       },
       idx: {
-        car: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&suffix=.car&urlGen=fromEnv",
-        file: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&urlGen=fromEnv",
+        car: "my://bla/storage?index=idx&name=test&store=car&storekey=%40test-data-idx%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?index=idx&name=test&store=file&storekey=%40test-data-idx%40&urlGen=fromEnv",
         meta: "my://bla/storage?index=idx&name=test&store=meta&storekey=%40test-meta-idx%40&urlGen=fromEnv",
         wal: "my://bla/storage?index=idx&name=test&store=wal&storekey=%40test-wal-idx%40&urlGen=fromEnv",
       },
@@ -568,14 +622,14 @@ describe("StoreURIRuntime", () => {
   it("no name toStoreURIRuntime(not more)", () => {
     expect(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, "gogo")))).toEqual({
       data: {
-        car: "my://bla/storage?name=gogo&store=data&storekey=%40gogo-data%40&suffix=.car&urlGen=fromEnv",
-        file: "my://bla/storage?name=gogo&store=data&storekey=%40gogo-data%40&urlGen=fromEnv",
+        car: "my://bla/storage?name=gogo&store=car&storekey=%40gogo-data%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?name=gogo&store=file&storekey=%40gogo-data%40&urlGen=fromEnv",
         meta: "my://bla/storage?name=gogo&store=meta&storekey=%40gogo-meta%40&urlGen=fromEnv",
         wal: "my://bla/storage?name=gogo&store=wal&storekey=%40gogo-wal%40&urlGen=fromEnv",
       },
       idx: {
-        car: "my://bla/storage?index=idx&name=gogo&store=data&storekey=%40gogo-data-idx%40&suffix=.car&urlGen=fromEnv",
-        file: "my://bla/storage?index=idx&name=gogo&store=data&storekey=%40gogo-data-idx%40&urlGen=fromEnv",
+        car: "my://bla/storage?index=idx&name=gogo&store=car&storekey=%40gogo-data-idx%40&suffix=.car&urlGen=fromEnv",
+        file: "my://bla/storage?index=idx&name=gogo&store=file&storekey=%40gogo-data-idx%40&urlGen=fromEnv",
         meta: "my://bla/storage?index=idx&name=gogo&store=meta&storekey=%40gogo-meta-idx%40&urlGen=fromEnv",
         wal: "my://bla/storage?index=idx&name=gogo&store=wal&storekey=%40gogo-wal-idx%40&urlGen=fromEnv",
       },
@@ -589,11 +643,11 @@ describe("StoreURIRuntime", () => {
           toStoreURIRuntime(sthis, "xxx", {
             base: "my://storage-base",
             data: {
-              data: "my://storage-data?name=yyy",
+              car: "my://storage-data?name=yyy",
               meta: "my://storage-meta",
             },
             idx: {
-              data: "my://storage-idx-data?name=yyy&index=bla",
+              car: "my://storage-idx-data?name=yyy&index=bla",
               meta: "my://storage-idx-meta",
             },
           }),
@@ -601,14 +655,14 @@ describe("StoreURIRuntime", () => {
       ),
     ).toEqual({
       data: {
-        car: "my://storage-data?name=yyy&store=data&storekey=%40yyy-data%40&suffix=.car",
-        file: "my://storage-data?name=yyy&store=data&storekey=%40yyy-data%40",
+        car: "my://storage-data?name=yyy&store=car&storekey=%40yyy-data%40&suffix=.car",
+        file: "my://storage-data?name=yyy&store=file&storekey=%40yyy-data%40",
         meta: "my://storage-meta?name=xxx&store=meta&storekey=%40xxx-meta%40",
         wal: "my://storage-base?name=xxx&store=wal&storekey=%40xxx-wal%40",
       },
       idx: {
-        car: "my://storage-idx-data?index=bla&name=yyy&store=data&storekey=%40yyy-data-idx%40&suffix=.car",
-        file: "my://storage-idx-data?index=bla&name=yyy&store=data&storekey=%40yyy-data-idx%40",
+        car: "my://storage-idx-data?index=bla&name=yyy&store=car&storekey=%40yyy-data-idx%40&suffix=.car",
+        file: "my://storage-idx-data?index=bla&name=yyy&store=file&storekey=%40yyy-data-idx%40",
         meta: "my://storage-idx-meta?index=idx&name=xxx&store=meta&storekey=%40xxx-meta-idx%40",
         wal: "my://storage-base?index=idx&name=xxx&store=wal&storekey=%40xxx-wal-idx%40",
       },
@@ -619,14 +673,14 @@ describe("StoreURIRuntime", () => {
     sthis.env.delete("FP_STORAGE_URL");
     expect(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, "maxi")))).toEqual({
       data: {
-        car: "murks://fp?name=maxi&store=data&storekey=%40maxi-data%40&suffix=.car&urlGen=default",
-        file: "murks://fp?name=maxi&store=data&storekey=%40maxi-data%40&urlGen=default",
+        car: "murks://fp?name=maxi&store=car&storekey=%40maxi-data%40&suffix=.car&urlGen=default",
+        file: "murks://fp?name=maxi&store=file&storekey=%40maxi-data%40&urlGen=default",
         meta: "murks://fp?name=maxi&store=meta&storekey=%40maxi-meta%40&urlGen=default",
         wal: "murks://fp?name=maxi&store=wal&storekey=%40maxi-wal%40&urlGen=default",
       },
       idx: {
-        car: "murks://fp?index=idx&name=maxi&store=data&storekey=%40maxi-data-idx%40&suffix=.car&urlGen=default",
-        file: "murks://fp?index=idx&name=maxi&store=data&storekey=%40maxi-data-idx%40&urlGen=default",
+        car: "murks://fp?index=idx&name=maxi&store=car&storekey=%40maxi-data-idx%40&suffix=.car&urlGen=default",
+        file: "murks://fp?index=idx&name=maxi&store=file&storekey=%40maxi-data-idx%40&urlGen=default",
         meta: "murks://fp?index=idx&name=maxi&store=meta&storekey=%40maxi-meta-idx%40&urlGen=default",
         wal: "murks://fp?index=idx&name=maxi&store=wal&storekey=%40maxi-wal-idx%40&urlGen=default",
       },
@@ -642,16 +696,16 @@ describe("StoreURIRuntime", () => {
         stores: [
           {
             data: {
-              car: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&suffix=.car&urlGen=fromEnv",
-              file: "my://bla/storage?name=test&store=data&storekey=%40test-data%40&urlGen=fromEnv",
+              car: "my://bla/storage?name=test&store=car&storekey=%40test-data%40&suffix=.car&urlGen=fromEnv",
+              file: "my://bla/storage?name=test&store=file&storekey=%40test-data%40&urlGen=fromEnv",
               meta: "my://bla/storage?name=test&store=meta&storekey=%40test-meta%40&urlGen=fromEnv",
               wal: "my://bla/storage?name=test&store=wal&storekey=%40test-wal%40&urlGen=fromEnv",
             },
           },
           {
             idx: {
-              car: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&suffix=.car&urlGen=fromEnv",
-              file: "my://bla/storage?index=idx&name=test&store=data&storekey=%40test-data-idx%40&urlGen=fromEnv",
+              car: "my://bla/storage?index=idx&name=test&store=car&storekey=%40test-data-idx%40&suffix=.car&urlGen=fromEnv",
+              file: "my://bla/storage?index=idx&name=test&store=file&storekey=%40test-data-idx%40&urlGen=fromEnv",
               meta: "my://bla/storage?index=idx&name=test&store=meta&storekey=%40test-meta-idx%40&urlGen=fromEnv",
               wal: "my://bla/storage?index=idx&name=test&store=wal&storekey=%40test-wal-idx%40&urlGen=fromEnv",
             },

package/tests/fireproof/fireproof.test.ts

@@ -121,23 +121,26 @@ describe("database fullconfig", () => {
   it("have the right name", async () => {
     let protocol: string | undefined;
     const url = sthis.env.get("FP_STORAGE_URL");
+    let path = "";
     if (url) {
-      protocol = URI.from(url).protocol;
+      const uri = URI.from(url);
+      protocol = uri.protocol;
+      path = uri.pathname;
     }
-    const base = bs.getDefaultURI(sthis, protocol);
+    const base = bs.getDefaultURI(sthis, protocol).build().appendRelative(path).URI();
     const db = fireproof("my-funky-name", {
       storeUrls: {
         base: base,
         // meta: `${base}/meta?taste=${taste}`,
         data: {
-          meta: base.build().pathname("dist/full/meta"),
-          data: base.build().pathname("dist/full/data"),
-          wal: base.build().pathname("dist/full/wal"),
+          meta: base.build().appendRelative("funky/meta"),
+          car: base.build().appendRelative("funky/data"),
+          wal: base.build().appendRelative("funky/wal"),
         },
         idx: {
-          meta: base.build().pathname("dist/full/idx-meta"),
-          data: base.build().pathname("dist/full/idx-data"),
-          wal: base.build().pathname("dist/full/idx-wal"),
+          meta: base.build().appendRelative("funky/idx-meta"),
+          car: base.build().appendRelative("funky/idx-data"),
+          wal: base.build().appendRelative("funky/idx-wal"),
         },
         // wal: `${base}/wal?taste=${taste}`,
       },
@@ -487,7 +490,7 @@ describe("Reopening a ledger", function () {
     const loader = blocks.loader;
     expect(loader).toBeDefined();
     expect(loader.carLog).toBeDefined();
-    expect(loader.carLog.length).toBe(1);
+    expect(loader.carLog.length).toBe(1 + 1 /* genesis */);
   });
 
   it("should have carlog after reopen", async () => {
@@ -497,7 +500,7 @@ describe("Reopening a ledger", function () {
     const loader = blocks.loader;
     expect(loader).toBeDefined();
     expect(loader.carLog).toBeDefined();
-    expect(loader.carLog.length).toBe(1);
+    expect(loader.carLog.length).toBe(1 + 1 /* genesis */);
     await db2.close();
   });
 
@@ -509,10 +512,10 @@ describe("Reopening a ledger", function () {
       await db.ready();
       const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
       const loader = blocks.loader;
-      expect(loader.carLog.length).toBe(i + 1);
+      expect(loader.carLog.length).toBe(i + 1 + 1 /* genesis */);
       const ok = await db.put({ _id: `test${i}`, fire: "proof".repeat(50 * 1024) });
       expect(ok).toBeTruthy();
-      expect(loader.carLog.length).toBe(i + 2);
+      expect(loader.carLog.length).toBe(i + 2 + 1 /* genesis */);
       const doc = await db.get<FireType>(`test${i}`);
       expect(doc.fire).toBe("proof".repeat(50 * 1024));
       await db.close();
@@ -663,7 +666,7 @@ describe("basic js verify", function () {
     const blocks = db.ledger.crdt.blockstore as bs.EncryptedBlockstore;
     const loader = blocks.loader;
     expect(loader).toBeTruthy();
-    const cid = loader.carLog[0][0];
+    const cid = loader.carLog.asArray()[0][0];
     const cid2 = db.ledger.crdt.clock.head[0];
     expect(cid).not.toBe(cid2);
     expect(cid).not.toBe(cid2);
@@ -709,6 +712,7 @@ describe("same workload twice, same CID", function () {
     await sthis.start();
     // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
     dbA = fireproof("test-dual-workload-a", configA);
+    await dbA.destroy();
     for (const doc of docs) {
       ok = await dbA.put(doc);
       expect(ok).toBeTruthy();
@@ -718,6 +722,7 @@ describe("same workload twice, same CID", function () {
 
     // todo this fails because the test setup doesn't properly configure both ledgers to use the same key
     dbB = fireproof("test-dual-workload-b", configB);
+    await dbA.destroy();
     for (const doc of docs) {
       ok = await dbB.put(doc);
       expect(ok).toBeTruthy();
@@ -735,15 +740,15 @@ describe("same workload twice, same CID", function () {
     const logA = dbA.ledger.crdt.blockstore.loader?.carLog;
     expect(logA).toBeTruthy();
     assert(logA);
-    expect(logA.length).toBe(docs.length);
+    expect(logA.length).toBe(docs.length + 1 /*genesis*/);
 
     const logB = dbB.ledger.crdt.blockstore.loader?.carLog;
     expect(logB).toBeTruthy();
     assert(logB);
-    expect(logB.length).toBe(docs.length);
+    expect(logB.length).toBe(docs.length + 1 /*genesis*/);
 
-    const logA2 = logA.map((c) => c.toString());
-    const logB2 = logB.map((c) => c.toString());
+    const logA2 = logA.asArray().map((c) => c.toString());
+    const logB2 = logB.asArray().map((c) => c.toString());
 
     expect(logA2.length).toBe(logB2.length);
 
@@ -764,8 +769,8 @@ describe("same workload twice, same CID", function () {
     assert(cmpLogB);
     expect(cmpLogB.length).toBe(1);
 
-    const cmpLogA2 = cmpLogA.map((c) => c.toString());
-    const cmpLogB2 = cmpLogB.map((c) => c.toString());
+    const cmpLogA2 = cmpLogA.asArray().map((c) => c.toString());
+    const cmpLogB2 = cmpLogB.asArray().map((c) => c.toString());
 
     expect(cmpLogA2.length).toBe(cmpLogB2.length);
 

package/tests/fireproof/stable-cid.test.ts

@@ -0,0 +1,69 @@
+import { sha256 } from "multiformats/hashes/sha2";
+import { ensureSuperThis, rt, bs } from "@fireproof/core";
+import { base58btc } from "multiformats/bases/base58";
+import { URI, toCryptoRuntime } from "@adviser/cement";
+import * as cborg from "cborg";
+
+const sthis = ensureSuperThis();
+describe.each([
+  async () => {
+    const kb = await rt.kb.getKeyBag(sthis, {});
+    const keyStr = base58btc.encode(toCryptoRuntime().randomBytes(kb.rt.keyLength));
+    return await rt.kc.keyedCryptoFactory(URI.from(`test://bla?storekey=${keyStr}`), kb, sthis);
+  },
+  async () => {
+    const kb = await rt.kb.getKeyBag(sthis, {});
+    return await rt.kc.keyedCryptoFactory(URI.from(`test://bla?storekey=insecure`), kb, sthis);
+  },
+])("regression of stable cid encoding", (factory) => {
+  let kycr: bs.CryptoAction;
+  beforeEach(async () => {
+    // let url: URI;
+    // if (runtimeFn().isBrowser) {
+    //   url = URI.from("indexeddb://fp-keybag");
+    // } else {
+    //   url = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
+    // }
+    kycr = await factory();
+  });
+
+  it("should encode and decode a stable cid", async () => {
+    const x1 = await rt.mf.block.encode({
+      value: cborg.encode({ hello: "world" }),
+      // hashBytes: {
+      //   as: (x: Uint8Array<ArrayBufferLike>): Promise<ByteView<Uint8Array>> => Promise.resolve(x),
+      // },
+      hasher: sha256,
+      codec: kycr.codec(toCryptoRuntime().randomBytes(12)),
+    });
+    const x2 = await rt.mf.block.encode({
+      value: cborg.encode({ hello: "world" }),
+      // hashBytes: {
+      //   as: (x: Uint8Array<ArrayBufferLike>): Promise<ByteView<Uint8Array>> => Promise.resolve(x),
+      // },
+      hasher: sha256,
+      codec: kycr.codec(toCryptoRuntime().randomBytes(12)),
+    });
+    expect(x1.cid).toEqual(x2.cid);
+  });
+  it("decode stable cid", async () => {
+    const x1 = await rt.mf.block.encode({
+      value: cborg.encode({ hello: "world" }),
+      // hashBytes: {
+      //   as: (x: Uint8Array<ArrayBufferLike>): Promise<ByteView<Uint8Array>> => Promise.resolve(x),
+      // },
+      hasher: sha256,
+      codec: kycr.codec(),
+    });
+    const x = await rt.mf.block.decode<bs.IvKeyIdData, 24, 18>({
+      bytes: x1.bytes,
+      // hashBytes: {
+      //   get: (x: bs.IvKeyIdData): Promise<ByteView<Uint8Array>> => Promise.resolve(x.data as ByteView<Uint8Array<ArrayBufferLike>>),
+      // },
+      codec: kycr.codec(),
+      hasher: sha256,
+    });
+    expect(x.cid.toString()).toEqual(x1.cid.toString());
+    expect(cborg.decode(x.value.data)).toEqual({ hello: "world" });
+  }, 1000000);
+});

package/tests/fireproof/utils.test.ts

@@ -17,22 +17,30 @@ describe("utils", () => {
 
   const storeOpts = [
     {
-      type: "data",
+      type: "car",
+      pathPart: "data",
       suffix: ".car",
     },
+    {
+      type: "file",
+      pathPart: "data",
+      suffix: "",
+    },
     {
       type: "wal",
+      pathPart: "wal",
       suffix: ".json",
     },
     {
       type: "meta",
+      pathPart: "meta",
       suffix: ".json",
     },
   ];
   it("getfilename plain", () => {
     for (const store of storeOpts) {
       const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version&suffix=${store.suffix}`);
-      expect(rt.getFileName(url, logger)).toEqual(`${store.type}/key${store.suffix}`);
+      expect(rt.getFileName(url, logger)).toEqual(`${store.pathPart}/key${store.suffix}`);
     }
   });
 
@@ -41,7 +49,7 @@ describe("utils", () => {
       const url = URI.from(
         `file://./x/path?index=idx&store=${store.type}&name=name&key=key&version=version&suffix=${store.suffix}`,
       );
-      expect(rt.getFileName(url, logger)).toEqual(`idx-${store.type}/key${store.suffix}`);
+      expect(rt.getFileName(url, logger)).toEqual(`idx-${store.pathPart}/key${store.suffix}`);
     }
   });
 
@@ -49,8 +57,9 @@ describe("utils", () => {
     for (const store of storeOpts) {
       const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version`);
       expect(getStore(url, logger, (...toJoin) => toJoin.join("+"))).toEqual({
-        name: store.type,
-        store: store.type,
+        fromUrl: store.type,
+        name: store.pathPart,
+        pathPart: store.pathPart,
       });
     }
   });
@@ -59,8 +68,9 @@ describe("utils", () => {
     for (const store of storeOpts) {
       const url = URI.from(`file://./x/path?index=ix&store=${store.type}&name=name&key=key&version=version`);
       expect(getStore(url, logger, (...toJoin) => toJoin.join("+"))).toEqual({
-        name: `ix+${store.type}`,
-        store: store.type,
+        fromUrl: store.type,
+        pathPart: store.pathPart,
+        name: `ix+${store.pathPart}`,
       });
     }
   });