@fireproof/core 0.19.121 → 0.20.0-dev-preview-06

package/tests/fireproof/indexer.test.ts

@@ -1,4 +1,17 @@
-import { Index, index, Database, CRDT, IndexRows, ensureSuperThis } from "@fireproof/core";
+import {
+  Index,
+  index,
+  Database,
+  CRDT,
+  IndexRows,
+  toStoreURIRuntime,
+  bs,
+  rt,
+  DatabaseFactory,
+  defaultWriteQueueOpts,
+  ensureSuperThis,
+  DatabaseOpts,
+} from "@fireproof/core";
 
 interface TestType {
   readonly title: string;
@@ -13,24 +26,24 @@ describe("basic Index", () => {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db._crdt, "hello", (doc) => {
+    indexer = new Index<string, TestType>(sthis, db.crdt, "hello", (doc) => {
       didMap = true;
       return doc.title;
     });
     await indexer.ready();
   });
   it("should have properties", function () {
-    expect(indexer.crdt).toBe(db._crdt);
-    expect(indexer.crdt.name).toBe("test-indexer");
+    expect(indexer.crdt).toBe(db.crdt);
+    // expect(indexer.crdt.name).toBe("test-indexer");
     expect(indexer.name).toBe("hello");
     expect(indexer.mapFn).toBeTruthy();
   });
@@ -100,17 +113,17 @@ describe("Index query with compound key", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("test-indexer");
     await db.put({ title: "amazing", score: 1 });
     await db.put({ title: "creative", score: 2 });
     await db.put({ title: "creative", score: 20 });
     await db.put({ title: "bazillas", score: 3 });
-    indexer = new Index<[string, number], TestType>(sthis, db._crdt, "hello", (doc) => {
+    indexer = new Index<[string, number], TestType>(sthis, db.crdt, "hello", (doc) => {
       return [doc.title, doc.score];
     });
     await indexer.ready();
@@ -130,16 +143,16 @@ describe("basic Index with map fun", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType>(sthis, db._crdt, "hello", (doc, map) => {
+    indexer = new Index<string, TestType>(sthis, db.crdt, "hello", (doc, map) => {
       map(doc.title);
     });
     await indexer.ready();
@@ -163,11 +176,11 @@ describe("basic Index with map fun with value", function () {
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index<string, TestType, number>(sthis, db._crdt, "hello", (doc, map) => {
+    indexer = new Index<string, TestType, number>(sthis, db.crdt, "hello", (doc, map) => {
       map(doc.title, doc.title.length);
     });
   });
@@ -198,17 +211,17 @@ describe("Index query with map and compound key", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("test-indexer");
     await db.put({ title: "amazing", score: 1 });
     await db.put({ title: "creative", score: 2 });
     await db.put({ title: "creative", score: 20 });
     await db.put({ title: "bazillas", score: 3 });
-    indexer = new Index<[string, number], TestType>(sthis, db._crdt, "hello", (doc, emit) => {
+    indexer = new Index<[string, number], TestType>(sthis, db.crdt, "hello", (doc, emit) => {
       emit([doc.title, doc.score]);
     });
     await indexer.ready();
@@ -228,16 +241,16 @@ describe("basic Index with string fun", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
+    db = DatabaseFactory("test-indexer");
     await db.put({ title: "amazing" });
     await db.put({ title: "creative" });
     await db.put({ title: "bazillas" });
-    indexer = new Index(sthis, db._crdt, "title");
+    indexer = new Index(sthis, db.crdt, "title");
     await indexer.ready();
   });
   it("should get results", async function () {
@@ -264,31 +277,44 @@ describe("basic Index upon cold start", function () {
   let mapFn: (doc: TestType) => string;
   let result: IndexRows<string, TestType>;
   const sthis = ensureSuperThis();
+  let dbOpts: DatabaseOpts;
   // result, mapFn;
   afterEach(async function () {
     await crdt.close();
     await crdt.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    // db = database()
-    crdt = new CRDT<TestType>(sthis, "test-indexer-cold", { persistIndexes: true });
+    const logger = sthis.logger.With().Module("IndexerTest").Logger();
+    logger.Debug().Msg("enter beforeEach");
+    dbOpts = {
+      writeQueue: defaultWriteQueueOpts({}),
+      keyBag: rt.kb.defaultKeyBagOpts(sthis),
+      storeUrls: toStoreURIRuntime(sthis, "test-indexer-cold"),
+      storeEnDe: bs.ensureStoreEnDeFile({}),
+    };
+    crdt = new CRDT<TestType>(sthis, dbOpts);
     await crdt.bulk([
       { id: "abc1", value: { title: "amazing" } },
       { id: "abc2", value: { title: "creative" } },
       { id: "abc3", value: { title: "bazillas" } },
     ]);
+    logger.Debug().Msg("post bulk beforeEach");
     didMap = 0;
     mapFn = (doc) => {
       didMap++;
       return doc.title;
     };
-    indexer = await index<string, TestType>(sthis, { _crdt: crdt }, "hello", mapFn);
+    indexer = await index<string, TestType>({ crdt: crdt }, "hello", mapFn);
+    logger.Debug().Msg("post index beforeEach");
     await indexer.ready();
+    logger.Debug().Msg("post indexer.ready beforeEach");
     // new Index(db._crdt.indexBlockstore, db._crdt, 'hello', mapFn)
     result = await indexer.query();
+
+    logger.Debug().Msg("post indexer.query beforeEach");
     expect(indexer.indexHead).toEqual(crdt.clock.head);
   });
   it("should call map on first query", function () {
@@ -301,12 +327,12 @@ describe("basic Index upon cold start", function () {
     expect(result.rows.length).toEqual(3);
   });
   it("should work on cold load", async function () {
-    const crdt2 = new CRDT<TestType>(sthis, "test-indexer-cold", { persistIndexes: true });
+    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
     await crdt2.ready();
     const { result, head } = await crdt2.changes();
     expect(result).toBeTruthy();
     await crdt2.ready();
-    const indexer2 = await index<string, TestType>(sthis, { _crdt: crdt2 }, "hello", mapFn);
+    const indexer2 = await index<string, TestType>({ crdt: crdt2 }, "hello", mapFn);
     await indexer2.ready();
     const result2 = await indexer2.query();
     expect(indexer2.indexHead).toEqual(head);
@@ -316,8 +342,8 @@ describe("basic Index upon cold start", function () {
   });
   it.skip("should not rerun the map function on seen changes", async function () {
     didMap = 0;
-    const crdt2 = new CRDT<TestType>(sthis, "test-indexer-cold", { persistIndexes: true });
-    const indexer2 = await index(sthis, { _crdt: crdt2 }, "hello", mapFn);
+    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
+    const indexer2 = await index({ crdt: crdt2 }, "hello", mapFn);
     const { result, head } = await crdt2.changes([]);
     expect(result.length).toEqual(3);
     expect(head.length).toEqual(1);
@@ -341,10 +367,8 @@ describe("basic Index upon cold start", function () {
     expect(didMap).toEqual(1);
   });
   it("should ignore meta when map function definiton changes", async function () {
-    const crdt2 = new CRDT<TestType>(sthis, "test-indexer-cold");
-    const result = await index<string, TestType>(sthis, { _crdt: crdt2 }, "hello", (doc) =>
-      doc.title.split("").reverse().join(""),
-    ).query();
+    const crdt2 = new CRDT<TestType>(sthis, dbOpts);
+    const result = await index<string, TestType>({ crdt: crdt2 }, "hello", (doc) => doc.title.split("").reverse().join("")).query();
     expect(result.rows.length).toEqual(3);
     expect(result.rows[0].key).toEqual("evitaerc"); // creative
   });
@@ -358,20 +382,20 @@ describe("basic Index with no data", function () {
   afterEach(async function () {
     await db.close();
     await db.destroy();
-    await indexer.close();
-    await indexer.destroy();
+    // await indexer.close();
+    // await indexer.destroy();
   });
   beforeEach(async function () {
     await sthis.start();
-    db = new Database("test-indexer");
-    indexer = new Index<string, TestType>(sthis, db._crdt, "hello", (doc) => {
+    db = DatabaseFactory("test-indexer");
+    indexer = new Index<string, TestType>(sthis, db.crdt, "hello", (doc) => {
       didMap = true;
       return doc.title;
     });
     await indexer.ready();
   });
   it("should have properties", function () {
-    expect(indexer.crdt).toEqual(db._crdt);
+    expect(indexer.crdt).toEqual(db.crdt);
     expect(indexer.name).toEqual("hello");
     expect(indexer.mapFn).toBeTruthy();
   });

package/tests/fireproof/utils.test.ts

@@ -1,7 +1,5 @@
-import { URI } from "@adviser/cement";
-import { rt, getStore, ensureSuperLog, ensureSuperThis } from "@fireproof/core";
-
-// only for test
+import { runtimeFn, URI } from "@adviser/cement";
+import { rt, getStore, inplaceFilter, ensureSuperThis, ensureSuperLog } from "@fireproof/core";
 import { UUID } from "uuidv7";
 
 describe("utils", () => {
@@ -33,14 +31,16 @@ describe("utils", () => {
   ];
   it("getfilename plain", () => {
     for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?store=${store.type}&name=name&key=key&version=version`);
+      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}`);
     }
   });
 
   it("getfilename index", () => {
     for (const store of storeOpts) {
-      const url = URI.from(`file://./x/path?index=idx&store=${store.type}&name=name&key=key&version=version`);
+      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}`);
     }
   });
@@ -80,4 +80,45 @@ describe("utils", () => {
     const id = sthis.timeOrderedNextId(0xcafebabebeef).str;
     expect(id.slice(0, 15)).toBe("cafebabe-beef-7");
   });
+
+  it("inplaceFilter empty", () => {
+    const s: string[] = [];
+    expect(inplaceFilter(s, () => false)).toEqual([]);
+    expect(inplaceFilter(s, () => true)).toEqual([]);
+  });
+
+  it("inplaceFilter sized filtered", () => {
+    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
+    expect(inplaceFilter(s, () => false)).toEqual([]);
+  });
+  it("inplaceFilter sized unfiltered", () => {
+    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
+    const ref = [...s];
+    expect(inplaceFilter(s, () => true)).toEqual(ref);
+  });
+
+  it("inplaceFilter sized mod 7", () => {
+    const s = new Array(100).fill("a").map((a, i) => `${a}${i.toString()}`);
+    const ref = [...s];
+    for (let i = 99; i >= 0; i--) {
+      if (!(i % 7)) {
+        ref.splice(i, 1);
+      }
+    }
+    expect(inplaceFilter(s, (_, j) => !!(j % 7))).toEqual(ref);
+    expect(s.length).toBe(85);
+  });
+});
+
+describe("runtime", () => {
+  it("runtime", () => {
+    const isNode = !!(typeof process === "object" && process.versions?.node);
+    expect(runtimeFn()).toEqual({
+      isBrowser: !isNode,
+      isCFWorker: false,
+      isDeno: false,
+      isNodeIsh: isNode,
+      isReactNative: false,
+    });
+  });
 });

package/tests/gateway/file/loader-config.test.ts

@@ -0,0 +1,307 @@
+import { BuildURI, CoerceURI, URI } from "@adviser/cement";
+import { fireproof, PARAM, rt, SuperThis } from "@fireproof/core";
+import { mockSuperThis } from "../../helpers.js";
+
+function dataDir(sthis: SuperThis, name?: string, base?: CoerceURI): URI {
+  if (!base) {
+    const home = sthis.env.get("HOME") || "./";
+    base =
+      sthis.env.get("FP_STORAGE_URL") ||
+      `file://${sthis.pathOps.join(home, ".fireproof", rt.FILESTORE_VERSION.replace(/-.*$/, ""))}?${PARAM.URL_GEN}=default`;
+  }
+  return URI.from(base.toString())
+    .build()
+    .setParam(PARAM.NAME, name || "")
+    .URI();
+}
+
+const _my_app = "my-app";
+function my_app() {
+  return _my_app;
+}
+
+describe("config file gateway", () => {
+  const sthis = mockSuperThis();
+  // const isMemFS: { fs?: string } = {};
+
+  beforeAll(async () => {
+    await sthis.start();
+    // const url = URI.from(sthis.env.get("FP_STORAGE_URL"));
+    // if (url.getParam("fs") === "mem") {
+    //   isMemFS.fs = "mem";
+    // }
+  });
+
+  it("loader", async () => {
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+
+    const dataStore = await db.crdt.blockstore.loader?.carStore();
+    expect(dataStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "data",
+        suffix: ".car",
+        storekey: "@my-app-data@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const WALStore = await db.crdt.blockstore.loader?.WALStore();
+    expect(WALStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "wal",
+        storekey: "@my-app-wal@",
+        urlGen: "fromEnv",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    await db.close();
+  });
+
+  it("file path", async () => {
+    let baseDir = "./dist/data".replace(/\?.*$/, "").replace(/^file:\/\//, "");
+    baseDir = sthis.pathOps.join(baseDir, /* testCfg(sthis, "data").version, */ my_app());
+    const base = BuildURI.from("./dist/data");
+    // if (isMemFS.fs) {
+    //   base.setParam("fs", isMemFS.fs);
+    // }
+    const sysfs = await rt.gw.file.sysFileSystemFactory(base.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    const db = fireproof(my_app(), { storeUrls: { base } });
+    // console.log(`>>>>>>>>>>>>>>>file-path`)
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.crdt.blockstore.loader?.carStore();
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        suffix: ".car",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "data",
+        storekey: "@my-app-data@",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: "./dist/data",
+      protocol: "file:",
+      searchParams: {
+        // ...isMemFS,
+        name: "my-app",
+        store: "meta",
+        storekey: "@my-app-meta@",
+        version: "v0.19-file",
+      },
+      style: "path",
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+  });
+
+  it("homedir default", async () => {
+    const old = sthis.env.get("FP_STORAGE_URL");
+    sthis.env.delete("FP_STORAGE_URL");
+    // this switches file: protocol not memory:
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, my_app());
+
+    const base = BuildURI.from(baseDir);
+    // if (isMemFS.fs) {
+    //   base.setParam("fs", isMemFS.fs);
+    // }
+    const sysfs = await rt.gw.file.sysFileSystemFactory(base.URI());
+    await sysfs.rm(baseDir, { recursive: true }).catch(() => {
+      /* */
+    });
+
+    expect(baseDir).toMatch(new RegExp(`/\\.fireproof/${rt.FILESTORE_VERSION.replace(/-file/, "")}/${my_app()}`));
+
+    const db = fireproof(my_app());
+    await db.put({ name: "my-app" });
+    expect(db.name).toBe(my_app());
+    const carStore = await db.crdt.blockstore.loader?.carStore();
+
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        suffix: ".car",
+        runtime: "node",
+        urlGen: "default",
+        store: "data",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        runtime: "node",
+        urlGen: "default",
+        store: "data",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: `${sthis.env.get("HOME")}/.fireproof/v0.19`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        runtime: "node",
+        urlGen: "default",
+        store: "meta",
+        name: my_app(),
+        storekey: `@${my_app()}-meta@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    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 = sthis.env.get("FP_STORAGE_URL");
+    // assert(!old, "FP_STORAGE_URL must set")
+    const testUrl = BuildURI.from(old);
+    // sthis.env.set("FP_STORAGE_URL", testUrl.toString());
+
+    let baseDir = dataDir(sthis, my_app()).pathname;
+    baseDir = sthis.pathOps.join(baseDir, /* testCfg(sthis, "data").version, */ my_app());
+
+    const sysfs = await rt.gw.file.sysFileSystemFactory(testUrl.URI());
+    await sysfs.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.crdt.blockstore.loader.carStore();
+    expect(carStore?.url().asObj()).toEqual({
+      pathname: "./dist/fp-dir-file",
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        urlGen: "fromEnv",
+        store: "data",
+        // runtime: "node",
+        suffix: ".car",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "data"))).isDirectory()).toBeTruthy();
+    const fileStore = await db.crdt.blockstore.loader?.fileStore();
+    expect(fileStore?.url().asObj()).toEqual({
+      pathname: `./dist/fp-dir-file`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        urlGen: "fromEnv",
+        store: "data",
+        name: my_app(),
+        storekey: `@${my_app()}-data@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+
+    const metaStore = await db.crdt.blockstore.loader?.metaStore();
+    expect(metaStore?.url().asObj()).toEqual({
+      pathname: `./dist/fp-dir-file`,
+      protocol: "file:",
+      style: "path",
+      searchParams: {
+        // ...isMemFS,
+        urlGen: "fromEnv",
+        store: "meta",
+        name: my_app(),
+        storekey: `@${my_app()}-meta@`,
+        version: rt.FILESTORE_VERSION,
+      },
+    });
+    expect((await sysfs.stat(sthis.pathOps.join(baseDir, "meta"))).isDirectory()).toBeTruthy();
+    await db.close();
+    sthis.env.set("FP_STORAGE_URL", old);
+  });
+});