@fireproof/core 0.19.9-dev-frag → 0.19.11-dev-dryrun

package/{node-filesystem-5JLBSHKQ.js → node-filesystem-7YZR3POJ.js}

@@ -1,12 +1,13 @@
 import {
   toArrayBuffer
-} from "./chunk-JO5AVWG7.js";
-import "./chunk-YS4GL6OK.js";
+} from "./chunk-XINRLWR3.js";
+import "./chunk-MAK4D54P.js";
 
 // src/runtime/gateways/file/node-filesystem.ts
+import { runtimeFn } from "@adviser/cement";
 var NodeFileSystem = class {
   async start() {
-    this.fs = await import("fs/promises");
+    this.fs = await import("node:fs/promises");
     return this;
   }
   async mkdir(path, options) {
@@ -32,10 +33,13 @@ var NodeFileSystem = class {
     return this.fs?.unlink(path);
   }
   async writefile(path, data) {
+    if (runtimeFn().isDeno) {
+      return this.fs?.writeFile(path, data);
+    }
     return this.fs?.writeFile(path, Buffer.from(data));
   }
 };
 export {
   NodeFileSystem
 };
-//# sourceMappingURL=node-filesystem-5JLBSHKQ.js.map
+//# sourceMappingURL=node-filesystem-7YZR3POJ.js.map

package/node-filesystem-7YZR3POJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/runtime/gateways/file/node-filesystem.ts"],"sourcesContent":["import type { PathLike, MakeDirectoryOptions, Stats, ObjectEncodingOptions } from \"node:fs\";\nimport type { mkdir, readdir, rm, copyFile, readFile, stat, unlink, writeFile } from \"node:fs/promises\";\nimport { toArrayBuffer } from \"./utils.js\";\nimport { SysFileSystem } from \"../../../types.js\";\nimport { runtimeFn } from \"@adviser/cement\";\n\nexport class NodeFileSystem implements SysFileSystem {\n  fs?: {\n    mkdir: typeof mkdir;\n    readdir: typeof readdir;\n    rm: typeof rm;\n    copyFile: typeof copyFile;\n    readFile: typeof readFile;\n    stat: typeof stat;\n    unlink: typeof unlink;\n    writeFile: typeof writeFile;\n  };\n\n  async start(): Promise<SysFileSystem> {\n    this.fs = await import(\"node:fs/promises\");\n    return this;\n  }\n  async mkdir(path: PathLike, options?: { recursive: boolean }): Promise<string | undefined> {\n    return this.fs?.mkdir(path, options);\n  }\n  async readdir(path: PathLike, options?: ObjectEncodingOptions): Promise<string[]> {\n    return this.fs?.readdir(path, options) as Promise<string[]>;\n  }\n  async rm(path: PathLike, options?: MakeDirectoryOptions & { recursive: boolean }): Promise<void> {\n    return this.fs?.rm(path, options);\n  }\n  async copyFile(source: PathLike, destination: PathLike): Promise<void> {\n    return this.fs?.copyFile(source, destination);\n  }\n  async readfile(path: PathLike, options?: { encoding: BufferEncoding; flag?: string }): Promise<Uint8Array> {\n    const ret = (await this.fs?.readFile(path, options)) as Buffer;\n    return toArrayBuffer(ret);\n  }\n  stat(path: PathLike): Promise<Stats> {\n    return this.fs?.stat(path) as Promise<Stats>;\n  }\n  async unlink(path: PathLike): Promise<void> {\n    return this.fs?.unlink(path);\n  }\n  async writefile(path: PathLike, data: Uint8Array | string): Promise<void> {\n    if (runtimeFn().isDeno) {\n      return this.fs?.writeFile(path, data);\n    }\n    return this.fs?.writeFile(path, Buffer.from(data));\n  }\n}\n\n// import { type NodeMap, join } from \"../../sys-container.js\";\n// import type { ObjectEncodingOptions, PathLike } from \"fs\";\n// import * as fs from \"fs/promises\";\n// import * as path from \"path\";\n// import * as os from \"os\";\n// import * as url from \"url\";\n// import { toArrayBuffer } from \"./utils.js\";\n\n// export async function createNodeSysContainer(): Promise<NodeMap> {\n//   // const nodePath = \"node:path\";\n//   // const nodeOS = \"node:os\";\n//   // const nodeURL = \"node:url\";\n//   // const nodeFS = \"node:fs\";\n//   // const fs = (await import(\"node:fs\")).promises;\n//   // const assert = \"assert\";\n//   // const path = await import(\"node:path\");\n//   return {\n//     state: \"node\",\n//     ...path,\n//     // ...(await import(\"node:os\")),\n//     // ...(await import(\"node:url\")),\n//     ...os,\n//     ...url,\n//     ...fs,\n//     join,\n//     stat: fs.stat as NodeMap[\"stat\"],\n//     readdir: fs.readdir as NodeMap[\"readdir\"],\n//     readfile: async (path: PathLike, options?: ObjectEncodingOptions): Promise<Uint8Array> => {\n//       const rs = await fs.readFile(path, options);\n//       return toArrayBuffer(rs);\n//     },\n//     writefile: fs.writeFile as NodeMap[\"writefile\"],\n//   };\n// }\n"],"mappings":";;;;;;AAIA,SAAS,iBAAiB;AAEnB,IAAM,iBAAN,MAA8C;AAAA,EAYnD,MAAM,QAAgC;AACpC,SAAK,KAAK,MAAM,OAAO,kBAAkB;AACzC,WAAO;AAAA,EACT;AAAA,EACA,MAAM,MAAM,MAAgB,SAA+D;AACzF,WAAO,KAAK,IAAI,MAAM,MAAM,OAAO;AAAA,EACrC;AAAA,EACA,MAAM,QAAQ,MAAgB,SAAoD;AAChF,WAAO,KAAK,IAAI,QAAQ,MAAM,OAAO;AAAA,EACvC;AAAA,EACA,MAAM,GAAG,MAAgB,SAAwE;AAC/F,WAAO,KAAK,IAAI,GAAG,MAAM,OAAO;AAAA,EAClC;AAAA,EACA,MAAM,SAAS,QAAkB,aAAsC;AACrE,WAAO,KAAK,IAAI,SAAS,QAAQ,WAAW;AAAA,EAC9C;AAAA,EACA,MAAM,SAAS,MAAgB,SAA4E;AACzG,UAAM,MAAO,MAAM,KAAK,IAAI,SAAS,MAAM,OAAO;AAClD,WAAO,cAAc,GAAG;AAAA,EAC1B;AAAA,EACA,KAAK,MAAgC;AACnC,WAAO,KAAK,IAAI,KAAK,IAAI;AAAA,EAC3B;AAAA,EACA,MAAM,OAAO,MAA+B;AAC1C,WAAO,KAAK,IAAI,OAAO,IAAI;AAAA,EAC7B;AAAA,EACA,MAAM,UAAU,MAAgB,MAA0C;AACxE,QAAI,UAAU,EAAE,QAAQ;AACtB,aAAO,KAAK,IAAI,UAAU,MAAM,IAAI;AAAA,IACtC;AACA,WAAO,KAAK,IAAI,UAAU,MAAM,OAAO,KAAK,IAAI,CAAC;AAAA,EACnD;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireproof/core",
-  "version": "0.19.9-dev-frag",
+  "version": "0.19.11-dev-dryrun",
   "description": "Live database for the web.",
   "type": "module",
   "module": "./index.js",
