@fireproof/core 0.19.0-dev-publish → 0.19.0-dev-use-fix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.19.0-dev-publish",
+  "version": "0.19.0-dev-use-fix",
   "description": "Live database for the web.",
   "type": "module",
   "module": "./index.js",

package/{sqlite-data-store-RIH56645.js → sqlite-data-store-3ST7XOLX.js}

@@ -1,11 +1,11 @@
 import {
   ensureSQLiteVersion
-} from "./chunk-5X6APJDY.js";
+} from "./chunk-ZHO4NMWL.js";
 import {
   ensureLogger,
   exception2Result,
   getStore
-} from "./chunk-UCMXU3DH.js";
+} from "./chunk-NZNG6TQT.js";
 import "./chunk-H3A2HMMM.js";
 
 // src/runtime/store-sql/v0.19-sqlite/sqlite-data-store.ts
@@ -117,4 +117,4 @@ export {
   DataSQLRecordBuilder,
   V0_18_0SQLiteDataStore
 };
-//# sourceMappingURL=sqlite-data-store-RIH56645.js.map
+//# sourceMappingURL=sqlite-data-store-3ST7XOLX.js.map

package/{sqlite-meta-store-6347MWOR.js → sqlite-meta-store-QOIMCSJ7.js}

@@ -1,11 +1,11 @@
 import {
   ensureSQLiteVersion
-} from "./chunk-5X6APJDY.js";
+} from "./chunk-ZHO4NMWL.js";
 import {
   ensureLogger,
   exception2Result,
   getStore
-} from "./chunk-UCMXU3DH.js";
+} from "./chunk-NZNG6TQT.js";
 import "./chunk-H3A2HMMM.js";
 
 // src/runtime/store-sql/v0.19-sqlite/sqlite-meta-store.ts
@@ -134,4 +134,4 @@ export {
   MetaSQLRecordBuilder,
   V0_18_0SQLiteMetaStore
 };
-//# sourceMappingURL=sqlite-meta-store-6347MWOR.js.map
+//# sourceMappingURL=sqlite-meta-store-QOIMCSJ7.js.map

package/{sqlite-wal-store-G5YGK77N.js → sqlite-wal-store-JFBQPOYT.js}

@@ -1,11 +1,11 @@
 import {
   ensureSQLiteVersion
-} from "./chunk-5X6APJDY.js";
+} from "./chunk-ZHO4NMWL.js";
 import {
   ensureLogger,
   exception2Result,
   getStore
-} from "./chunk-UCMXU3DH.js";
+} from "./chunk-NZNG6TQT.js";
 import "./chunk-H3A2HMMM.js";
 
 // src/runtime/store-sql/v0.19-sqlite/sqlite-wal-store.ts
@@ -120,4 +120,4 @@ export {
   V0_18_0SQLiteWalStore,
   WalSQLRecordBuilder
 };
-//# sourceMappingURL=sqlite-wal-store-G5YGK77N.js.map
+//# sourceMappingURL=sqlite-wal-store-JFBQPOYT.js.map

package/{store-file-D472VFCS.js → store-file-CSS5THFH.js}

@@ -11,7 +11,7 @@ import {
   getFileName,
   getPath,
   getStore
-} from "./chunk-UCMXU3DH.js";
+} from "./chunk-NZNG6TQT.js";
 import {
   SysContainer
 } from "./chunk-H3A2HMMM.js";
@@ -190,4 +190,4 @@ export {
   FileTestStore,
   FileWALGateway
 };
-//# sourceMappingURL=store-file-D472VFCS.js.map
+//# sourceMappingURL=store-file-CSS5THFH.js.map

package/{store-indexdb-FRX5PTKR.js → store-indexdb-DR4HELVP.js}

@@ -5,9 +5,9 @@ import {
   IndexDBWalGateway,
   getIndexDBName,
   guardVersion
-} from "./chunk-EVSZA26U.js";
+} from "./chunk-AZVWSRER.js";
 import "./chunk-VZGT7ZYP.js";
