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

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

@@ -1,7 +1,6 @@
 import { bs, ensureSuperThis, PARAM, rt, StoreType, storeType2DataMetaWal } from "@fireproof/core";
 import { BuildURI, LogCollector, runtimeFn, toCryptoRuntime, URI } from "@adviser/cement";
 import { base58btc } from "multiformats/bases/base58";
-import { CID } from "multiformats/cid";
 // import { sha256 as hasher } from "multiformats/hashes/sha2";
 // import * as dagCodec from "@ipld/dag-cbor";
 import * as cborg from "cborg";
@@ -325,155 +324,6 @@ describe("KeyedCryptoStore", () => {
       expect(dec).toEqual(testData);
     }
   });
-
-  it("public: true results in insecure STORE_KEY and noCrypto", async () => {
-    if (!baseUrl) {
-      throw new Error("baseUrl not initialized. Check test setup.");
-    }
-    if (!kb) {
-      throw new Error("kb not initialized. Check test setup.");
-    }
-
-    const testDbName = "testDbPublic";
-    const mockStethis = mockSuperThis();
-    await mockStethis.start();
-
-    // DbMeta only has 'cars' property. A CarGroup is Car[], so an empty array is a valid empty CarGroup.
-    const dbMeta: bs.DbMeta = { cars: [] };
-
-    // Constructing storeUrls with 'insecure' for public: true
-    const metaUri = baseUrl
-      .build()
-      .setParam(PARAM.NAME, `${testDbName}-meta`)
-      .setParam(PARAM.STORE, "meta" as StoreType)
-      .setParam(PARAM.STORE_KEY, "insecure")
-      .URI();
-    const carUri = baseUrl
-      .build()
-      .setParam(PARAM.NAME, `${testDbName}-car`)
-      .setParam(PARAM.STORE, "car" as StoreType)
-      .setParam(PARAM.STORE_KEY, "insecure")
-      .URI();
-    const fileUri = baseUrl
-      .build()
-      .setParam(PARAM.NAME, `${testDbName}-file`)
-      .setParam(PARAM.STORE, "file" as StoreType)
-      .setParam(PARAM.STORE_KEY, "insecure")
-      .URI();
-    const walUri = baseUrl
-      .build()
-      .setParam(PARAM.NAME, `${testDbName}-wal`)
-      .setParam(PARAM.STORE, "wal" as StoreType)
-      .setParam(PARAM.STORE_KEY, "insecure")
-      .URI();
-
-    const insecureStoreUrls: bs.StoreURIs = {
-      meta: metaUri,
-      car: carUri,
-      file: fileUri,
-      wal: walUri,
-    };
-
-    const bsOpts: bs.BlockstoreOpts = {
-      public: true,
-      storeUrls: insecureStoreUrls, // Use the correctly configured insecure URLs
-      keyBag: kb.rt,
-      meta: dbMeta,
-      compact: async () => ({
-        car: CID.parse("bafyreibv2h6gs6lgjpmwj2k2qflgsemg32ufoq2t3r24g7myr5gc5a2vta"),
-        blocks: [],
-        size: 0,
-        meta: CID.parse("bafyreibv2h6gs6lgjpmwj2k2qflgsemg32ufoq2t3r24g7myr5gc5a2vta"),
-      }),
-      autoCompact: 0,
-      crypto: toCryptoRuntime(),
-      threshold: 10,
-      taskManager: { removeAfter: 3, retryTimeout: 50 },
-      storeRuntime: bs.toStoreRuntime(mockStethis, {}),
-      tracer: () => {
-        /* noop */
-      },
-      logger: mockStethis.logger,
-      applyMeta: async () => Promise.resolve(),
-    };
-
-    const encBlockstore = new bs.EncryptedBlockstore(mockStethis, bsOpts);
-
-    expect(encBlockstore.loader.ebOpts.storeUrls.meta.getParam(PARAM.STORE_KEY), "Meta store URL's STORE_KEY in loader opts").toBe(
-      "insecure",
-    );
-    expect(encBlockstore.loader.ebOpts.storeUrls.car.getParam(PARAM.STORE_KEY), "Car store URL's STORE_KEY in loader opts").toBe(
-      "insecure",
-    );
-    expect(encBlockstore.loader.ebOpts.storeUrls.file.getParam(PARAM.STORE_KEY), "File store URL's STORE_KEY in loader opts").toBe(
-      "insecure",
-    );
-    expect(encBlockstore.loader.ebOpts.storeUrls.wal.getParam(PARAM.STORE_KEY), "Wal store URL's STORE_KEY in loader opts").toBe(
-      "insecure",
-    );
-
-    const storeFactoryItem: bs.StoreFactoryItem = {
-      loader: encBlockstore.loader,
-      byStore: {
-        meta: { url: encBlockstore.loader.ebOpts.storeUrls.meta },
-        car: { url: encBlockstore.loader.ebOpts.storeUrls.car },
-        file: { url: encBlockstore.loader.ebOpts.storeUrls.file },
-        wal: { url: encBlockstore.loader.ebOpts.storeUrls.wal },
-      },
-    };
-    const stores = await encBlockstore.loader.ebOpts.storeRuntime.makeStores(storeFactoryItem);
-
-    const resolvedMetaStore = stores.meta;
-    expect(resolvedMetaStore.url().getParam(PARAM.STORE_KEY), "Resolved meta store's STORE_KEY").toBe("insecure");
-    let kc = await resolvedMetaStore.keyedCrypto();
-    expect(kc.constructor.name).toBe("noCrypto");
-
-    const resolvedCarStore = stores.car;
-    expect(resolvedCarStore.url().getParam(PARAM.STORE_KEY), "Resolved car store's STORE_KEY").toBe("insecure");
-    kc = await resolvedCarStore.keyedCrypto();
-    expect(kc.constructor.name).toBe("noCrypto");
-
-    const resolvedFileStore = stores.file;
-    expect(resolvedFileStore).toBeDefined();
-    if (resolvedFileStore) {
-      expect(resolvedFileStore.url().getParam(PARAM.STORE_KEY), "Resolved file store's STORE_KEY").toBe("insecure");
-      kc = await resolvedFileStore.keyedCrypto();
-      expect(kc.constructor.name).toBe("noCrypto");
-    }
-
-    const resolvedWalStore = stores.wal;
-    expect(resolvedWalStore).toBeDefined();
-    if (resolvedWalStore) {
-      expect(resolvedWalStore.url().getParam(PARAM.STORE_KEY), "Resolved wal store's STORE_KEY").toBe("insecure");
-      kc = await resolvedWalStore.keyedCrypto(); // kc is now from WAL store if it exists
-      expect(kc.constructor.name).toBe("noCrypto");
-    }
-
-    // Test noCrypto's _encrypt and _decrypt behavior (currently throws)
-    // Use the latest 'kc' which would be from WAL store if present, or File, or Car, or Meta.
-    // All should be noCrypto instances in this test case.
-    const testData = kb.rt.crypto.randomBytes(1024);
-    const iv = kb.rt.crypto.randomBytes(12);
-    // Test noCrypto's key.get() behavior (currently throws)
-    await expect(kc.key.get()).resolves.toBeUndefined();
-
-    // Test noCrypto's _encrypt behavior (currently throws)
-    // Since key.get() throws, we can't get a real key. _encrypt in noCrypto also throws and doesn't use the key.
-    // The key parameter in _encrypt is optional, so we can pass undefined or a dummy.
-    const dummyCryptoKey: CryptoKey = {
-      algorithm: { name: "NONE" }, // Or simply {} if that's too specific
-      extractable: false,
-      type: "secret",
-      usages: [], // CryptoKeyUsage[]
-    };
-    // For public databases, noCrypto now returns the bytes unchanged instead of throwing
-    const encryptedData = await kc._encrypt({ bytes: testData, key: dummyCryptoKey, iv });
-    expect(encryptedData).toEqual(testData); // Expect the same bytes to be returned
-
-    // Test decrypt also returns the original bytes
-    const decryptedData = await kc._decrypt({ bytes: testData, key: dummyCryptoKey, iv });
-    expect(decryptedData).toEqual(testData);
-  });
 });
 
 describe("KeyedCrypto", () => {

package/tests/blockstore/loader.test.ts

@@ -3,8 +3,9 @@ import { sha256 as hasher } from "multiformats/hashes/sha2";
 import { CID } from "multiformats/cid";
 import { CRDTMeta, CarTransaction, IndexTransactionMeta, SuperThis, bs, ensureSuperThis, rt } from "@fireproof/core";
 import { simpleBlockOpts } from "../helpers.js";
-import { FPBlock, isCarBlockItemReady, isCarBlockItemStale } from "../../src/blockstore/index.js";
-import { anyBlock2FPBlock } from "../../src/blockstore/loader-helpers.js";
+
+const { isCarBlockItemReady, isCarBlockItemStale, anyBlock2FPBlock } = bs;
+type FPBlock = bs.FPBlock;
 
 class MyMemoryBlockStore extends bs.EncryptedBlockstore {
   readonly memblock = new Map<string, FPBlock>();

package/tests/blockstore/standalone.test.ts

@@ -2,7 +2,7 @@ import { BuildURI, runtimeFn, URI } from "@adviser/cement";
 import { ensureSuperThis, PARAM, CRDTImpl, CRDT, LedgerOpts, fireproof, bs, sleep } from "@fireproof/core";
 import { Link } from "multiformats";
 import { stripper } from "@adviser/cement/utils";
-import pLimit from "p-limit";
+import pLimit from "@fireproof/vendor/p-limit";
 
 describe("standalone", () => {
   const sthis = ensureSuperThis();

package/tests/blockstore/transaction.test.ts

@@ -1,10 +1,10 @@
 import { CID } from "multiformats";
 import { BaseBlockstore, bs, CarTransaction, ensureSuperThis } from "@fireproof/core";
 import { simpleBlockOpts } from "../helpers.js";
-import { anyBlock2FPBlock } from "../../src/blockstore/loader-helpers.js";
-import { AnyLink } from "../../src/blockstore/index.js";
 import { to_uint8 } from "@adviser/cement";
 
+const { anyBlock2FPBlock } = bs;
+
 describe("Fresh TransactionBlockstore", function () {
   let blocks: BaseBlockstore;
   const sthis = ensureSuperThis();
@@ -20,7 +20,7 @@ describe("Fresh TransactionBlockstore", function () {
   // });
   it("should not put", async () => {
     const value = sthis.txt.encode("value");
-    const e = await blocks.put(await anyBlock2FPBlock({ cid: "key" as unknown as AnyLink, bytes: value })).catch((e) => e);
+    const e = await blocks.put(await anyBlock2FPBlock({ cid: "key" as unknown as bs.AnyLink, bytes: value })).catch((e) => e);
     expect(e.message).toMatch(/transaction/g);
   });
   it("should yield a transaction", async () => {

package/tests/fireproof/attachable.test.ts

@@ -530,7 +530,7 @@ describe("sync", () => {
     );
 
     // await waitIdle.wait(dbs);
-    await sleep(500);
+    await sleep(1000);
     await Promise.all(
       dbs.map(async (tdb) => {
         const rows = await tdb.db.allDocs();

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 { CarBlockItem, CarGroup, FPBlock } from "../src/blockstore/index.js";
-import { CommitQueue } from "../src/blockstore/commit-queue.js";
 
 /* eslint-disable @typescript-eslint/no-empty-function */
 export function tracer() {}
@@ -97,7 +95,7 @@ class MockLoader implements bs.Loadable {
   readonly carLog: bs.CarLog;
   readonly attachedStores: bs.AttachedStores;
   readonly taskManager: bs.TaskManager;
-  readonly commitQueue: CommitQueue<unknown>;
+  readonly commitQueue: bs.CommitQueue<unknown>;
 
   constructor(sthis: SuperThis) {
     this.sthis = sthis;
@@ -118,7 +116,7 @@ class MockLoader implements bs.Loadable {
       retryTimeout: 50,
     });
     this.attachedStores = new bs.AttachedRemotesImpl(this);
-    this.commitQueue = new CommitQueue({
+    this.commitQueue = new bs.CommitQueue({
       tracer,
     });
   }
@@ -137,7 +135,7 @@ class MockLoader implements bs.Loadable {
     return rt.kb.getKeyBag(this.sthis, {});
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  handleDbMetasFromStore(metas: bs.DbMeta[], store: bs.ActiveStore): Promise<CarGroup> {
+  handleDbMetasFromStore(metas: bs.DbMeta[], store: bs.ActiveStore): Promise<bs.CarGroup> {
     // throw new Error("Method not implemented.");
     return Promise.resolve([]);
   }
@@ -149,15 +147,15 @@ class MockLoader implements bs.Loadable {
     throw new Error("Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  getBlock(cid: bs.AnyLink, store: bs.ActiveStore): Promise<FPBlock | Falsy> {
+  getBlock(cid: bs.AnyLink, store: bs.ActiveStore): Promise<bs.FPBlock | Falsy> {
     throw new Error("Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  loadFileCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<FPBlock<CarBlockItem>> {
+  loadFileCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<bs.FPBlock<bs.CarBlockItem>> {
     throw new Error("Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  loadCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<FPBlock<CarBlockItem>> {
+  loadCar(cid: bs.AnyLink, store: bs.ActiveStore): Promise<bs.FPBlock<bs.CarBlockItem>> {
     throw new Error("Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -165,7 +163,7 @@ class MockLoader implements bs.Loadable {
     throw new Error("Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  entries(cache?: boolean): AsyncIterableIterator<FPBlock> {
+  entries(cache?: boolean): AsyncIterableIterator<bs.FPBlock> {
     throw new Error("Method not implemented.");
   }
 }