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

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

@@ -1,41 +1,44 @@
-import { Database, bs, ensureSuperThis } from "@fireproof/core";
-import { URI } from "@adviser/cement";
+import { Ledger, LedgerFactory, PARAM, bs, ensureSuperThis } from "@fireproof/core";
 
 import { fileContent } from "./cars/bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i.js";
-
-function customExpect(value: unknown, matcher: (val: unknown) => void, message: string): void {
-  try {
-    matcher(value);
-  } catch (error) {
-    void error;
-    // console.error(error);
-    throw new Error(message);
-  }
-}
-
-interface ExtendedGateway extends bs.Gateway {
-  logger: { _attributes: { module: string; url?: string } };
-  headerSize: number;
-  fidLength: number;
-}
-
-interface ExtendedStore {
-  gateway: ExtendedGateway;
-  _url: URI;
-  name: string;
-}
+import { simpleCID } from "../helpers.js";
+
+// import { DataStore, MetaStore, WALState, WALStore } from "../../src/blockstore/types.js";
+// import { Gateway } from "../../src/blockstore/gateway.js";
+// import { FPEnvelopeMeta, FPEnvelopeType } from "../../src/blockstore/fp-envelope.js";
+
+// function customExpect(value: unknown, matcher: (val: unknown) => void, message: string): void {
+//   try {
+//     matcher(value);
+//   } catch (error) {
+//     void error;
+//     // console.error(error);
+//     throw new Error(message);
+//   }
+// }
+
+// interface ExtendedGateway extends bs.Gateway {
+//   readonly logger: Logger;
+//   readonly headerSize: number;
+//   readonly fidLength: number;
+// }
+
+// interface ExtendedStore {
+//   readonly gateway: ExtendedGateway;
+//   readonly _url: URI;
+//   readonly name: string;
+// }
 
 describe("noop Gateway", function () {
-  let db: Database;
-  let carStore: ExtendedStore;
-  let metaStore: ExtendedStore;
-  let fileStore: ExtendedStore;
-  let walStore: ExtendedStore;
-  let carGateway: ExtendedGateway;
-  let metaGateway: ExtendedGateway;
-  let fileGateway: ExtendedGateway;
-  let walGateway: ExtendedGateway;
-
+  let db: Ledger;
+  let carStore: bs.DataStore;
+  let metaStore: bs.MetaStore;
+  let fileStore: bs.DataStore;
+  let walStore: bs.WALStore;
+  let carGateway: bs.SerdeGateway;
+  let metaGateway: bs.SerdeGateway;
+  let fileGateway: bs.SerdeGateway;
+  let walGateway: bs.SerdeGateway;
   const sthis = ensureSuperThis();
 
   afterEach(async function () {
@@ -43,19 +46,21 @@ describe("noop Gateway", function () {
     await db.destroy();
   });
   beforeEach(async function () {
-    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+    db = LedgerFactory("test-gateway-" + sthis.nextId().str, {
+      logger: sthis.logger,
+    });
 
     // Extract stores from the loader
-    carStore = (await db.blockstore.loader?.carStore()) as unknown as ExtendedStore;
-    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
-    fileStore = (await db.blockstore.loader?.fileStore()) as unknown as ExtendedStore;
-    walStore = (await db.blockstore.loader?.WALStore()) as unknown as ExtendedStore;
+    carStore = (await db.crdt.blockstore.loader?.carStore()) as bs.DataStore;
+    metaStore = (await db.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
+    fileStore = (await db.crdt.blockstore.loader?.fileStore()) as bs.DataStore;
+    walStore = (await db.crdt.blockstore.loader?.WALStore()) as bs.WALStore;
 
     // Extract and log gateways
-    carGateway = carStore?.gateway;
-    metaGateway = metaStore?.gateway;
-    fileGateway = fileStore?.gateway;
-    walGateway = walStore?.gateway;
+    carGateway = carStore.realGateway;
+    metaGateway = metaStore.realGateway;
+    fileGateway = fileStore.realGateway;
+    walGateway = walStore.realGateway;
   });
 
   it("should have valid stores and gateways", async function () {
@@ -73,26 +78,27 @@ describe("noop Gateway", function () {
 
   it("should have correct store names", async function () {
     // Check that all stores have the correct name
-    expect(carStore?.name).toContain("test-gateway");
-    expect(metaStore?.name).toContain("test-gateway");
-    expect(fileStore?.name).toContain("test-gateway");
-    expect(walStore?.name).toContain("test-gateway");
+    expect(carStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
+    expect(metaStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
+    expect(fileStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
+    expect(walStore.url().getParam(PARAM.NAME)).toContain("test-gateway");
   });
 
   it("should have correct store types in URLs", async function () {
     // Check that all stores have the correct store type in their URL
-    expect(carStore?._url.toString()).toContain("store=data");
-    expect(metaStore?._url.toString()).toContain("store=meta");
-    expect(fileStore?._url.toString()).toContain("store=data");
-    expect(walStore?._url.toString()).toContain("store=wal");
+    expect(carStore.url().toString()).toContain("store=data");
+    expect(carStore.url().toString()).toContain("suffix=.car");
+    expect(metaStore.url().toString()).toContain("store=meta");
+    expect(fileStore.url().toString()).toContain("store=data");
+    expect(walStore.url().toString()).toContain("store=wal");
   });
 
   it("should have version specified in URLs", async function () {
     // Verify that all stores have a version specified
-    expect(carStore?._url.toString()).toContain("version=");
-    expect(metaStore?._url.toString()).toContain("version=");
-    expect(fileStore?._url.toString()).toContain("version=");
-    expect(walStore?._url.toString()).toContain("version=");
+    expect(carStore.url().toString()).toContain("version=");
+    expect(metaStore.url().toString()).toContain("version=");
+    expect(fileStore.url().toString()).toContain("version=");
+    expect(walStore.url().toString()).toContain("version=");
   });
 
   it("should have correct gateway types", async function () {
@@ -105,202 +111,263 @@ describe("noop Gateway", function () {
 
   it("should build CAR Gateway URL", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
-    expect(carUrl?.Ok()).toBeTruthy();
+    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), testKey);
+    expect(carUrl.Ok().hasParam("key")).toBeTruthy();
   });
 
   it("should start CAR Gateway", async function () {
-    await carGateway?.start(carStore?._url);
+    const url = await carGateway.start(sthis, carStore.url());
+    expect(url.Ok().asObj()).toEqual(carStore.url().asObj());
   });
 
   it("should put data in CAR Gateway", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const testData = fileContent;
-    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
-    await carGateway?.start(carStore?._url);
-    const carPutResult = await carGateway?.put(carUrl?.Ok(), testData);
-    expect(carPutResult?.Ok()).toBeFalsy();
+    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), fileContent.cid);
+    await carGateway.start(sthis, carStore.url());
+    const carPutResult = await carGateway.put(sthis, carUrl.Ok(), {
+      type: bs.FPEnvelopeType.CAR,
+      payload: fileContent.block,
+    });
+    expect(carPutResult.isOk()).toBeTruthy();
   });
 
   it("should get data from CAR Gateway", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const testData = fileContent;
-    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
-    await carGateway?.start(carStore?._url);
-    await carGateway?.put(carUrl?.Ok(), testData);
-    const carGetResult = await carGateway?.get(carUrl?.Ok());
-    customExpect(carGetResult?.Ok(), (v) => expect(v).toEqual(testData), "carGetResult should match testData");
+    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), fileContent.cid);
+    await carGateway.start(sthis, carStore.url());
+    await carGateway.put(sthis, carUrl.Ok(), {
+      type: bs.FPEnvelopeType.CAR,
+      payload: fileContent.block,
+    });
+    const carGetResult = await carGateway.get(sthis, carUrl.Ok());
+    expect(carGetResult.Ok().type).toEqual("car");
+    expect(carGetResult.Ok().payload).toEqual(fileContent.block);
+    // customExpect(carGetResult.Ok(), (v) => expect(v).toEqual(testData), "carGetResult should match testData");
   });
 
   it("should delete data from CAR Gateway", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const testData = fileContent;
-    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
-    await carGateway?.start(carStore?._url);
-    await carGateway?.put(carUrl?.Ok(), testData);
-    const carDeleteResult = await carGateway?.delete(carUrl?.Ok());
-    expect(carDeleteResult?.Ok()).toBeFalsy();
+    const carUrl = await carGateway.buildUrl(sthis, carStore.url(), fileContent.cid);
+    await carGateway.start(sthis, carStore.url());
+    await carGateway.put(sthis, carUrl.Ok(), {
+      type: bs.FPEnvelopeType.CAR,
+      payload: fileContent.block,
+    });
+    const carDeleteResult = await carGateway.delete(sthis, carUrl.Ok());
+    expect(carDeleteResult.isOk()).toBeTruthy();
   });
 
   it("should close CAR Gateway", async function () {
-    await carGateway?.close(carStore?._url);
+    await carGateway.close(sthis, carStore.url());
   });
   it("should build Meta Gateway URL", async function () {
-    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
-    expect(metaUrl?.Ok()).toBeTruthy();
+    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
+    expect(metaUrl.Ok()).toBeTruthy();
   });
 
   it("should start Meta Gateway", async function () {
-    await metaGateway?.start(metaStore?._url);
+    await metaGateway.start(sthis, metaStore.url());
   });
 
   it("should close Meta Gateway", async function () {
-    await metaGateway?.start(metaStore?._url);
-    await metaGateway?.close(metaStore?._url);
+    await metaGateway.start(sthis, metaStore.url());
+    await metaGateway.close(sthis, metaStore.url());
   });
 
   it("should build File Gateway URL", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
-    expect(fileUrl?.Ok()).toBeTruthy();
+    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
+    expect(fileUrl.Ok()).toBeTruthy();
   });
 
   it("should start File Gateway", async function () {
-    await fileGateway?.start(fileStore?._url);
+    await fileGateway.start(sthis, fileStore.url());
   });
 
   it("should put data to File Gateway", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const testData = fileContent;
-    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
-    await fileGateway?.start(fileStore?._url);
-    const filePutResult = await fileGateway?.put(fileUrl?.Ok(), testData);
-    expect(filePutResult?.Ok()).toBeFalsy();
+    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
+    await fileGateway.start(sthis, fileStore.url());
+    const filePutResult = await fileGateway.put(sthis, fileUrl.Ok(), {
+      type: bs.FPEnvelopeType.FILE,
+      payload: fileContent.block,
+    });
+    expect(filePutResult.Ok()).toBeFalsy();
   });
 
   it("should get data from File Gateway", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const testData = fileContent;
-    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
-    await fileGateway?.start(fileStore?._url);
-    await fileGateway?.put(fileUrl?.Ok(), testData);
-    const fileGetResult = await fileGateway?.get(fileUrl?.Ok());
-    customExpect(fileGetResult?.Ok(), (v) => expect(v).toEqual(testData), "fileGetResult should match testData");
+    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
+    await fileGateway.start(sthis, fileStore.url());
+    await fileGateway.put(sthis, fileUrl.Ok(), {
+      type: bs.FPEnvelopeType.FILE,
+      payload: fileContent.block,
+    });
+    const fileGetResult = await fileGateway.get(sthis, fileUrl.Ok());
+    expect(fileGetResult.Ok().type).toEqual("file");
+    expect(fileGetResult.Ok().payload).toEqual(fileContent.block);
   });
 
   it("should delete data from File Gateway", async function () {
-    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const testData = fileContent;
-    const fileUrl = await fileGateway?.buildUrl(fileStore?._url, testKey);
-    await fileGateway?.start(fileStore?._url);
-    await fileGateway?.put(fileUrl?.Ok(), testData);
-    const fileDeleteResult = await fileGateway?.delete(fileUrl?.Ok());
-    expect(fileDeleteResult?.Ok()).toBeFalsy();
+    const fileUrl = await fileGateway.buildUrl(sthis, fileStore.url(), fileContent.cid);
+    await fileGateway.start(sthis, fileStore.url());
+    await fileGateway.put(sthis, fileUrl.Ok(), {
+      type: bs.FPEnvelopeType.FILE,
+      payload: fileContent.block,
+    });
+    const fileDeleteResult = await fileGateway.delete(sthis, fileUrl.Ok());
+    expect(fileDeleteResult.isOk()).toBeTruthy();
   });
 
   it("should close File Gateway", async function () {
-    await fileGateway?.close(fileStore?._url);
+    await fileGateway.close(sthis, fileStore.url());
   });
   it("should build WAL Gateway URL", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
-    expect(walUrl?.Ok()).toBeTruthy();
+    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
+    expect(walUrl.Ok()).toBeTruthy();
   });
 
   it("should start WAL Gateway", async function () {
-    await walGateway?.start(walStore?._url);
+    await walGateway.start(sthis, walStore.url());
   });
 
   it("should put data to WAL Gateway", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
-    await walGateway?.start(walStore?._url);
-    const walTestDataString = JSON.stringify({
-      operations: [],
-      noLoaderOps: [],
-      fileOperations: [],
+    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
+    await walGateway.start(sthis, walStore.url());
+    // const walTestDataString = JSON.stringify();
+    // const walTestData = sthis.txt.encode(walTestDataString);
+    const walPutResult = await walGateway.put(sthis, walUrl.Ok(), {
+      type: bs.FPEnvelopeType.WAL,
+      payload: {
+        operations: [],
+        noLoaderOps: [],
+        fileOperations: [],
+      },
     });
-    const walTestData = sthis.txt.encode(walTestDataString);
-    const walPutResult = await walGateway?.put(walUrl?.Ok(), walTestData);
-    expect(walPutResult?.Ok()).toBeFalsy();
+    expect(walPutResult.Ok()).toBeFalsy();
   });
 
   it("should get data from WAL Gateway", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
-    await walGateway?.start(walStore?._url);
-    const walTestDataString = JSON.stringify({
-      operations: [],
-      noLoaderOps: [],
-      fileOperations: [],
+    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
+    await walGateway.start(sthis, walStore.url());
+    const ref: bs.WALState = {
+      operations: [
+        {
+          cars: [await simpleCID(sthis)],
+        },
+      ],
+      noLoaderOps: [
+        {
+          cars: [await simpleCID(sthis)],
+        },
+      ],
+      fileOperations: [
+        {
+          cid: await simpleCID(sthis),
+          public: false,
+        },
+      ],
+    };
+    // const walTestDataString = JSON.stringify({
+    //   operations: [],
+    //   noLoaderOps: [],
+    //   fileOperations: [],
+    // });
+    // const walTestData = sthis.txt.encode(walTestDataString);
+    await walGateway.put(sthis, walUrl.Ok(), {
+      type: bs.FPEnvelopeType.WAL,
+      payload: ref,
     });
-    const walTestData = sthis.txt.encode(walTestDataString);
-    await walGateway?.put(walUrl?.Ok(), walTestData);
-    const walGetResult = await walGateway?.get(walUrl?.Ok());
-    const okResult = walGetResult?.Ok();
-    const decodedResult = sthis.txt.decode(okResult);
-    expect(decodedResult).toEqual(walTestDataString);
+    const walGetResult = await walGateway.get(sthis, walUrl.Ok());
+    expect(walGetResult.isOk()).toBeTruthy();
+    // const okResult = walGetResult.Ok();
+    // const decodedResult = sthis.txt.decode(okResult);
+    expect(ref).toEqual(walGetResult.Ok().payload);
   });
 
   it("should delete data from WAL Gateway", async function () {
     const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
-    const walUrl = await walGateway?.buildUrl(walStore?._url, testKey);
-    await walGateway?.start(walStore?._url);
-    const walTestDataString = JSON.stringify({
-      operations: [],
-      noLoaderOps: [],
-      fileOperations: [],
+    const walUrl = await walGateway.buildUrl(sthis, walStore.url(), testKey);
+    await walGateway.start(sthis, walStore.url());
+    const ref: bs.WALState = {
+      operations: [
+        {
+          cars: [await simpleCID(sthis)],
+        },
+      ],
+      noLoaderOps: [
+        {
+          cars: [await simpleCID(sthis)],
+        },
+      ],
+      fileOperations: [
+        {
+          cid: await simpleCID(sthis),
+          public: false,
+        },
+      ],
+    };
+    await walGateway.put(sthis, walUrl.Ok(), {
+      type: bs.FPEnvelopeType.WAL,
+      payload: ref,
     });
-    const walTestData = sthis.txt.encode(walTestDataString);
-    await walGateway?.put(walUrl?.Ok(), walTestData);
-    const walDeleteResult = await walGateway?.delete(walUrl?.Ok());
-    expect(walDeleteResult?.Ok()).toBeFalsy();
+    const walDeleteResult = await walGateway.delete(sthis, walUrl.Ok());
+    expect(walDeleteResult.isOk()).toBeTruthy();
   });
 
   it("should close WAL Gateway", async function () {
-    await walGateway?.start(walStore?._url);
-    await walGateway?.close(walStore?._url);
-  });
-
-  it("should have correct CAR Gateway properties", async function () {
-    // CAR Gateway assertions
-    expect(carGateway?.fidLength).toBe(4);
-    expect(carGateway?.headerSize).toBe(36);
-    expect(carGateway?.logger._attributes).toHaveProperty("module");
-    expect(carGateway?.logger._attributes).toHaveProperty("url");
-  });
-
-  it("should have correct Meta Gateway properties", async function () {
-    // Meta Gateway assertions
-    expect(metaGateway?.fidLength).toBe(4);
-    expect(metaGateway?.headerSize).toBe(36);
-    expect(metaGateway?.logger._attributes).toHaveProperty("module");
-    expect(metaGateway?.logger._attributes).not.toHaveProperty("url");
-  });
-
-  it("should have correct File Gateway properties", async function () {
-    // File Gateway assertions
-    expect(fileGateway?.fidLength).toBe(4);
-    expect(fileGateway?.headerSize).toBe(36);
-    expect(fileGateway?.logger._attributes).toHaveProperty("module");
-    expect(fileGateway?.logger._attributes).toHaveProperty("url");
-  });
-
-  it("should have correct WAL Gateway properties", async function () {
-    // WAL Gateway assertions
-    expect(walGateway?.fidLength).toBe(4);
-    expect(walGateway?.headerSize).toBe(36);
-    expect(walGateway?.logger._attributes).toHaveProperty("module");
-    expect(walGateway?.logger._attributes).not.toHaveProperty("url");
-  });
+    await walGateway.start(sthis, walStore.url());
+    await walGateway.close(sthis, walStore.url());
+  });
+
+  // it("should have correct CAR Gateway properties", async function () {
+  //   // CAR Gateway assertions
+  //   expect(carGateway.fidLength).toBe(4);
+  //   expect(carGateway.headerSize).toBe(36);
+  //   carGateway.logger.Error().Msg("CAR Gateway properties");
+  //   await sthis.logger.Flush();
+  //   const last = sthis.ctx.logCollector.Logs().slice(-1)[0];
+  //   expect(last).toHaveProperty("module");
+  //   expect(carStore.).toHaveProperty("url");
+  // });
+
+  // it("should have correct Meta Gateway properties", async function () {
+  //   // Meta Gateway assertions
+  //   expect(metaGateway.fidLength).toBe(4);
+  //   expect(metaGateway.headerSize).toBe(36);
+  //   metaGateway.logger.Error().Msg("CAR Gateway properties");
+  //   await sthis.logger.Flush();
+  //   const last = sthis.ctx.logCollector.Logs().slice(-1)[0];
+  //   expect(last).toHaveProperty("module");
+  //   expect(last).not.toHaveProperty("url");
+  // });
+
+  // it("should have correct File Gateway properties", async function () {
+  //   // File Gateway assertions
+  //   expect(fileGateway.fidLength).toBe(4);
+  //   expect(fileGateway.headerSize).toBe(36);
+  //   fileGateway.logger.Error().Msg("CAR Gateway properties");
+  //   await sthis.logger.Flush();
+  //   const last = sthis.ctx.logCollector.Logs().slice(-1)[0];
+  //   expect(last).toHaveProperty("module");
+  //   expect(last).toHaveProperty("url");
+  // });
+
+  // it("should have correct WAL Gateway properties", async function () {
+  //   // WAL Gateway assertions
+  //   expect(walGateway.fidLength).toBe(4);
+  //   expect(walGateway.headerSize).toBe(36);
+  //   walGateway.logger.Error().Msg("CAR Gateway properties");
+  //   await sthis.logger.Flush();
+  //   const last = sthis.ctx.logCollector.Logs().slice(-1)[0];
+  //   expect(last).toHaveProperty("module");
+  //   expect(last).not.toHaveProperty("url");
+  // });
 });
 
 describe("noop Gateway subscribe", function () {
-  let db: Database;
+  let db: Ledger;
 
-  let metaStore: ExtendedStore;
+  let metaStore: bs.MetaStore;
 
-  let metaGateway: ExtendedGateway;
+  let metaGateway: bs.SerdeGateway;
   const sthis = ensureSuperThis();
 
   afterEach(async function () {
@@ -308,30 +375,30 @@ describe("noop Gateway subscribe", function () {
     await db.destroy();
   });
   beforeEach(async function () {
-    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+    db = LedgerFactory("test-gateway-" + sthis.nextId().str);
 
     // Extract stores from the loader
-    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
+    metaStore = (await db.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
 
-    metaGateway = metaStore?.gateway;
+    metaGateway = metaStore.realGateway;
   });
   it("should subscribe to meta Gateway", async function () {
-    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
-    await metaGateway?.start(metaStore?._url);
+    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
+    await metaGateway.start(sthis, metaStore.url());
 
     let resolve: () => void;
     let didCall = false;
     const p = new Promise<void>((r) => {
       resolve = r;
     });
-    const metaSubscribeResult = await metaGateway?.subscribe?.(metaUrl?.Ok(), async (data: Uint8Array) => {
-      const decodedData = sthis.txt.decode(data);
-      expect(decodedData).toContain("[]");
-      didCall = true;
-      resolve();
-    });
-    if (!metaSubscribeResult?.isErr()) {
-      expect(metaSubscribeResult?.Ok()).toBeTruthy();
+    if (metaGateway.subscribe) {
+      const metaSubscribeResult = (await metaGateway.subscribe(sthis, metaUrl.Ok(), async (data: bs.FPEnvelopeMeta) => {
+        // const decodedData = sthis.txt.decode(data);
+        expect(data.payload).toContain("[]");
+        didCall = true;
+        resolve();
+      })) as bs.UnsubscribeResult;
+      expect(metaSubscribeResult.isOk()).toBeTruthy();
       const ok = await db.put({ _id: "key1", hello: "world1" });
       expect(ok).toBeTruthy();
       expect(ok.id).toBe("key1");
@@ -342,13 +409,13 @@ describe("noop Gateway subscribe", function () {
 });
 
 describe("Gateway", function () {
-  let db: Database;
+  let db: Ledger;
   // let carStore: ExtendedStore;
-  let metaStore: ExtendedStore;
+  let metaStore: bs.MetaStore;
   // let fileStore: ExtendedStore;
   // let walStore: ExtendedStore;
   // let carGateway: ExtendedGateway;
-  let metaGateway: ExtendedGateway;
+  let metaGateway: bs.SerdeGateway;
   // let fileGateway: ExtendedGateway;
   // let walGateway: ExtendedGateway;
   const sthis = ensureSuperThis();
@@ -358,38 +425,41 @@ describe("Gateway", function () {
     await db.destroy();
   });
   beforeEach(async function () {
-    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+    db = LedgerFactory("test-gateway-" + sthis.nextId().str);
     const ok = await db.put({ _id: "test", foo: "bar" });
     expect(ok).toBeTruthy();
     expect(ok.id).toBe("test");
 
     // Extract stores from the loader
-    // carStore = (await db.blockstore.loader?.carStore()) as unknown as ExtendedStore;
-    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
-    // fileStore = (await db.blockstore.loader?.fileStore()) as unknown as ExtendedStore;
-    // walStore = (await db.blockstore.loader?.WALStore()) as unknown as ExtendedStore;
+    // carStore = (await db.blockstore.loader.carStore()) as unknown as ExtendedStore;
+    metaStore = (await db.crdt.blockstore.loader?.metaStore()) as bs.MetaStore;
+    // fileStore = (await db.blockstore.loader.fileStore()) as unknown as ExtendedStore;
+    // walStore = (await db.blockstore.loader.WALStore()) as unknown as ExtendedStore;
 
     // Extract and log gateways
-    // carGateway = carStore?.gateway;
-    metaGateway = metaStore?.gateway;
-    // fileGateway = fileStore?.gateway;
-    // walGateway = walStore?.gateway;
+    // carGateway = carStore.gateway;
+    metaGateway = metaStore.realGateway;
+    // fileGateway = fileStore.gateway;
+    // walGateway = walStore.gateway;
   });
 
   it("should get data from Meta Gateway", async function () {
-    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
-    await metaGateway?.start(metaStore?._url);
-    const metaGetResult = await metaGateway?.get(metaUrl?.Ok());
-    const metaGetResultOk = metaGetResult?.Ok();
-    const decodedMetaGetResultOk = sthis.txt.decode(metaGetResultOk);
-    expect(decodedMetaGetResultOk).toContain("parents");
+    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
+    await metaGateway.start(sthis, metaStore.url());
+    const metaGetResult = await metaGateway.get(sthis, metaUrl.Ok());
+    expect(metaGetResult.isOk()).toBeTruthy();
+    const meta = metaGetResult.Ok().payload as bs.DbMetaEvent[];
+    // const metaGetResultOk = metaGetResult.Ok();
+    // const decodedMetaGetResultOk = sthis.txt.decode(metaGetResultOk);
+    expect(meta.length).toBe(1);
+    expect(Object.keys(meta[0])).toEqual(["eventCid", "parents", "dbMeta"]);
   });
 
   it("should delete data from Meta Gateway", async function () {
-    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
-    await metaGateway?.start(metaStore?._url);
+    const metaUrl = await metaGateway.buildUrl(sthis, metaStore.url(), "main");
+    await metaGateway.start(sthis, metaStore.url());
     // should we be testing .destroy() instead?
-    const metaDeleteResult = await metaGateway?.delete(metaUrl?.Ok());
-    expect(metaDeleteResult?.Ok()).toBeFalsy();
+    const metaDeleteResult = await metaGateway.delete(sthis, metaUrl.Ok());
+    expect(metaDeleteResult.isOk()).toBeTruthy();
   });
 });