@fireproof/core 0.19.8-dev → 0.19.8-dev-alldocs

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

package/tests/fireproof/config.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { fireproof, rt } from "@fireproof/core";
+import { isNode } from "std-env";
+
+describe("fireproof/config", () => {
+  let _my_app = "my-app";
+  function my_app() {
+    return _my_app;
+  }
+  beforeAll(async () => {
+    await rt.SysContainer.start();
+    if (isNode) {
+      const fpStorageUrl = rt.SysContainer.env.get("FP_STORAGE_URL");
+      if (fpStorageUrl) {
+        let url: URL;
+        try {
+          url = new URL(fpStorageUrl);
+        } catch (e) {
+          url = new URL(`file://${fpStorageUrl}`);
+        }
+        _my_app = `my-app-${url.protocol.replace(/:$/, "")}`;
+      }
+    }
+  });
+
+  if (!isNode) {
+    it("default", async () => {
+      const db = fireproof(my_app());
+      await db.put({ name: "my-app" });
+      expect(db.name).toBe(my_app());
+      const carStore = await db.blockstore.loader?.carStore();
+      expect(carStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=data&version=${rt.INDEXDB_VERSION}`));
+      const fileStore = await db.blockstore.loader?.fileStore();
+      expect(fileStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=data&version=${rt.INDEXDB_VERSION}`));
+      const metaStore = await db.blockstore.loader?.metaStore();
+      expect(metaStore?.url.toString()).toMatch(new RegExp(`indexdb://fp\\?name=my-app&store=meta&version=${rt.INDEXDB_VERSION}`));
+      await db.close();
+    });
+    return;
+  }
+  it("node default", async () => {
+    const old = rt.SysContainer.env.get("FP_STORAGE_URL");
+    rt.SysContainer.env.del("FP_STORAGE_URL");
+    let baseDir = rt
+      .dataDir(my_app())
+      .replace(/\?.*$/, "")
+      .replace(/^file:\/\//, "");
+    baseDir = rt.SysContainer.join(baseDir, rt.FILESTORE_VERSION, my_app());
+    await rt.SysContainer.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    expect(baseDir).toMatch(new RegExp(`/\\.fireproof/${rt.FILESTORE_VERSION}/${my_app()}`));
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`file:.*\\/\\.fireproof\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`file:.*\\/\\.fireproof\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`file:.*\\/\\.fireproof\\?name=${my_app()}&store=meta&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    rt.SysContainer.env.set("FP_STORAGE_URL", old);
+    await db.close();
+  });
+
+  it("set by env", async () => {
+    const old = rt.SysContainer.env.get("FP_STORAGE_URL");
+    rt.SysContainer.env.set("FP_STORAGE_URL", "./dist/env");
+
+    let baseDir = rt
+      .dataDir(my_app())
+      .replace(/\?.*$/, "")
+      .replace(/^file:\/\//, "");
+    baseDir = rt.SysContainer.join(baseDir, rt.FILESTORE_VERSION, my_app());
+    await rt.SysContainer.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`file://\\./dist/env\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`file://\\./dist/env\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`file://\\./dist/env\\?name=${my_app()}&store=meta&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+    rt.SysContainer.env.set("FP_STORAGE_URL", old);
+  });
+
+  it("file path", async () => {
+    let baseDir = "./dist/data".replace(/\?.*$/, "").replace(/^file:\/\//, "");
+    baseDir = rt.SysContainer.join(baseDir, rt.FILESTORE_VERSION, my_app());
+    await rt.SysContainer.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), {
+      store: {
+        stores: {
+          base: "./dist/data",
+        },
+      },
+    });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`file://.\\/dist\\/data\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`file://.\\/dist\\/data\\?name=${my_app()}&store=data&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`file://.\\/dist\\/data\\?name=${my_app()}&store=meta&version=${rt.FILESTORE_VERSION}`),
+    );
+    expect((await rt.SysContainer.stat(rt.SysContainer.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+  });
+
+  it("sqlite path", async () => {
+    let dbFile = "sqlite://./dist/sqlite".replace(/\?.*$/, "").replace(/^sqlite:\/\//, "");
+    dbFile = rt.SysContainer.join(dbFile, `${my_app()}.sqlite`);
+    await rt.SysContainer.rm(dbFile, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), {
+      store: {
+        stores: {
+          base: "sqlite://./dist/sqlite",
+        },
+      },
+    });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect((await rt.SysContainer.stat(dbFile)).isFile()).toBeTruthy();
+    expect(db.name).toBe(my_app());
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite\\?name=${my_app()}&store=meta&version=${rt.SQLITE_VERSION}`),
+    );
+    await db.close();
+  });
+
+  it("full config path", async () => {
+    const db = fireproof(my_app(), {
+      store: {
+        stores: {
+          base: "sqlite://./dist/sqlite",
+
+          meta: "sqlite://./dist/sqlite/meta",
+          data: "sqlite://./dist/sqlite/data",
+          index: "sqlite://./dist/sqlite/index",
+          remoteWAL: "sqlite://./dist/sqlite/wal",
+        },
+      },
+    });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: my_app() });
+    expect(db.name).toBe(my_app());
+
+    const carStore = await db.blockstore.loader?.carStore();
+    expect(carStore?.url.toString()).toMatch(
+      // sqlite://./dist/sqlite/data?store=data&version=v0.19-sqlite
+      new RegExp(`sqlite://./dist/sqlite/data\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+
+    const fileStore = await db.blockstore.loader?.fileStore();
+    expect(fileStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite/data\\?name=${my_app()}&store=data&version=${rt.SQLITE_VERSION}`),
+    );
+    const metaStore = await db.blockstore.loader?.metaStore();
+    expect(metaStore?.url.toString()).toMatch(
+      new RegExp(`sqlite://./dist/sqlite/meta\\?name=${my_app()}&store=meta&version=${rt.SQLITE_VERSION}`),
+    );
+    await db.close();
+  });
+});