@@ -46,16 +46,19 @@
     "react": ">=18.0.0"
   },
   "dependencies": {
-    "@adviser/cement": "^0.2.22",
+    "@adviser/cement": "^0.2.31",
+    "multiformats": "^13.3.0",
     "@ipld/unixfs": "^3.0.0",
     "@ipld/car": "^5.3.2",
+    "@ipld/dag-json": "^10.2.2",
+    "@ipld/dag-cbor": "^9.2.1",
     "@web3-storage/pail": "^0.6.0",
-    "cborg": "^4.2.3",
+    "cborg": "^4.2.4",
     "charwise": "^3.0.1",
     "prolly-trees": "^1.0.4",
     "idb": "^8.0.0",
-    "ipfs-unixfs-exporter": "^13.5.0",
-    "memfs": "^4.11.0",
+    "ipfs-unixfs-exporter": "^13.6.1",
+    "memfs": "^4.12.0",
     "p-limit": "^6.1.0",
     "react": "^18.3.1"
   },

package/tests/blockstore/keyed-crypto.test.ts

@@ -3,12 +3,14 @@ import { BuildURI, Logger, MockLogger, runtimeFn, toCryptoRuntime, URI } from "@
 import { base58btc } from "multiformats/bases/base58";
 import { sha256 as hasher } from "multiformats/hashes/sha2";
 import * as dagCodec from "@ipld/dag-cbor";
