@fireproof/core 0.20.0-dev-preview-40 → 0.20.0-dev-preview-50

package/tests/fireproof/all-gateway.test.ts

@@ -32,9 +32,9 @@ import { Future } from "@adviser/cement";
 
 describe("noop Gateway", function () {
   let db: Ledger;
-  let carStore: bs.DataStore;
+  let carStore: bs.CarStore;
   let metaStore: bs.MetaStore;
-  let fileStore: bs.DataStore;
+  let fileStore: bs.FileStore;
   let walStore: bs.WALStore;
   let carGateway: bs.SerdeGateway;
   let metaGateway: bs.SerdeGateway;
@@ -43,21 +43,22 @@ describe("noop Gateway", function () {
   const sthis = ensureSuperThis();
   let ctx: { loader: bs.Loadable };
 
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     db = LedgerFactory("test-gateway-" + sthis.nextId().str, {
       logger: sthis.logger,
     });
-    ctx = { loader: await db.crdt.blockstore.loader };
+    await db.ready();
+    ctx = { loader: db.crdt.blockstore.loader };
 
     // Extract stores from the loader
-    carStore = (await ctx.loader.carStore()) as bs.DataStore;
-    metaStore = (await ctx.loader.metaStore()) as bs.MetaStore;
-    fileStore = (await ctx.loader.fileStore()) as bs.DataStore;
-    walStore = (await ctx.loader.WALStore()) as bs.WALStore;
+    carStore = ctx.loader.attachedStores.local().active.car;
+    metaStore = ctx.loader.attachedStores.local().active.meta;
+    fileStore = ctx.loader.attachedStores.local().active.file;
+    walStore = ctx.loader.attachedStores.local().active.wal;
 
     // Extract and log gateways
     carGateway = carStore.realGateway;
@@ -66,7 +67,7 @@ describe("noop Gateway", function () {
     walGateway = walStore.realGateway;
   });
 
-  it("should have valid stores and gateways", async function () {
+  it("should have valid stores and gateways", async () => {
     // Add assertions
     expect(carStore).toBeTruthy();
     expect(metaStore).toBeTruthy();
@@ -79,7 +80,7 @@ describe("noop Gateway", function () {
     expect(walGateway).toBeTruthy();
   });
 
-  it("should have correct store names", async function () {
+  it("should have correct store names", async () => {
     // Check that all stores have the correct name
     expect(carStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
     expect(metaStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
@@ -87,16 +88,16 @@ describe("noop Gateway", function () {
     expect(walStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
   });
 
-  it("should have correct store types in URLs", async function () {
+  it("should have correct store types in URLs", async () => {
     // Check that all stores have the correct store type in their URL
-    expect(carStore.url().toString()).toContain("store=data");
+    expect(carStore.url().toString()).toContain("store=car");
     expect(carStore.url().toString()).toContain("suffix=.car");
     expect(metaStore.url().toString()).toContain("store=meta");
-    expect(fileStore.url().toString()).toContain("store=data");
+    expect(fileStore.url().toString()).toContain("store=file");
     expect(walStore.url().toString()).toContain("store=wal");
   });
 
-  it("should have version specified in URLs", async function () {
+  it("should have version specified in URLs", async () => {
     // Verify that all stores have a version specified
     expect(carStore.url().toString()).toContain("version=");
     expect(metaStore.url().toString()).toContain("version=");
@@ -104,7 +105,7 @@ describe("noop Gateway", function () {
     expect(walStore.url().toString()).toContain("version=");
   });
 
-  it("should have correct gateway types", async function () {
+  it("should have correct gateway types", async () => {
     // Check that all gateways are instances of the expected gateway class
     expect(typeof carGateway).toBe("object");
     expect(typeof metaGateway).toBe("object");
@@ -112,18 +113,18 @@ describe("noop Gateway", function () {
     expect(typeof walGateway).toBe("object");
   });
 
-  it("should build CAR Gateway URL", async function () {
+  it("should build CAR Gateway URL", async () => {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
     const carUrl = await carGateway.buildUrl(ctx, carStore.url(), testKey);
     expect(carUrl.Ok().hasParam("key")).toBeTruthy();
   });
 
-  it("should start CAR Gateway", async function () {
+  it("should start CAR Gateway", async () => {
     const url = await carGateway.start(ctx, carStore.url());
     expect(url.Ok().asObj()).toEqual(carStore.url().asObj());
   });
 
-  it("should put data in CAR Gateway", async function () {
+  it("should put data in CAR Gateway", async () => {
     const carUrl = await carGateway.buildUrl(ctx, carStore.url(), fileContent.cid);
     await carGateway.start(ctx, carStore.url());
     const carPutResult = await carGateway.put(ctx, carUrl.Ok(), {
@@ -133,7 +134,7 @@ describe("noop Gateway", function () {
     expect(carPutResult.isOk()).toBeTruthy();
   });
 
-  it("should get data from CAR Gateway", async function () {
+  it("should get data from CAR Gateway", async () => {
     const carUrl = await carGateway.buildUrl(ctx, carStore.url(), fileContent.cid);
     await carGateway.start(ctx, carStore.url());
     await carGateway.put(ctx, carUrl.Ok(), {
@@ -146,7 +147,7 @@ describe("noop Gateway", function () {
     // customExpect(carGetResult.Ok(), (v) => expect(v).toEqual(testData), "carGetResult should match testData");
   });
 
-  it("should delete data from CAR Gateway", async function () {
+  it("should delete data from CAR Gateway", async () => {
     const carUrl = await carGateway.buildUrl(ctx, carStore.url(), fileContent.cid);
     await carGateway.start(ctx, carStore.url());
     await carGateway.put(ctx, carUrl.Ok(), {
@@ -157,33 +158,33 @@ describe("noop Gateway", function () {
     expect(carDeleteResult.isOk()).toBeTruthy();
   });
 
-  it("should close CAR Gateway", async function () {
+  it("should close CAR Gateway", async () => {
     await carGateway.close(ctx, carStore.url());
   });
-  it("should build Meta Gateway URL", async function () {
+  it("should build Meta Gateway URL", async () => {
     const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
     expect(metaUrl.Ok()).toBeTruthy();
   });
 
-  it("should start Meta Gateway", async function () {
+  it("should start Meta Gateway", async () => {
     await metaGateway.start(ctx, metaStore.url());
   });
 
-  it("should close Meta Gateway", async function () {
+  it("should close Meta Gateway", async () => {
     await metaGateway.start(ctx, metaStore.url());
     await metaGateway.close(ctx, metaStore.url());
   });
 
-  it("should build File Gateway URL", async function () {
+  it("should build File Gateway URL", async () => {
     const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
     expect(fileUrl.Ok()).toBeTruthy();
   });
 
-  it("should start File Gateway", async function () {
+  it("should start File Gateway", async () => {
     await fileGateway.start(ctx, fileStore.url());
   });
 
-  it("should put data to File Gateway", async function () {
+  it("should put data to File Gateway", async () => {
     const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
     await fileGateway.start(ctx, fileStore.url());
     const filePutResult = await fileGateway.put(ctx, fileUrl.Ok(), {
@@ -193,7 +194,7 @@ describe("noop Gateway", function () {
     expect(filePutResult.Ok()).toBeFalsy();
   });
 
-  it("should get data from File Gateway", async function () {
+  it("should get data from File Gateway", async () => {
     const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
     await fileGateway.start(ctx, fileStore.url());
     await fileGateway.put(ctx, fileUrl.Ok(), {
@@ -205,7 +206,7 @@ describe("noop Gateway", function () {
     expect(fileGetResult.Ok().payload).toEqual(fileContent.block);
   });
 
-  it("should delete data from File Gateway", async function () {
+  it("should delete data from File Gateway", async () => {
     const fileUrl = await fileGateway.buildUrl(ctx, fileStore.url(), fileContent.cid);
     await fileGateway.start(ctx, fileStore.url());
     await fileGateway.put(ctx, fileUrl.Ok(), {
@@ -216,20 +217,20 @@ describe("noop Gateway", function () {
     expect(fileDeleteResult.isOk()).toBeTruthy();
   });
 
-  it("should close File Gateway", async function () {
+  it("should close File Gateway", async () => {
     await fileGateway.close(ctx, fileStore.url());
   });
-  it("should build WAL Gateway URL", async function () {
+  it("should build WAL Gateway URL", async () => {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
     const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
     expect(walUrl.Ok()).toBeTruthy();
   });
 
-  it("should start WAL Gateway", async function () {
+  it("should start WAL Gateway", async () => {
     await walGateway.start(ctx, walStore.url());
   });
 
-  it("should put data to WAL Gateway", async function () {
+  it("should put data to WAL Gateway", async () => {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
     const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
     await walGateway.start(ctx, walStore.url());
@@ -246,7 +247,7 @@ describe("noop Gateway", function () {
     expect(walPutResult.Ok()).toBeFalsy();
   });
 
-  it("should get data from WAL Gateway", async function () {
+  it("should get data from WAL Gateway", async () => {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
     const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
     await walGateway.start(ctx, walStore.url());
@@ -285,7 +286,7 @@ describe("noop Gateway", function () {
     expect(ref).toEqual(walGetResult.Ok().payload);
   });
 
-  it("should delete data from WAL Gateway", async function () {
+  it("should delete data from WAL Gateway", async () => {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
     const walUrl = await walGateway.buildUrl(ctx, walStore.url(), testKey);
     await walGateway.start(ctx, walStore.url());
@@ -315,12 +316,12 @@ describe("noop Gateway", function () {
     expect(walDeleteResult.isOk()).toBeTruthy();
   });
 
-  it("should close WAL Gateway", async function () {
+  it("should close WAL Gateway", async () => {
     await walGateway.start(ctx, walStore.url());
     await walGateway.close(ctx, walStore.url());
   });
 
-  // it("should have correct CAR Gateway properties", async function () {
+  // it("should have correct CAR Gateway properties", async () =>{
   //   // CAR Gateway assertions
   //   expect(carGateway.fidLength).toBe(4);
   //   expect(carGateway.headerSize).toBe(36);
@@ -331,7 +332,7 @@ describe("noop Gateway", function () {
   //   expect(carStore.).toHaveProperty("url");
   // });
 
-  // it("should have correct Meta Gateway properties", async function () {
+  // it("should have correct Meta Gateway properties", async () =>{
   //   // Meta Gateway assertions
   //   expect(metaGateway.fidLength).toBe(4);
   //   expect(metaGateway.headerSize).toBe(36);
@@ -342,7 +343,7 @@ describe("noop Gateway", function () {
   //   expect(last).not.toHaveProperty("url");
   // });
 
-  // it("should have correct File Gateway properties", async function () {
+  // it("should have correct File Gateway properties", async () =>{
   //   // File Gateway assertions
   //   expect(fileGateway.fidLength).toBe(4);
   //   expect(fileGateway.headerSize).toBe(36);
@@ -353,7 +354,7 @@ describe("noop Gateway", function () {
   //   expect(last).toHaveProperty("url");
   // });
 
-  // it("should have correct WAL Gateway properties", async function () {
+  // it("should have correct WAL Gateway properties", async () =>{
   //   // WAL Gateway assertions
   //   expect(walGateway.fidLength).toBe(4);
   //   expect(walGateway.headerSize).toBe(36);
@@ -374,20 +375,22 @@ describe("noop Gateway subscribe", function () {
   const sthis = ensureSuperThis();
   let ctx: bs.SerdeGatewayCtx;
 
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     db = fireproof("test-gateway-" + sthis.nextId().str);
 
+    await db.ready();
+
     ctx = { loader: db.ledger.crdt.blockstore.loader };
     // Extract stores from the loader
-    metaStore = (await db.ledger.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
+    metaStore = db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
 
     metaGateway = metaStore.realGateway;
   });
-  it("should subscribe to meta Gateway", async function () {
+  it("should subscribe to meta Gateway", async () => {
     const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
     await metaGateway.start(ctx, metaStore.url());
 
@@ -427,11 +430,11 @@ describe("Gateway", function () {
 
   let ctx: bs.SerdeGatewayCtx;
 
-  afterEach(async function () {
+  afterEach(async () => {
     await db.close();
     await db.destroy();
   });
-  beforeEach(async function () {
+  beforeEach(async () => {
     db = fireproof("test-gateway-" + sthis.nextId().str);
     ctx = { loader: db.ledger.crdt.blockstore.loader };
     const ok = await db.put({ _id: "test", foo: "bar" });
@@ -440,7 +443,7 @@ describe("Gateway", function () {
 
     // Extract stores from the loader
     // carStore = (await db.blockstore.loader.carStore()) as unknown as ExtendedStore;
-    metaStore = (await db.ledger.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
+    metaStore = db.ledger.crdt.blockstore.loader.attachedStores.local().active.meta;
     // fileStore = (await db.blockstore.loader.fileStore()) as unknown as ExtendedStore;
     // walStore = (await db.blockstore.loader.WALStore()) as unknown as ExtendedStore;
 
@@ -451,7 +454,7 @@ describe("Gateway", function () {
     // walGateway = walStore.gateway;
   });
 
-  it("should get data from Meta Gateway", async function () {
+  it("should get data from Meta Gateway", async () => {
     const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
     await metaGateway.start(ctx, metaStore.url());
     const metaGetResult = await metaGateway.get(ctx, metaUrl.Ok());
@@ -463,7 +466,7 @@ describe("Gateway", function () {
     expect(Object.keys(meta[0])).toEqual(["eventCid", "parents", "dbMeta"]);
   });
 
-  it("should delete data from Meta Gateway", async function () {
+  it("should delete data from Meta Gateway", async () => {
     const metaUrl = await metaGateway.buildUrl(ctx, metaStore.url(), "main");
     await metaGateway.start(ctx, metaStore.url());
     // should we be testing .destroy() instead?

package/tests/fireproof/attachable.test.ts

@@ -0,0 +1,356 @@
+import { URI } from "@adviser/cement";
+import { stripper } from "@adviser/cement/utils";
+import { Attachable, Database, ensureSuperThis, fireproof, GatewayUrlsParam, PARAM, rt, Attached, bs } from "@fireproof/core";
+import { CarReader } from "@ipld/car/reader";
+import * as dagCbor from "@ipld/dag-cbor";
+import { sleep } from "../helpers.js";
+import { mockLoader } from "../helpers.js";
+
+describe("meta check", () => {
+  const sthis = ensureSuperThis();
+  it("empty Database", async () => {
+    const name = `remote-db-${sthis.nextId().str}`;
+    const db = fireproof(name, {
+      storeUrls: {
+        base: `memory://${name}`,
+      },
+    });
+    await db.ready();
+    const gws = db.ledger.crdt.blockstore.loader.attachedStores.local();
+    await db.close();
+    expect(
+      Array.from(((gws.active.car.realGateway as rt.gw.DefSerdeGateway).gw as rt.gw.memory.MemoryGateway).memorys.entries()).filter(
+        ([k]) => k.startsWith(`memory://${name}`),
+      ),
+    ).toEqual([]);
+  });
+
+  it("one record Database", async () => {
+    const name = `remote-db-${sthis.nextId().str}`;
+    const db = fireproof(name, {
+      storeUrls: {
+        base: `memory://${name}`,
+      },
+    });
+    await db.put({ _id: `id-${0}`, value: `value-${0}` });
+    await db.close();
+
+    const db1 = fireproof(name, {
+      storeUrls: {
+        base: `memory://${name}`,
+      },
+    });
+    await db1.close();
+  });
+
+  it("multiple record Database", async () => {
+    const name = `remote-db-${sthis.nextId().str}`;
+    const base = `memory://${name}?storekey=insecure`;
+    const db = fireproof(name, {
+      storeUrls: {
+        base,
+      },
+    });
+    await db.ready();
+    await db.put({ _id: `id-${0}`, value: `value-${0}` });
+    const gws = db.ledger.crdt.blockstore.loader.attachedStores.local();
+    expect(db.ledger.crdt.blockstore.loader.carLog.asArray().map((i) => i.map((i) => i.toString()))).toEqual([
+      ["baembeieldbalgnyxqp7rmj4cbrot75gweavqy3aw22km43zsfufrihfn7e"],
+      ["baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu"],
+    ]);
+    await db.close();
+    expect(
+      Array.from(((gws.active.car.realGateway as rt.gw.DefSerdeGateway).gw as rt.gw.memory.MemoryGateway).memorys.entries())
+        .filter(([k]) => k.startsWith(`memory://${name}`))
+        .map(([k]) =>
+          stripper(
+            ["name", "storekey", "version"],
+            Array.from(URI.from(k).getParams).reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {}),
+          ),
+        ),
+    ).toEqual([
+      {
+        key: "baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu",
+        store: "car",
+        suffix: ".car",
+      },
+      {
+        key: "main",
+        store: "wal",
+      },
+      {
+        key: "main",
+        store: "meta",
+      },
+      {
+        key: "baembeieldbalgnyxqp7rmj4cbrot75gweavqy3aw22km43zsfufrihfn7e",
+        store: "car",
+        suffix: ".car",
+      },
+    ]);
+
+    const db1 = fireproof(name, {
+      storeUrls: {
+        base,
+      },
+    });
+    expect(db1.ledger).not.equal(db.ledger);
+    await db1.ready();
+    expect(db1.ledger.crdt.blockstore.loader.carLog.asArray().map((i) => i.map((i) => i.toString()))).toEqual([
+      ["baembeieldbalgnyxqp7rmj4cbrot75gweavqy3aw22km43zsfufrihfn7e"],
+      ["baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu"],
+    ]);
+
+    const gensis = await db1.get(PARAM.GENESIS_CID);
+    expect(gensis).toEqual({ _id: PARAM.GENESIS_CID });
+
+    const val = await db1.allDocs();
+    expect(val.rows).toEqual([
+      {
+        key: "id-0",
+        value: {
+          _id: "id-0",
+          value: "value-0",
+        },
+      },
+    ]);
+    const car = Array.from(
+      ((gws.active.car.realGateway as rt.gw.DefSerdeGateway).gw as rt.gw.memory.MemoryGateway).memorys.entries(),
+    )
+      .filter(([k]) => k.startsWith(`memory://${name}`))
+      .map(([k, v]) => [URI.from(k).getParam(PARAM.KEY), v])
+      .find(([k]) => k === "baembeig2is4vdgz4gyiadfh5uutxxeiuqtacnesnytrnilpwcu7q5m5tmu") as [string, Uint8Array];
+    const rawReader = await CarReader.fromBytes(car[1]);
+    const blocks = [];
+    for await (const block of rawReader.blocks()) {
+      blocks.push(block);
+    }
+    expect(dagCbor.decode(blocks[1].bytes)).toEqual({
+      doc: {
+        _id: "baembeiarootfireproofgenesisblockaaaafireproofgenesisblocka",
+      },
+    });
+
+    expect(blocks.map((i) => i.cid.toString())).toEqual([
+      "bafyreibxibqhi6wh5klrje7ne4htffeqyyqfd6y7x2no6wnhid4nixizau",
+      "bafyreidnvv4mwvweup5w52ddre2sl4syhvczm6ejqsmuekajowdl2cf2q4",
+      "bafyreihh6nbfbhgkf5lz7hhsscjgiquw426rxzr3fprbgonekzmyvirrhe",
+      "bafyreiejg3twlaxr7gfvvhtxrhvwaydytdv4guidmtvaz5dskm6gp73ryi",
+      "bafyreiblui55o25dopc5faol3umsnuohb5carto7tot4kicnkfc37he4h4",
+    ]);
+  });
+});
+
+describe("activate store", () => {
+  // activate(store: DataAndMetaStore | CoerceURI): ActiveStore {
+  //   if (isCoerceURI(store)) {
+  //     throw this.loadable.sthis.logger.Error().Msg("store must be an object").AsError();
+  //   }
+  //   return new ActiveStoreImpl(store as DataAndMetaStore, this);
+  // }
+
+  const sthis = ensureSuperThis();
+  let attach: bs.AttachedStores;
+  let firstAttached: Attached;
+  let secondAttached: Attached;
+  beforeEach(async () => {
+    attach = new bs.AttachedRemotesImpl(mockLoader(sthis));
+    firstAttached = await attach.attach({
+      name: "first",
+      prepare: async () => ({
+        car: { url: "memory://first?store=car" },
+        meta: { url: "memory://first?store=meta" },
+        file: { url: "memory://first" },
+        wal: { url: "memory://first?store=wal" },
+      }),
+    });
+
+    secondAttached = await attach.attach({
+      name: "second",
+      prepare: async () => ({
+        car: { url: "memory://second?store=car" },
+        meta: { url: "memory://second?store=meta" },
+        file: { url: "memory://second?store=file" },
+      }),
+    });
+  });
+
+  it("activate by store", async () => {
+    expect(attach.activate(secondAttached.stores).active.car.url().toString()).toBe(
+      "memory://second?name=second&store=car&storekey=%40second-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate(firstAttached.stores).local().active.car.url().toString()).toBe(
+      "memory://first?name=first&store=car&storekey=%40first-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate(firstAttached.stores).active.meta.url().toString()).toBe(
+      "memory://first?name=first&store=meta&storekey=%40first-meta%40&version=v0.19-memory",
+    );
+  });
+
+  it("activate by store", async () => {
+    expect(attach.activate("memory://second").active.car.url().toString()).toBe(
+      "memory://second?name=second&store=car&storekey=%40second-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate("memory://second").remotes()[0].active.car.url().toString()).toEqual(
+      "memory://second?name=second&store=car&storekey=%40second-data%40&suffix=.car&version=v0.19-memory",
+    );
+    expect(attach.activate("memory://first?store=meta").active.car.url().toString()).toBe(
+      "memory://first?name=first&store=car&storekey=%40first-data%40&suffix=.car&version=v0.19-memory",
+    );
+  });
+});
+
+describe("join function", () => {
+  const sthis = ensureSuperThis();
+  // export const connect: ConnectFunction = (
+  //     db: Database,
+  //     remoteDbName = "",
+  //     url = "netlify://localhost:8888?protocol=ws"
+  //   ) => {
+  //     const { sthis, name: dbName } = db;
+  //     if (!dbName) {
+  //       throw new Error("dbName is required");
+  //     }
+  //     const urlObj = BuildURI.from(url);
+  //     const existingName = urlObj.getParam("name");
+  //     urlObj.defParam("name", remoteDbName || existingName || dbName);
+  //     urlObj.defParam("localName", dbName);
+  //     urlObj.defParam("storekey", `@${dbName}:data@`);
+  //     return connectionCache.get(urlObj.toString()).once(() => {
+  //       makeKeyBagUrlExtractable(sthis);
+  //       const connection = connectionFactory(sthis, urlObj);
+  //       connection.connect(db.ledger.crdt.blockstore);
+  //       return connection;
+  //     });
+  //   };
+  class AJoinable implements Attachable {
+    readonly name: string;
+    constructor(name: string) {
+      this.name = name;
+    }
+    prepare(): Promise<GatewayUrlsParam> {
+      return Promise.resolve({
+        car: { url: `memory://car/${this.name}` },
+        meta: { url: `memory://meta/${this.name}` },
+        file: { url: `memory://file/${this.name}` },
+      });
+    }
+  }
+  function aJoinable(name: string): Attachable {
+    return new AJoinable(name);
+  }
+
+  let db: Database;
+  let joinableDBs: string[] = [];
+  beforeAll(async () => {
+    const set = sthis.nextId().str;
+    joinableDBs = await Promise.all(
+      new Array(10).fill(1).map(async (_, i) => {
+        const name = `remote-db-${i}-${set}`;
+        const db = fireproof(name, {
+          storeUrls: {
+            // base: `memory://${name}`,
+            data: {
+              car: `memory://car/${name}`,
+              meta: `memory://meta/${name}`,
+              file: `memory://file/${name}`,
+              wal: `memory://wal/${name}`,
+            },
+          },
+        });
+        // await db.put({ _id: `genesis`, value: `genesis` });
+        // await db.ready();
+        for (let j = 0; j < 10; j++) {
+          await db.put({ _id: `${i}-${j}`, value: `${i}-${j}` });
+        }
+        expect(await db.get(PARAM.GENESIS_CID)).toEqual({ _id: PARAM.GENESIS_CID });
+        await db.close();
+        return name;
+      }),
+    );
+    // await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    db = fireproof(`db-${set}`, {
+      storeUrls: {
+        base: `memory://db-${set}`,
+      },
+    });
+    // await db.put({ _id: `genesis`, value: `genesis` });
+    for (let j = 0; j < 10; j++) {
+      await db.put({ _id: `db-${j}`, value: `db-${set}` });
+    }
+    expect(await db.get(PARAM.GENESIS_CID)).toEqual({ _id: PARAM.GENESIS_CID });
+  });
+  afterAll(async () => {
+    await db.close();
+  });
+
+  it("it is joinable detachable", async () => {
+    const my = fireproof("my", {
+      storeUrls: {
+        base: "memory://my",
+      },
+    });
+    await my.put({ _id: "genesis", value: "genesis" });
+    await Promise.all(
+      joinableDBs.map(async (name) => {
+        const tmp = fireproof(name, {
+          storeUrls: {
+            data: {
+              car: `memory://car/${name}`,
+              meta: `memory://meta/${name}`,
+              file: `memory://file/${name}`,
+              wal: `memory://wal/${name}`,
+            },
+          },
+        });
+        const res = await tmp.allDocs();
+        expect(res.rows.length).toBe(10);
+        await tmp.close();
+        const attached = await my.attach(aJoinable(name));
+        expect(attached).toBeDefined();
+      }),
+    );
+    expect(my.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(joinableDBs.length);
+    await my.close();
+    expect(my.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(0);
+  });
+
+  it("it is inbound syncing", async () => {
+    await Promise.all(
+      joinableDBs.map(async (name) => {
+        const attached = await db.attach(aJoinable(name));
+        expect(attached).toBeDefined();
+      }),
+    );
+    await sleep(100);
+    expect(db.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(joinableDBs.length);
+    const res = await db.allDocs();
+    expect(res.rows.length).toBe(10 + 10 * joinableDBs.length);
+  });
+
+  it("it empty inbound syncing", async () => {
+    const name = `empty-db-${sthis.nextId().str}`;
+    const db = fireproof(name, {
+      storeUrls: {
+        // base: `memory://${name}`,
+        data: {
+          car: `memory://car/${name}`,
+          meta: `memory://meta/${name}`,
+          file: `memory://file/${name}`,
+          wal: `memory://wal/${name}`,
+        },
+      },
+    });
+    await Promise.all(
+      joinableDBs.map(async (name) => {
+        const attached = await db.attach(aJoinable(name));
+        expect(attached).toBeDefined();
+      }),
+    );
+    await sleep(100);
+    expect(db.ledger.crdt.blockstore.loader.attachedStores.remotes().length).toBe(joinableDBs.length);
+    const res = await db.allDocs();
+    expect(res.rows.length).toBe(10 * joinableDBs.length);
+  });
+});