-import "./chunk-UCMXU3DH.js";
+import "./chunk-NZNG6TQT.js";
 import "./chunk-H3A2HMMM.js";
 export {
   IndexDBDataGateway,
@@ -17,4 +17,4 @@ export {
   getIndexDBName,
   guardVersion
 };
-//# sourceMappingURL=store-indexdb-FRX5PTKR.js.map
+//# sourceMappingURL=store-indexdb-DR4HELVP.js.map

package/{store-sql-MDSU23Y7.js → store-sql-BG6SMGQJ.js}

@@ -8,7 +8,7 @@ import {
   exceptionWrapper,
   getKey,
   getName
-} from "./chunk-UCMXU3DH.js";
+} from "./chunk-NZNG6TQT.js";
 import {
   SysContainer
 } from "./chunk-H3A2HMMM.js";
@@ -88,7 +88,7 @@ function SQLConnectionFactory(databaseURL, opts = {}) {
 async function WalStoreFactory(db) {
   switch (db.opts.sqlFlavor) {
     case "sqlite": {
-      const { V0_18_0SQLiteWalStore } = await import("./sqlite-wal-store-G5YGK77N.js");
+      const { V0_18_0SQLiteWalStore } = await import("./sqlite-wal-store-JFBQPOYT.js");
       const store = new V0_18_0SQLiteWalStore(db);
       return store;
     }
@@ -99,7 +99,7 @@ async function WalStoreFactory(db) {
 async function DataStoreFactory(db) {
   switch (db.opts.sqlFlavor) {
     case "sqlite": {
-      const { V0_18_0SQLiteDataStore } = await import("./sqlite-data-store-RIH56645.js");
+      const { V0_18_0SQLiteDataStore } = await import("./sqlite-data-store-3ST7XOLX.js");
       const store = new V0_18_0SQLiteDataStore(db);
       return store;
     }
@@ -110,7 +110,7 @@ async function DataStoreFactory(db) {
 async function MetaStoreFactory(db) {
   switch (db.opts.sqlFlavor) {
     case "sqlite": {
-      const { V0_18_0SQLiteMetaStore } = await import("./sqlite-meta-store-6347MWOR.js");
+      const { V0_18_0SQLiteMetaStore } = await import("./sqlite-meta-store-QOIMCSJ7.js");
       const store = new V0_18_0SQLiteMetaStore(db);
       return store;
     }
@@ -341,4 +341,4 @@ export {
   SQLTestStore,
   SQLWalGateway
 };
-//# sourceMappingURL=store-sql-MDSU23Y7.js.map
+//# sourceMappingURL=store-sql-BG6SMGQJ.js.map

package/tests/blockstore/loader.test.ts

@@ -0,0 +1,265 @@
+import * as codec from "@ipld/dag-cbor";
+import { sha256 as hasher } from "multiformats/hashes/sha2";
+import { BlockView } from "multiformats";
+import { encode } from "multiformats/block";
+import { CID } from "multiformats/cid";
+import { MemoryBlockstore } from "@web3-storage/pail/block";
+import { CRDTMeta, IndexTransactionMeta, bs, rt } from "@fireproof/core";
+
+class MyMemoryBlockStore extends bs.EncryptedBlockstore {
+  readonly memblock = new MemoryBlockstore();
+  constructor() {
+    const ebOpts = {
+      name: "MyMemoryBlockStore",
+    };
+    super(ebOpts);
+  }
+  ready(): Promise<void> {
+    return Promise.resolve();
+  }
+  close(): Promise<void> {
+    return this.loader.close();
+  }
+  loader = new bs.Loader("MyMemoryBlockStore", {});
+  readonly transactions = new Set<bs.CarTransaction>();
+  // readonly lastTxMeta?: TransactionMeta;
+  readonly compacting: boolean = false;
+
+  override async put(cid: bs.AnyAnyLink, block: Uint8Array): Promise<void> {
+    return this.memblock.put(cid, block);
+  }
+
+  // transaction<M ext(fn: (t: CarTransaction) => Promise<MetaType>, opts?: { noLoader: boolean }): Promise<MetaType> {
+  //   throw new Error("Method not implemented.");
+  // }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getFile(car: bs.AnyLink, cid: bs.AnyLink, isPublic?: boolean): Promise<Uint8Array> {
+    throw new Error("Method not implemented.");
+  }
+  compact(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  defaultCompact(blocks: bs.CompactionFetcher): Promise<bs.TransactionMeta> {
+    throw new Error("Method not implemented.");
+  }
+}
+
+describe("basic Loader simple", function () {
+  let loader: bs.Loader;
+  let block: BlockView;
+  let t: bs.CarTransaction;
+
+  afterEach(async function () {
+    await loader.close();
+    await loader.destroy();
+  });
+
+  beforeEach(async function () {
+    const testDbName = "test-loader-commit";
+    await rt.SysContainer.start();
+    const mockM = new MyMemoryBlockStore();
+    t = new bs.CarTransaction(mockM as bs.EncryptedBlockstore);
+    loader = new bs.Loader(testDbName, { public: true });
+    await loader.ready();
+    block = await encode({
+      value: { hello: "world" },
+      hasher,
+      codec,
+    });
+    await t.put(block.cid, block.bytes);
+    await mockM.put(block.cid, block.bytes);
+  });
+  it("should have an empty car log", function () {
+    expect(loader.carLog.length).toBe(0);
+  });
+  it("should commit", async function () {
+    const carGroup = await loader.commit(t, { head: [block.cid] });
+    expect(loader.carLog.length).toBe(1);
+    const reader = await loader.loadCar(carGroup[0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+});
+
+describe("basic Loader with two commits", function () {
+  let loader: bs.Loader;
+  let block: BlockView;
+  let block2: BlockView;
+  let block3: BlockView;
+  let block4: BlockView;
+  let t: bs.CarTransaction;
+  let carCid: bs.CarGroup;
+  let carCid0: bs.CarGroup;
+
+  afterEach(async function () {
+    await loader.close();
+    await loader.destroy();
+  });
+
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    const mockM = new MyMemoryBlockStore();
+    t = new bs.CarTransaction(mockM);
+    loader = new bs.Loader("test-loader-two-commit", { public: true });
+    block = await encode({
+      value: { hello: "world" },
+      hasher,
+      codec,
+    });
+    await t.put(block.cid, block.bytes);
+    carCid0 = await loader.commit(t, { head: [block.cid] });
+
+    block2 = await encode({
+      value: { hello: "universe" },
+      hasher,
+      codec,
+    });
+    await t.put(block2.cid, block2.bytes);
+    carCid = await loader.commit(t, { head: [block2.cid] });
+
+    block3 = await encode({
+      value: { hello: "multiverse" },
+      hasher,
+      codec,
+    });
+    await t.put(block3.cid, block3.bytes);
+
+    block4 = await encode({
+      value: { hello: "megaverse" },
+      hasher,
+      codec,
+    });
+
+    await t.put(block4.cid, block4.bytes);
+  });
+
+  it("should have a car log", function () {
+    expect(loader.carLog.length).toBe(2);
+    expect(loader.carLog[0].toString()).toBe(carCid.toString());
+    expect(loader.carLog[1].toString()).toBe(carCid0.toString());
+  });
+
+  it("should commit", async function () {
+    const reader = await loader.loadCar(carCid[0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.compact.length).toBe(0);
+    expect(parsed.cars.length).toBe(1);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+
+  it("should compact", async function () {
+    const compactCid = await loader.commit(t, { head: [block2.cid] }, { compact: true });
+    expect(loader.carLog.length).toBe(1);
+
+    const reader = await loader.loadCar(compactCid[0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<CRDTMeta>(reader, loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.compact.length).toBe(2);
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.head).toBeTruthy();
+  });
+
+  it("compact should erase old files", async function () {
+    const cs = await loader.carStore();
+    await loader.commit(t, { head: [block2.cid] }, { compact: true });
+    expect(loader.carLog.length).toBe(1);
+    await loader.commit(t, { head: [block3.cid] }, { compact: false });
+    expect(loader.carLog.length).toBe(2);
+    expect(await cs.load(carCid[0])).toBeTruthy();
+    await loader.commit(t, { head: [block3.cid] }, { compact: true });
+    expect(loader.carLog.length).toBe(1);
+    const e0 = await cs.load(carCid[0]).catch((e) => e);
+    expect(e0 instanceof Error).toBeTruthy();
+    await loader.commit(t, { head: [block4.cid] }, { compact: false });
+    expect(loader.carLog.length).toBe(2);
+
+    const e = await loader.loadCar(carCid[0]).catch((e) => e);
+    expect(e).toBeTruthy();
+    expect(e instanceof Error).toBeTruthy();
+    expect(e.message).toMatch("missing car file");
+  }, 10000);
+});
+
+describe("basic Loader with index commits", function () {
+  let block: BlockView;
+  let ib: bs.EncryptedBlockstore;
+  let indexerResult: IndexTransactionMeta;
+  let cid: CID;
+  // let indexMap: Map<string, CID>;
+
+  afterEach(async function () {
+    await ib.close();
+    await ib.destroy();
+  });
+
+  beforeEach(async function () {
+    const name = "test-loader-index" + Math.random();
+    await rt.SysContainer.start();
+    // t = new CarTransaction()
+    ib = new bs.EncryptedBlockstore({ name });
+    block = await encode({
+      value: { hello: "world" },
+      hasher,
+      codec,
+    });
+    // console.log('block', block.cid)
+
+    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
+    indexerResult = {
+      indexes: {
+        hello: {
+          byId: cid,
+          byKey: cid,
+          head: [cid as CID<unknown, number, number, 1>],
+          name: "hello",
+          map: "(doc) => doc.hello",
+        },
+      },
+    };
+    // indexMap = new Map();
+  });
+
+  it("should start with an empty car log", function () {
+    expect(ib.loader).toBeTruthy();
+    expect(ib.loader.carLog.length).toBe(0);
+  });
+
+  it("should commit the index metadata", async function () {
+    const { cars: carCid } = await ib.transaction<IndexTransactionMeta>(
+      async (t) => {
+        await t.put(block.cid, block.bytes);
+        return indexerResult;
+      } /* , indexMap */,
+    );
+
+    expect(carCid).toBeTruthy();
+    expect(ib.loader).toBeTruthy();
+    const carLog = ib.loader.carLog;
+
+    expect(carLog.length).toBe(1);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const reader = await ib.loader.loadCar(carCid![0]);
+    expect(reader).toBeTruthy();
+    const parsed = await bs.parseCarFile<IndexTransactionMeta>(reader, ib.loader.logger);
+    expect(parsed.cars).toBeTruthy();
+    expect(parsed.cars.length).toBe(0);
+    expect(parsed.meta).toBeTruthy();
+    expect(parsed.meta.indexes).toBeTruthy();
+    const indexes = parsed.meta.indexes;
+    expect(indexes).toBeTruthy();
+    expect(indexes.hello).toBeTruthy();
+    expect(indexes.hello.map).toBe("(doc) => doc.hello");
+    expect(indexes.hello.name).toBe("hello");
+  });
+});

package/tests/blockstore/store.test.ts

@@ -0,0 +1,164 @@
+import { CID } from "multiformats";
+import { rt, bs } from "@fireproof/core";
+import { MockLogger } from "@adviser/cement";
+import { NotFoundError } from "../../src/blockstore/gateway";
+
+const decoder = new TextDecoder("utf-8");
+
+function runtime() {
+  return bs.toStoreRuntime({}, MockLogger().logger);
+}
+
+function mockLoader(name: string): bs.Loadable {
+  return {
+    name,
+    ebOpts: {
+      store: {},
+    },
+  } as bs.Loadable;
+}
+
+describe("DataStore", function () {
+  let store: bs.DataStore;
+  let raw: bs.TestStore;
+
+  afterEach(async () => {
+    await store.close();
+    await store.destroy();
+  });
+
+  beforeEach(async () => {
+    await rt.SysContainer.start();
+    store = await runtime().makeDataStore(mockLoader("test"));
+    await store.start();
+    raw = await bs.testStoreFactory(store.url);
+  });
+
+  it("should have a name", function () {
+    expect(store.name).toEqual("test");
+  });
+
+  it("should save a car", async function () {
+    const car: bs.AnyBlock = {
+      cid: "cidKey" as unknown as CID,
+      bytes: new Uint8Array([55, 56, 57]),
+    };
+    await store.save(car);
+    const data = await raw.get(store.url, car.cid.toString());
+    expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
+  });
+});
+
+describe("DataStore with a saved car", function () {
+  let store: bs.DataStore;
+  let raw: bs.TestStore;
+  let car: bs.AnyBlock;
+
+  afterEach(async () => {
+    await store.close();
+    await store.destroy();
+  });
+
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    store = await runtime().makeDataStore(mockLoader("test2"));
+    await store.start();
+    raw = await bs.testStoreFactory(store.url);
+    car = {
+      cid: "cid" as unknown as CID,
+      bytes: new Uint8Array([55, 56, 57, 80]),
+    };
+    await store.save(car);
+  });
+
+  it("should have a car", async function () {
+    const data = await raw.get(store.url, car.cid.toString());
+    expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
+  });
+
+  it("should load a car", async function () {
+    const loaded = await store.load(car.cid);
+    expect(loaded.cid).toEqual(car.cid);
+    expect(loaded.bytes.constructor.name).toEqual("Uint8Array");
+    expect(loaded.bytes.toString()).toEqual(car.bytes.toString());
+  });
+
+  it("should remove a car", async function () {
+    await store.remove(car.cid);
+    const error = (await store.load(car.cid).catch((e: Error) => e)) as NotFoundError;
+    expect(error.code).toMatch("ENOENT");
+    // matches(error.message, "ENOENT");
+  });
+});
+
+describe("MetaStore", function () {
+  let store: bs.MetaStore;
+  let raw: bs.TestStore;
+
+  afterEach(async () => {
+    await store.close();
+    await store.destroy();
+  });
+
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    store = await runtime().makeMetaStore(mockLoader("test"));
+    await store.start();
+    raw = await bs.testStoreFactory(store.url);
+  });
+
+  it("should have a name", function () {
+    expect(store.name).toEqual("test");
+  });
+
+  it("should save a header", async function () {
+    const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
+    const h: bs.DbMeta = {
+      cars: [cid],
+      key: undefined,
+    };
+    await store.save(h);
+    const file = await raw.get(store.url, "main");
+    const header = JSON.parse(decoder.decode(file));
+    expect(header).toBeTruthy();
+    expect(header.cars).toBeTruthy();
+    expect(header.cars[0]["/"]).toEqual(cid.toString());
+  });
+});
+
+describe("MetaStore with a saved header", function () {
+  let store: bs.MetaStore;
+  let raw: bs.TestStore;
+  let cid: CID;
+
+  afterEach(async () => {
+    await store.close();
+    await store.destroy();
+  });
+
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    store = await runtime().makeMetaStore(mockLoader("test-saved-header"));
+    await store.start();
+    raw = await bs.testStoreFactory(store.url);
+    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
+    await store.save({ cars: [cid], key: undefined });
+  });
+
+  it("should have a header", async function () {
+    const data = decoder.decode(await raw.get(store.url, "main"));
+    expect(data).toMatch(/car/);
+    const header = JSON.parse(data);
+    expect(header).toBeTruthy();
+    expect(header.cars).toBeTruthy();
+    expect(header.cars[0]["/"]).toEqual(cid.toString());
+  });
+
+  it("should load a header", async function () {
+    const loadeds = (await store.load()) as bs.DbMeta[];
+    const loaded = loadeds[0];
+    expect(loaded).toBeTruthy();
+    expect(loaded.cars).toBeTruthy();
+    expect(loaded.cars.toString()).toEqual(cid.toString());
+  });
+});

package/tests/blockstore/transaction.test.ts

@@ -0,0 +1,121 @@
+import { CID } from "multiformats";
+// import { matches, equalsJSON } from "../helpers.js";
+import { bs } from "@fireproof/core";
+
+describe("Fresh TransactionBlockstore", function () {
+  let blocks: bs.BaseBlockstore;
+  beforeEach(function () {
+    blocks = new bs.BaseBlockstore();
+  });
+  it("should not have a name", function () {
+    expect(blocks.name).toBeFalsy();
+  });
+  it("should not have a loader", function () {
+    expect(blocks.loader).toBeFalsy();
+  });
+  it("should not put", async function () {
+    const value = new TextEncoder().encode("value");
+    const e = await blocks.put("key" as unknown as bs.AnyLink, value).catch((e) => e);
+    expect(e.message).toMatch(/transaction/g);
+  });
+  it("should yield a transaction", async function () {
+    const txR = await blocks.transaction(async (tblocks) => {
+      expect(tblocks).toBeTruthy();
+      expect(tblocks instanceof bs.CarTransaction).toBeTruthy();
+      return { head: [] };
+    });
+    expect(txR).toBeTruthy();
+    expect(txR.t).toBeTruthy();
+    expect(txR.meta).toEqual({ head: [] });
+  });
+});
+
+describe("TransactionBlockstore with name", function () {
+  let blocks: bs.EncryptedBlockstore;
+  beforeEach(function () {
+    blocks = new bs.EncryptedBlockstore({ name: "test" });
+  });
+  it("should have a name", function () {
+    expect(blocks.name).toEqual("test");
+  });
+  it("should have a loader", function () {
+    expect(blocks.loader).toBeTruthy();
+  });
+  it("should get from loader", async function () {
+    const bytes = new TextEncoder().encode("bytes");
+    expect(blocks.loader).toBeTruthy();
+    blocks.loader.getBlock = async (cid) => {
+      return { cid, bytes };
+    };
+    const value = await blocks.get("key" as unknown as bs.AnyAnyLink);
+    expect(value).toEqual({ cid: "key" as unknown as bs.AnyAnyLink, bytes });
+  });
+});
+
+describe("A transaction", function () {
+  let tblocks: bs.CarTransaction;
+  let blocks: bs.EncryptedBlockstore;
+  beforeEach(async function () {
+    blocks = new bs.EncryptedBlockstore({ name: "test" });
+    tblocks = new bs.CarTransaction(blocks);
+    blocks.transactions.add(tblocks);
+  });
+  it("should put and get", async function () {
+    const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
+    const bytes = new TextEncoder().encode("bytes");
+    await tblocks.put(cid, bytes);
+    expect(blocks.transactions.has(tblocks)).toBeTruthy();
+    const got = await tblocks.get(cid);
+    expect(got).toBeTruthy();
+    expect(got?.cid).toEqual(cid);
+    expect(got?.bytes).toEqual(bytes);
+  });
+});
+
+function asUInt8Array(str: string) {
+  return new TextEncoder().encode(str);
+}
+
+describe("TransactionBlockstore with a completed transaction", function () {
+  let blocks: bs.BaseBlockstore;
+  let cid: CID;
+  let cid2: CID;
+
+  beforeEach(async function () {
+    cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
+    cid2 = CID.parse("bafybeibgouhn5ktecpjuovt52zamzvm4dlve5ak7x6d5smms3itkhplnhm");
+
+    blocks = new bs.BaseBlockstore();
+    await blocks.transaction(async (tblocks) => {
+      await tblocks.put(cid, asUInt8Array("value"));
+      await tblocks.put(cid2, asUInt8Array("value2"));
+      return { head: [] };
+    });
+    await blocks.transaction(async (tblocks) => {
+      await tblocks.put(cid, asUInt8Array("value"));
+      await tblocks.put(cid2, asUInt8Array("value2"));
+      return { head: [] };
+    });
+  });
+  it("should have transactions", async function () {
+    const ts = blocks.transactions;
+    expect(ts.size).toEqual(2);
+  });
+  it("should get", async function () {
+    const value = (await blocks.get(cid)) as bs.AnyBlock;
+    expect(value.cid).toEqual(cid);
+    expect(value.bytes.toString()).toEqual(asUInt8Array("value").toString());
+
+    const value2 = (await blocks.get(cid2)) as bs.AnyBlock;
+    expect(value2.bytes.toString()).toEqual(asUInt8Array("value2").toString());
+  });
+  it("should yield entries", async function () {
+    const blz = [];
+    for await (const blk of blocks.entries()) {
+      blz.push(blk);
+    }
+    expect(blz.length).toEqual(2);
+  });
+});
+
+// test compact