-import { mockSuperThis } from "../helpers";
+import { MockSuperThis, mockSuperThis } from "../helpers";
 
 describe("KeyBag", () => {
   let url: URI;
-  const sthis = mockSuperThis();
-  beforeAll(async () => {
+  let sthis: MockSuperThis;
+
+  beforeEach(async () => {
+    sthis = mockSuperThis();
     await sthis.start();
     if (runtimeFn().isBrowser) {
       url = URI.from("indexdb://fp-keybag");
@@ -34,6 +36,33 @@ describe("KeyBag", () => {
     expect(kb.rt.url.toString()).toBe(url.toString());
     sthis.env.set("FP_KEYBAG_URL", old);
   });
+
+  it("extract keyMaterial", async () => {
+    const dkb = await rt.kb.getKeyBag(sthis);
+    const old = sthis.env.get("FP_KEYBAG_URL");
+    sthis.env.set("FP_KEYBAG_URL", BuildURI.from(dkb.rt.url).setParam("extractKey", "_deprecated_internal_api").toString());
+    const kb = await rt.kb.getKeyBag(sthis);
+    const key = kb.rt.crypto.randomBytes(kb.rt.keyLength);
+    const keyStr = base58btc.encode(key);
+    const res = await kb.setNamedKey("extract.test", keyStr);
+    expect(res.isOk()).toBeTruthy();
+    const gkb = await kb.getNamedExtractableKey("extract.test", true);
+    expect(gkb.isOk()).toBeTruthy();
+    expect(await gkb.Ok().extract()).toEqual({
+      key,
+      keyStr,
+    });
+    sthis.env.set("FP_KEYBAG_URL", old);
+    await sthis.logger.Flush();
+    expect(sthis.logCollector.Logs()).toEqual([
+      {
+        level: "warn",
+        module: "KeyBag",
+        msg: "extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!",
+      },
+    ]);
+  });
+
   it("simple add", async () => {
     const kb = await rt.kb.getKeyBag(sthis, {
       url: url.toString(),
@@ -105,7 +134,8 @@ describe("KeyedCryptoStore", () => {
       baseUrl = URI.from("indexdb://fp-keyed-crypto-store");
     } else {
       kbUrl = URI.merge(`file://./dist/tests/key.bag`, sthis.env.get("FP_KEYBAG_URL"));
-      baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
+      // baseUrl = URI.merge("file://./dist/tests/keyed-crypto-store", sthis.env.get("FP_STORAGE_URL"));
+      baseUrl = URI.from(sthis.env.get("FP_STORAGE_URL"));
     }
     kb = await rt.kb.getKeyBag(sthis, {
       url: kbUrl,

package/tests/blockstore/store.test.ts

@@ -88,9 +88,8 @@ describe("DataStore with a saved car", function () {
 
   it("should remove a car", async function () {
     await store.remove(car.cid);
-    const error = (await store.load(car.cid).catch((e: Error) => e)) as NotFoundError;
-    expect(error.code).toMatch("ENOENT");
-    // matches(error.message, "ENOENT");
+    const { e: error } = (await store.load(car.cid).catch((e: Error) => ({ e }))) as { e: NotFoundError };
+    expect(error).toBeTruthy();
   });
 });
 
@@ -124,10 +123,11 @@ describe("MetaStore", function () {
     };
     await store.save(h);
     const file = await raw.get(store.url(), "main");
-    const header = JSON.parse(decoder.decode(file));
-    expect(header).toBeTruthy();
-    expect(header.cars).toBeTruthy();
-    expect(header.cars[0]["/"]).toEqual(cid.toString());
+    const [blockMeta] = await store.handleByteHeads(file);
+    const decodedHeader = blockMeta.dbMeta;
+    expect(decodedHeader).toBeTruthy();
+    expect(decodedHeader.cars).toBeTruthy();
+    expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
   });
 });
 
@@ -152,12 +152,17 @@ describe("MetaStore with a saved header", function () {
   });
 
   it("should have a header", async function () {
-    const data = decoder.decode(await raw.get(store.url(), "main"));
-    expect(data).toMatch(/car/);
-    const header = JSON.parse(data);
-    expect(header).toBeTruthy();
-    expect(header.cars).toBeTruthy();
-    expect(header.cars[0]["/"]).toEqual(cid.toString());
+    const bytes = await raw.get(store.url(), "main");
+    const data = decoder.decode(bytes);
+    expect(data).toMatch(/parents/);
+    const header = JSON.parse(data)[0];
+    expect(header).toBeDefined();
+    expect(header.parents).toBeDefined();
+    const [blockMeta] = await store.handleByteHeads(bytes);
+    const decodedHeader = blockMeta.dbMeta;
+    expect(decodedHeader).toBeDefined();
+    expect(decodedHeader.cars).toBeDefined();
+    expect(decodedHeader.cars[0].toString()).toEqual(cid.toString());
   });
 
   it("should load a header", async function () {

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

@@ -0,0 +1,395 @@
+import { Database, bs } from "@fireproof/core";
+import { URI } from "@adviser/cement";
+
+// @ts-expect-error - This import has no type definitions
+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;
+}
+
+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;
+
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+
+    // 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;
+
+    // Extract and log gateways
+    carGateway = carStore?.gateway;
+    metaGateway = metaStore?.gateway;
+    fileGateway = fileStore?.gateway;
+    walGateway = walStore?.gateway;
+  });
+
+  it("should have valid stores and gateways", async function () {
+    // Add assertions
+    expect(carStore).toBeTruthy();
+    expect(metaStore).toBeTruthy();
+    expect(fileStore).toBeTruthy();
+    expect(walStore).toBeTruthy();
+
+    expect(carGateway).toBeTruthy();
+    expect(metaGateway).toBeTruthy();
+    expect(fileGateway).toBeTruthy();
+    expect(walGateway).toBeTruthy();
+  });
+
+  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");
+  });
+
+  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");
+  });
+
+  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=");
+  });
+
+  it("should have correct gateway types", async function () {
+    // Check that all gateways are instances of the expected gateway class
+    expect(typeof carGateway).toBe("object");
+    expect(typeof metaGateway).toBe("object");
+    expect(typeof fileGateway).toBe("object");
+    expect(typeof walGateway).toBe("object");
+  });
+
+  it("should build CAR Gateway URL", async function () {
+    const testKey = "bafkreidxwt2nhvbl4fnqfw3ctlt6zbrir4kqwmjo5im6rf4q5si27kgo2i";
+    const carUrl = await carGateway?.buildUrl(carStore?._url, testKey);
+    expect(carUrl?.Ok()).toBeTruthy();
+  });
+
+  it("should start CAR Gateway", async function () {
+    await carGateway?.start(carStore?._url);
+  });
+
+  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();
+  });
+
+  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");
+  });
+
+  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();
+  });
+
+  it("should close CAR Gateway", async function () {
+    await carGateway?.close(carStore?._url);
+  });
+  it("should build Meta Gateway URL", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    expect(metaUrl?.Ok()).toBeTruthy();
+  });
+
+  it("should start Meta Gateway", async function () {
+    await metaGateway?.start(metaStore?._url);
+  });
+
+  it("should close Meta Gateway", async function () {
+    await metaGateway?.start(metaStore?._url);
+    await metaGateway?.close(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();
+  });
+
+  it("should start File Gateway", async function () {
+    await fileGateway?.start(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();
+  });
+
+  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");
+  });
+
+  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();
+  });
+
+  it("should close File Gateway", async function () {
+    await fileGateway?.close(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();
+  });
+
+  it("should start WAL Gateway", async function () {
+    await walGateway?.start(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 walEncoder = new TextEncoder();
+    const walTestData = walEncoder.encode(walTestDataString);
+    const walPutResult = await walGateway?.put(walUrl?.Ok(), walTestData);
+    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 walEncoder = new TextEncoder();
+    const walTestData = walEncoder.encode(walTestDataString);
+    await walGateway?.put(walUrl?.Ok(), walTestData);
+    const walGetResult = await walGateway?.get(walUrl?.Ok());
+    const okResult = walGetResult?.Ok();
+    const decodedResult = new TextDecoder().decode(okResult);
+    expect(decodedResult).toEqual(walTestDataString);
+  });
+
+  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 walEncoder = new TextEncoder();
+    const walTestData = walEncoder.encode(walTestDataString);
+    await walGateway?.put(walUrl?.Ok(), walTestData);
+    const walDeleteResult = await walGateway?.delete(walUrl?.Ok());
+    expect(walDeleteResult?.Ok()).toBeFalsy();
+  });
+
+  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");
+  });
+});
+
+describe("noop Gateway subscribe", function () {
+  let db: Database;
+
+  let metaStore: ExtendedStore;
+
+  let metaGateway: ExtendedGateway;
+
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+
+    // Extract stores from the loader
+    metaStore = (await db.blockstore.loader?.metaStore()) as unknown as ExtendedStore;
+
+    metaGateway = metaStore?.gateway;
+  });
+  it("should subscribe to meta Gateway", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    await metaGateway?.start(metaStore?._url);
+
+    if (metaGateway.subscribe) {
+      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 = new TextDecoder().decode(data);
+        expect(decodedData).toContain("[]");
+        didCall = true;
+        resolve();
+      });
+      expect(metaSubscribeResult?.Ok()).toBeTruthy();
+      const ok = await db.put({ _id: "key1", hello: "world1" });
+      expect(ok).toBeTruthy();
+      expect(ok.id).toBe("key1");
+      await p;
+      expect(didCall).toBeTruthy();
+    }
+  });
+});
+
+describe("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;
+
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    db = new Database("test-gateway-" + Math.random().toString(36).substring(7));
+    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;
+
+    // Extract and log gateways
+    // carGateway = carStore?.gateway;
+    metaGateway = metaStore?.gateway;
+    // 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 = new TextDecoder().decode(metaGetResultOk);
+    expect(decodedMetaGetResultOk).toContain("parents");
+  });
+
+  it("should delete data from Meta Gateway", async function () {
+    const metaUrl = await metaGateway?.buildUrl(metaStore?._url, "main");
+    await metaGateway?.start(metaStore?._url);
+    // should we be testing .destroy() instead?
+    const metaDeleteResult = await metaGateway?.delete(metaUrl?.Ok());
+    expect(metaDeleteResult?.Ok()).toBeFalsy();
+  });
+});