@fireproof/core 0.19.8-dev-getcon → 0.19.9-dev-frag

package/tests/blockstore/store.test.ts

@@ -1,16 +1,16 @@
 import { CID } from "multiformats";
-import { rt, bs } from "@fireproof/core";
-import { MockLogger } from "@adviser/cement";
-import { NotFoundError } from "../../src/blockstore/gateway";
+import { bs, NotFoundError, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../helpers";
 
 const decoder = new TextDecoder("utf-8");
 
-function runtime() {
-  return bs.toStoreRuntime({}, MockLogger().logger);
+function runtime(sthis: SuperThis) {
+  return bs.toStoreRuntime({}, sthis);
 }
 
-function mockLoader(name: string): bs.Loadable {
+function mockLoader(sthis: SuperThis, name: string): bs.Loadable {
   return {
+    sthis,
     name,
     ebOpts: {
       store: {},
@@ -20,18 +20,19 @@ function mockLoader(name: string): bs.Loadable {
 
 describe("DataStore", function () {
   let store: bs.DataStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
 
+  const sthis = mockSuperThis();
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
   beforeEach(async () => {
-    await rt.SysContainer.start();
-    store = await runtime().makeDataStore(mockLoader("test"));
+    await sthis.start();
+    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
   });
 
   it("should have a name", function () {
@@ -44,26 +45,28 @@ describe("DataStore", function () {
       bytes: new Uint8Array([55, 56, 57]),
     };
     await store.save(car);
-    const data = await raw.get(store.url, car.cid.toString());
+    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 raw: bs.TestGateway;
   let car: bs.AnyBlock;
 
+  const sthis = mockSuperThis();
+
   afterEach(async () => {
     await store.close();
     await store.destroy();
   });
 
   beforeEach(async function () {
-    await rt.SysContainer.start();
-    store = await runtime().makeDataStore(mockLoader("test2"));
+    await sthis.start();
+    store = await runtime(sthis).makeDataStore(mockLoader(sthis, "test2"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
     car = {
       cid: "cid" as unknown as CID,
       bytes: new Uint8Array([55, 56, 57, 80]),
@@ -72,7 +75,7 @@ describe("DataStore with a saved car", function () {
   });
 
   it("should have a car", async function () {
-    const data = await raw.get(store.url, car.cid.toString());
+    const data = await raw.get(store.url(), car.cid.toString());
     expect(decoder.decode(data)).toEqual(decoder.decode(car.bytes));
   });
 
@@ -93,7 +96,9 @@ describe("DataStore with a saved car", function () {
 
 describe("MetaStore", function () {
   let store: bs.MetaStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
+
+  const sthis = mockSuperThis();
 
   afterEach(async () => {
     await store.close();
@@ -101,10 +106,10 @@ describe("MetaStore", function () {
   });
 
   beforeEach(async function () {
-    await rt.SysContainer.start();
-    store = await runtime().makeMetaStore(mockLoader("test"));
+    await sthis.start();
+    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
   });
 
   it("should have a name", function () {
@@ -115,10 +120,10 @@ describe("MetaStore", function () {
     const cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
     const h: bs.DbMeta = {
       cars: [cid],
-      key: undefined,
+      // key: undefined,
     };
     await store.save(h);
-    const file = await raw.get(store.url, "main");
+    const file = await raw.get(store.url(), "main");
     const header = JSON.parse(decoder.decode(file));
     expect(header).toBeTruthy();
     expect(header.cars).toBeTruthy();
@@ -128,8 +133,9 @@ describe("MetaStore", function () {
 
 describe("MetaStore with a saved header", function () {
   let store: bs.MetaStore;
-  let raw: bs.TestStore;
+  let raw: bs.TestGateway;
   let cid: CID;
+  const sthis = mockSuperThis();
 
   afterEach(async () => {
     await store.close();
@@ -137,16 +143,16 @@ describe("MetaStore with a saved header", function () {
   });
 
   beforeEach(async function () {
-    await rt.SysContainer.start();
-    store = await runtime().makeMetaStore(mockLoader("test-saved-header"));
+    await sthis.start();
+    store = await runtime(sthis).makeMetaStore(mockLoader(sthis, "test-saved-header"));
     await store.start();
-    raw = await bs.testStoreFactory(store.url);
+    raw = await bs.testStoreFactory(store.url(), sthis);
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
-    await store.save({ cars: [cid], key: undefined });
+    await store.save({ cars: [cid] /*, key: undefined */ });
   });
 
   it("should have a header", async function () {
-    const data = decoder.decode(await raw.get(store.url, "main"));
+    const data = decoder.decode(await raw.get(store.url(), "main"));
     expect(data).toMatch(/car/);
     const header = JSON.parse(data);
     expect(header).toBeTruthy();

package/tests/blockstore/transaction.test.ts

@@ -1,9 +1,10 @@
 import { CID } from "multiformats";
-// import { matches, equalsJSON } from "../helpers.js";
-import { bs } from "@fireproof/core";
+import { bs, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../helpers";
 
 describe("Fresh TransactionBlockstore", function () {
   let blocks: bs.BaseBlockstore;
+  const sthis = mockSuperThis();
   beforeEach(function () {
     blocks = new bs.BaseBlockstore();
   });
@@ -14,7 +15,7 @@ describe("Fresh TransactionBlockstore", function () {
     expect(blocks.loader).toBeFalsy();
   });
   it("should not put", async function () {
-    const value = new TextEncoder().encode("value");
+    const value = sthis.txt.encode("value");
     const e = await blocks.put("key" as unknown as bs.AnyLink, value).catch((e) => e);
     expect(e.message).toMatch(/transaction/g);
   });
@@ -32,8 +33,9 @@ describe("Fresh TransactionBlockstore", function () {
 
 describe("TransactionBlockstore with name", function () {
   let blocks: bs.EncryptedBlockstore;
+  const sthis = mockSuperThis();
   beforeEach(function () {
-    blocks = new bs.EncryptedBlockstore({ name: "test" });
+    blocks = new bs.EncryptedBlockstore(sthis, { name: "test" });
   });
   it("should have a name", function () {
     expect(blocks.name).toEqual("test");
@@ -42,7 +44,7 @@ describe("TransactionBlockstore with name", function () {
     expect(blocks.loader).toBeTruthy();
   });
   it("should get from loader", async function () {
-    const bytes = new TextEncoder().encode("bytes");
+    const bytes = sthis.txt.encode("bytes");
     expect(blocks.loader).toBeTruthy();
     blocks.loader.getBlock = async (cid) => {
       return { cid, bytes };
@@ -55,14 +57,15 @@ describe("TransactionBlockstore with name", function () {
 describe("A transaction", function () {
   let tblocks: bs.CarTransaction;
   let blocks: bs.EncryptedBlockstore;
+  const sthis = mockSuperThis();
   beforeEach(async function () {
-    blocks = new bs.EncryptedBlockstore({ name: "test" });
+    blocks = new bs.EncryptedBlockstore(sthis, { 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");
+    const bytes = sthis.txt.encode("bytes");
     await tblocks.put(cid, bytes);
     expect(blocks.transactions.has(tblocks)).toBeTruthy();
     const got = await tblocks.get(cid);
@@ -72,14 +75,15 @@ describe("A transaction", function () {
   });
 });
 
-function asUInt8Array(str: string) {
-  return new TextEncoder().encode(str);
+function asUInt8Array(str: string, sthis: SuperThis) {
+  return sthis.txt.encode(str);
 }
 
 describe("TransactionBlockstore with a completed transaction", function () {
   let blocks: bs.BaseBlockstore;
   let cid: CID;
   let cid2: CID;
+  const sthis = mockSuperThis();
 
   beforeEach(async function () {
     cid = CID.parse("bafybeia4luuns6dgymy5kau5rm7r4qzrrzg6cglpzpogussprpy42cmcn4");
@@ -87,13 +91,13 @@ describe("TransactionBlockstore with a completed transaction", function () {
 
     blocks = new bs.BaseBlockstore();
     await blocks.transaction(async (tblocks) => {
-      await tblocks.put(cid, asUInt8Array("value"));
-      await tblocks.put(cid2, asUInt8Array("value2"));
+      await tblocks.put(cid, asUInt8Array("value", sthis));
+      await tblocks.put(cid, asUInt8Array("value", sthis));
       return { head: [] };
     });
     await blocks.transaction(async (tblocks) => {
-      await tblocks.put(cid, asUInt8Array("value"));
-      await tblocks.put(cid2, asUInt8Array("value2"));
+      await tblocks.put(cid, asUInt8Array("value", sthis));
+      await tblocks.put(cid2, asUInt8Array("value2", sthis));
       return { head: [] };
     });
   });
@@ -104,10 +108,10 @@ describe("TransactionBlockstore with a completed transaction", function () {
   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());
+    expect(value.bytes.toString()).toEqual(asUInt8Array("value", sthis).toString());
 
     const value2 = (await blocks.get(cid2)) as bs.AnyBlock;
-    expect(value2.bytes.toString()).toEqual(asUInt8Array("value2").toString());
+    expect(value2.bytes.toString()).toEqual(asUInt8Array("value2", sthis).toString());
   });
   it("should yield entries", async function () {
     const blz = [];

package/tests/fireproof/config.test.ts

@@ -1,10 +1,12 @@
 import { describe, it, expect, beforeAll } from "vitest";
-import { fireproof, rt } from "@fireproof/core";
+import { dataDir, fireproof, rt } from "@fireproof/core";
+import { runtimeFn, URI } from "@adviser/cement";
+import { mockSuperThis } from "../helpers";
 
 describe("runtime", () => {
   it("runtime", () => {
     const isNode = !!(typeof process === "object" && process.versions?.node);
-    expect(rt.SysContainer.runtime()).toEqual({
+    expect(runtimeFn()).toEqual({
       isBrowser: !isNode,
       isDeno: false,
       isNodeIsh: isNode,
@@ -18,46 +20,58 @@ describe("fireproof/config", () => {
   function my_app() {
     return _my_app;
   }
+  function params(store: string) {
+    return Object.entries({
+      store,
+      name: my_app(),
+      storekey: `@${my_app()}:${store}@`,
+      version: rt.FILESTORE_VERSION,
+    });
+  }
+  const sthis = mockSuperThis();
   beforeAll(async () => {
-    await rt.SysContainer.start();
-    if (rt.SysContainer.runtime().isNodeIsh) {
-      const fpStorageUrl = rt.SysContainer.env.get("FP_STORAGE_URL");
+    await sthis.start();
+    if (runtimeFn().isNodeIsh) {
+      const fpStorageUrl = sthis.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(/:$/, "")}`;
+        const url = URI.from(fpStorageUrl);
+        _my_app = `my-app-${url.protocol.replace(/:$/, "")}:${url.getParam("fs") || "fs"}`;
       }
     }
   });
 
-  if (!rt.SysContainer.runtime().isNodeIsh) {
+  if (!runtimeFn().isNodeIsh) {
     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}`));
+      expect(fileStore?.url().toString()).toMatch(
+        new RegExp(`indexdb://fp\\?name=my-app&store=data&storekey=%40my-app%3Adata%40&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}`));
+      expect(metaStore?.url().toString()).toMatch(
+        new RegExp(`indexdb://fp\\?name=my-app&store=meta&storekey=%40my-app%3Ameta%40&version=${rt.INDEXDB_VERSION}`),
+      );
+
+      const carStore = await db.blockstore.loader?.carStore();
+      expect(carStore?.url().toString()).toMatch(
+        new RegExp(`indexdb://fp\\?name=my-app&store=data&storekey=%40my-app%3Adata%40&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(() => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    sthis.env.delete("FP_STORAGE_URL");
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, rt.FILESTORE_VERSION, my_app());
+
+    const sysfs = await rt.getFileSystem(URI.from(baseDir));
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
       /* */
     });
 
@@ -68,34 +82,39 @@ describe("fireproof/config", () => {
     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();
+    for (const [param, value] of Object.entries({
+      store: "data",
+      name: my_app(),
+      storekey: `@${my_app()}:data@`,
+      version: rt.FILESTORE_VERSION,
+    })) {
+      expect(carStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.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}`),
-    );
+    for (const [param, value] of params("data")) {
+      expect(fileStore?.url().getParam(param)).toBe(value);
+    }
     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);
+    for (const [param, value] of params("meta")) {
+      expect(metaStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    sthis.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 old = sthis.env.get("FP_STORAGE_URL");
+    const testUrl = URI.merge(`./dist/env`, old);
+    sthis.env.set("FP_STORAGE_URL", testUrl.toString());
+
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, rt.FILESTORE_VERSION, my_app());
+
+    const sysfs = await rt.getFileSystem(testUrl);
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
       /* */
     });
 
@@ -103,54 +122,51 @@ describe("fireproof/config", () => {
     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();
+    for (const [param, value] of params("data")) {
+      expect(carStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.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}`),
-    );
+    for (const [param, value] of params("data")) {
+      expect(fileStore?.url().getParam(param)).toBe(value);
+    }
     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();
+    for (const [param, value] of params("meta")) {
+      expect(metaStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
     await db.close();
-    rt.SysContainer.env.set("FP_STORAGE_URL", old);
+    sthis.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(() => {
+    baseDir = sthis.pathOps.join(baseDir, rt.FILESTORE_VERSION, my_app());
+
+    const base = "./dist/data";
+    const sysfs = await rt.getFileSystem(URI.from(base));
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
       /* */
     });
 
-    const db = fireproof(my_app(), {
-      store: {
-        stores: {
-          base: "./dist/data",
-        },
-      },
-    });
+    const db = fireproof(my_app(), { store: { stores: { base } } });
     // 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}`),
-    );
+    for (const [param, value] of params("data")) {
+      expect(carStore?.url().getParam(param)).toBe(value);
+    }
     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();
+    for (const [param, value] of params("data")) {
+      expect(fileStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.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();
+    for (const [param, value] of params("meta")) {
+      expect(metaStore?.url().getParam(param)).toBe(value);
+    }
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
     await db.close();
   });
 });