@reventlessdev/reventless-local 3.0.0-alpha.199 → 3.0.0-alpha.201

package/tests/adapter/GraphQL_SubscriptionResolversTest.res.mjs

@@ -3,6 +3,7 @@
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as LocalStateChangeDescriptor$ReventlessLocal from "../../src/adapter/LocalStateChangeDescriptor.res.mjs";
 import * as LocalGraphQL_SubscriptionResolvers$ReventlessLocal from "../../src/adapter/Api/LocalGraphQL_SubscriptionResolvers.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
@@ -68,7 +69,7 @@ globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
           "2026-05-19T12:00:00Z"
         ]
       ]);
-      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", "prod-1", state);
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "prod-1", state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
       TestBus.publishStateChange("Product", descriptor);
       let received = await consumerPromise;
       if (received !== null) {
@@ -84,10 +85,10 @@ globalThis.describe("LocalGraphQL_SubscriptionResolvers", () => {
       let iter = ps.subscribe("onCatalogProduct_stateChanged");
       let consumerPromise = startConsumer(iter, 300);
       await yieldTick();
-      let foreignDescriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", "cat-1", Object.fromEntries([[
+      let foreignDescriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Updated", "cat-1", Object.fromEntries([[
           "id",
           "cat-1"
-        ]]));
+        ]]), LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
       TestBus.publishStateChange("Category", foreignDescriptor);
       let received = await consumerPromise;
       globalThis.expect(received === null ? undefined : Primitive_option.some(received)).toEqual(undefined);

package/tests/adapter/ObjectStorePersistenceTest.res

@@ -0,0 +1,243 @@
+// The local object store follows the active backend's durability: with a
+// file-backed SQLite database the bytes land beside it on disk, so uploads and
+// offloaded payloads survive the restart that their events survive; with Memory
+// they stay in-process.
+
+@@warning("-44")
+
+open JestGlobals
+
+let tempRoot = (): string =>
+  NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-objectstore-"]))
+
+let bytes = NodeBuffer.fromStringUtf8
+
+describe("ObjectStoreStorage_FileSystem", () => {
+  testSync("put then get round-trips the bytes and the content type", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("<svg/>"),
+      ~contentType="image/svg+xml",
+    )
+    expect(
+      ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/logo.svg")->Option.map(
+        ((got, contentType)) => (got->NodeBuffer.toStringUtf8, contentType),
+      ),
+    )->toEqual(Some(("<svg/>", "image/svg+xml")))
+  })
+
+  testSync("the key's slashes become directories under objects/", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    expect(
+      NodeFs.existsSync(NodePath.join([root, "objects", "uploads", "abc", "logo.svg"])),
+    )->toEqual(true)
+  })
+
+  testSync("get returns None for a missing key", () => {
+    let root = tempRoot()
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/none/x.svg"))->toEqual(None)
+  })
+
+  testSync("get returns None for a key naming a directory rather than an object", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc"))->toEqual(None)
+  })
+
+  testSync("delete removes the object, its content type, and the directory it emptied", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    ObjectStoreStorage_FileSystem.delete(~root, ~key="uploads/abc/logo.svg")
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/logo.svg"))->toEqual(None)
+    expect(NodeFs.existsSync(NodePath.join([root, "objects", "uploads", "abc"])))->toEqual(false)
+    expect(NodeFs.existsSync(NodePath.join([root, "object-meta", "uploads", "abc"])))->toEqual(
+      false,
+    )
+  })
+
+  testSync("delete of an absent key is a no-op", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.delete(~root, ~key="uploads/abc/gone.svg")
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/gone.svg"))->toEqual(None)
+  })
+
+  testSync("offload payloads round-trip in their own keyspace", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.putOffload(~root, ~key="sha256/deadbeef", ~bytes=`{"a":1}`)
+    expect(ObjectStoreStorage_FileSystem.getOffload(~root, ~key="sha256/deadbeef"))->toEqual(
+      Some(`{"a":1}`),
+    )
+    // Not reachable as a served object — the two trees are separate.
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="sha256/deadbeef"))->toEqual(None)
+  })
+
+  testSync("a traversing key is refused rather than written outside the root", () => {
+    let root = tempRoot()
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/../../escaped.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    // `objects/uploads/../../escaped.svg` resolves to `<root>/escaped.svg`.
+    expect(NodeFs.existsSync(NodePath.join([root, "escaped.svg"])))->toEqual(false)
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/../../escaped.svg"))->toEqual(
+      None,
+    )
+  })
+
+  testSync("reset clears the store's trees and leaves the rest of the root alone", () => {
+    let root = tempRoot()
+    NodeFs.writeFileSync(NodePath.join([root, "local.db"]), "not a real database")
+    ObjectStoreStorage_FileSystem.put(
+      ~root,
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("x"),
+      ~contentType="image/svg+xml",
+    )
+    ObjectStoreStorage_FileSystem.putOffload(~root, ~key="sha256/deadbeef", ~bytes="{}")
+
+    ObjectStoreStorage_FileSystem.reset(~root)
+
+    expect(ObjectStoreStorage_FileSystem.get(~root, ~key="uploads/abc/logo.svg"))->toEqual(None)
+    expect(ObjectStoreStorage_FileSystem.getOffload(~root, ~key="sha256/deadbeef"))->toEqual(None)
+    expect(NodeFs.existsSync(NodePath.join([root, "local.db"])))->toEqual(true)
+  })
+})
+
+describe("LocalObjectStore backend dispatch", () => {
+  // Restore the module-global backend so a later assertion in this file (and the
+  // suite's own default) sees Memory rather than whichever db a test opened.
+  afterEach(() => BackendState.setMemory())
+
+  testSync("a file-backed SQLite backend puts the bytes on disk beside the database", () => {
+    let root = tempRoot()
+    let path = NodePath.join([root, "local.db"])
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path), ~path)
+
+    LocalObjectStore.put(~key="uploads/abc/logo.svg", ~bytes=bytes("x"), ~contentType="image/png")
+
+    expect(
+      NodeFs.existsSync(NodePath.join([root, "objects", "uploads", "abc", "logo.svg"])),
+    )->toEqual(true)
+    expect(
+      LocalObjectStore.get(~key="uploads/abc/logo.svg")->Option.map(e => e.contentType),
+    )->toEqual(Some("image/png"))
+  })
+
+  testSync("an object stored on disk outlives the process that stored it", () => {
+    let root = tempRoot()
+    let path = NodePath.join([root, "local.db"])
+
+    // First "process": store, then drop every trace of it from memory.
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path), ~path)
+    LocalObjectStore.put(
+      ~key="uploads/abc/logo.svg",
+      ~bytes=bytes("kept"),
+      ~contentType="image/png",
+    )
+    LocalObjectStore.putOffload(~key="sha256/cafe", ~bytes=`{"structure":true}`)
+    BackendState.setMemory()
+    ObjectStoreStorage_InMemory.reset()
+
+    // Second "process": same database file, same directory.
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path), ~path)
+    expect(
+      LocalObjectStore.get(~key="uploads/abc/logo.svg")->Option.map(e => e.contentType),
+    )->toEqual(Some("image/png"))
+    expect(LocalObjectStore.getOffload(~key="sha256/cafe"))->toEqual(Some(`{"structure":true}`))
+  })
+
+  testSync("a `:memory:` SQLite backend keeps objects in process, writing nothing", () => {
+    BackendState.setSqlite(~db=SqliteDriver.openDb(~path=":memory:"), ~path=":memory:")
+    expect(BackendState.getObjectStoreRoot())->toEqual(None)
+
+    LocalObjectStore.put(~key="uploads/abc/logo.svg", ~bytes=bytes("x"), ~contentType="image/png")
+    expect(LocalObjectStore.get(~key="uploads/abc/logo.svg")->Option.isSome)->toEqual(true)
+  })
+
+  testSync("the Memory backend keeps objects in process", () => {
+    BackendState.setMemory()
+    expect(BackendState.getObjectStoreRoot())->toEqual(None)
+
+    LocalObjectStore.put(~key="uploads/abc/mem.svg", ~bytes=bytes("x"), ~contentType="image/png")
+    expect(LocalObjectStore.get(~key="uploads/abc/mem.svg")->Option.isSome)->toEqual(true)
+    LocalObjectStore.delete(~key="uploads/abc/mem.svg")
+    expect(LocalObjectStore.get(~key="uploads/abc/mem.svg"))->toEqual(None)
+  })
+
+  testSync("servedKey refuses a path that would climb out of the store", () => {
+    expect(LocalObjectStore.servedKey("/uploads/../../etc/passwd"))->toEqual(None)
+    expect(LocalObjectStore.servedKey("/uploads/abc/logo.svg"))->toEqual(
+      Some("uploads/abc/logo.svg"),
+    )
+  })
+})
+
+describe("declared store prefixes", () => {
+  afterEach(() => LocalObjectStore.reset())
+
+  testSync("a declared store mints under uploads/{plugin}/{store}", () => {
+    LocalObjectStore.registerStore(
+      ~qualified="Catalog.productImages",
+      ~prefix=LocalObjectStore.localPrefixFor(~qualified="Catalog.productImages"),
+    )
+    let ref = LocalUploadResolvers.mintRef(~store="Catalog.productImages", ~fileName="logo.svg")
+    expect(ref->String.startsWith("/uploads/Catalog/productImages/"))->toEqual(true)
+    expect(ref->String.endsWith("/logo.svg"))->toEqual(true)
+  })
+
+  testSync("an undeclared store falls back to the shared uploads prefix", () => {
+    let ref = LocalUploadResolvers.mintRef(~store="Nobody.knows", ~fileName="logo.svg")
+    expect(ref->String.startsWith("/uploads/"))->toEqual(true)
+  })
+
+  testSync("a store's objects stay under the served uploads prefix", () => {
+    LocalObjectStore.registerStore(
+      ~qualified="Catalog.productImages",
+      ~prefix="uploads/Catalog/productImages",
+    )
+    expect(LocalObjectStore.servedKey("/uploads/Catalog/productImages/abc/logo.svg"))->toEqual(
+      Some("uploads/Catalog/productImages/abc/logo.svg"),
+    )
+    // Nesting the store under `uploads/` is what keeps a UI dev server's single
+    // `/uploads` proxy hop enough to reach it — a sibling top-level prefix would
+    // resolve against the UI server instead of the platform.
+    expect(LocalObjectStore.servedKey("/Catalog/productImages/abc/logo.svg"))->toEqual(None)
+    expect(LocalObjectStore.servedKey("/Ordering/invoices/abc/x.pdf"))->toEqual(None)
+  })
+
+  testSync("two plugins declaring the same store name stay apart", () => {
+    ["Catalog.images", "Ordering.images"]->Array.forEach(
+      q =>
+        LocalObjectStore.registerStore(
+          ~qualified=q,
+          ~prefix=LocalObjectStore.localPrefixFor(~qualified=q),
+        ),
+    )
+    expect(LocalObjectStore.storePrefix(~qualified="Catalog.images"))->toEqual(
+      Some("uploads/Catalog/images"),
+    )
+    expect(LocalObjectStore.storePrefix(~qualified="Ordering.images"))->toEqual(
+      Some("uploads/Ordering/images"),
+    )
+  })
+})

package/tests/adapter/ObjectStorePersistenceTest.res.mjs

@@ -0,0 +1,159 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as BackendState$ReventlessLocal from "../../src/adapter/BackendState.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as LocalObjectStore$ReventlessLocal from "../../src/adapter/ObjectStore/LocalObjectStore.res.mjs";
+import * as LocalUploadResolvers$ReventlessLocal from "../../src/adapter/LocalUploadResolvers.res.mjs";
+import * as ObjectStoreStorage_InMemory$ReventlessLocal from "../../src/adapter/ObjectStore/ObjectStoreStorage_InMemory.res.mjs";
+import * as ObjectStoreStorage_FileSystem$ReventlessLocal from "../../src/adapter/ObjectStore/ObjectStoreStorage_FileSystem.res.mjs";
+
+function tempRoot() {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-objectstore-"));
+}
+
+function bytes(prim) {
+  return Buffer.from(prim, "utf8");
+}
+
+globalThis.describe("ObjectStoreStorage_FileSystem", () => {
+  globalThis.test("put then get round-trips the bytes and the content type", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("<svg/>", "utf8"), "image/svg+xml");
+    globalThis.expect(Stdlib_Option.map(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/logo.svg"), param => [
+      param[0].toString("utf8"),
+      param[1]
+    ])).toEqual([
+      "<svg/>",
+      "image/svg+xml"
+    ]);
+  });
+  globalThis.test("the key's slashes become directories under objects/", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "objects", "uploads", "abc", "logo.svg"))).toEqual(true);
+  });
+  globalThis.test("get returns None for a missing key", () => {
+    let root = tempRoot();
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/none/x.svg")).toEqual(undefined);
+  });
+  globalThis.test("get returns None for a key naming a directory rather than an object", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc")).toEqual(undefined);
+  });
+  globalThis.test("delete removes the object, its content type, and the directory it emptied", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.$$delete(root, "uploads/abc/logo.svg");
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/logo.svg")).toEqual(undefined);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "objects", "uploads", "abc"))).toEqual(false);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "object-meta", "uploads", "abc"))).toEqual(false);
+  });
+  globalThis.test("delete of an absent key is a no-op", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.$$delete(root, "uploads/abc/gone.svg");
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/gone.svg")).toEqual(undefined);
+  });
+  globalThis.test("offload payloads round-trip in their own keyspace", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.putOffload(root, "sha256/deadbeef", `{"a":1}`);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.getOffload(root, "sha256/deadbeef")).toEqual(`{"a":1}`);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "sha256/deadbeef")).toEqual(undefined);
+  });
+  globalThis.test("a traversing key is refused rather than written outside the root", () => {
+    let root = tempRoot();
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/../../escaped.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "escaped.svg"))).toEqual(false);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/../../escaped.svg")).toEqual(undefined);
+  });
+  globalThis.test("reset clears the store's trees and leaves the rest of the root alone", () => {
+    let root = tempRoot();
+    Nodefs.writeFileSync(Nodepath.join(root, "local.db"), "not a real database", "utf8");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.put(root, "uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/svg+xml");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.putOffload(root, "sha256/deadbeef", "{}");
+    ObjectStoreStorage_FileSystem$ReventlessLocal.reset(root);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.get(root, "uploads/abc/logo.svg")).toEqual(undefined);
+    globalThis.expect(ObjectStoreStorage_FileSystem$ReventlessLocal.getOffload(root, "sha256/deadbeef")).toEqual(undefined);
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "local.db"))).toEqual(true);
+  });
+});
+
+globalThis.describe("LocalObjectStore backend dispatch", () => {
+  globalThis.afterEach(() => BackendState$ReventlessLocal.setMemory());
+  globalThis.test("a file-backed SQLite backend puts the bytes on disk beside the database", () => {
+    let root = tempRoot();
+    let path = Nodepath.join(root, "local.db");
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(path), path);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/png");
+    globalThis.expect(Nodefs.existsSync(Nodepath.join(root, "objects", "uploads", "abc", "logo.svg"))).toEqual(true);
+    globalThis.expect(Stdlib_Option.map(LocalObjectStore$ReventlessLocal.get("uploads/abc/logo.svg"), e => e.contentType)).toEqual("image/png");
+  });
+  globalThis.test("an object stored on disk outlives the process that stored it", () => {
+    let root = tempRoot();
+    let path = Nodepath.join(root, "local.db");
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(path), path);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/logo.svg", Buffer.from("kept", "utf8"), "image/png");
+    LocalObjectStore$ReventlessLocal.putOffload("sha256/cafe", `{"structure":true}`);
+    BackendState$ReventlessLocal.setMemory();
+    ObjectStoreStorage_InMemory$ReventlessLocal.reset();
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(path), path);
+    globalThis.expect(Stdlib_Option.map(LocalObjectStore$ReventlessLocal.get("uploads/abc/logo.svg"), e => e.contentType)).toEqual("image/png");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.getOffload("sha256/cafe")).toEqual(`{"structure":true}`);
+  });
+  globalThis.test("a `:memory:` SQLite backend keeps objects in process, writing nothing", () => {
+    BackendState$ReventlessLocal.setSqlite(SqliteDriver$ReventlessLocal.openDb(":memory:"), ":memory:");
+    globalThis.expect(BackendState$ReventlessLocal.getObjectStoreRoot()).toEqual(undefined);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/logo.svg", Buffer.from("x", "utf8"), "image/png");
+    globalThis.expect(Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.get("uploads/abc/logo.svg"))).toEqual(true);
+  });
+  globalThis.test("the Memory backend keeps objects in process", () => {
+    BackendState$ReventlessLocal.setMemory();
+    globalThis.expect(BackendState$ReventlessLocal.getObjectStoreRoot()).toEqual(undefined);
+    LocalObjectStore$ReventlessLocal.put("uploads/abc/mem.svg", Buffer.from("x", "utf8"), "image/png");
+    globalThis.expect(Stdlib_Option.isSome(LocalObjectStore$ReventlessLocal.get("uploads/abc/mem.svg"))).toEqual(true);
+    LocalObjectStore$ReventlessLocal.$$delete("uploads/abc/mem.svg");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.get("uploads/abc/mem.svg")).toEqual(undefined);
+  });
+  globalThis.test("servedKey refuses a path that would climb out of the store", () => {
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/uploads/../../etc/passwd")).toEqual(undefined);
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/uploads/abc/logo.svg")).toEqual("uploads/abc/logo.svg");
+  });
+});
+
+globalThis.describe("declared store prefixes", () => {
+  globalThis.afterEach(() => LocalObjectStore$ReventlessLocal.reset());
+  globalThis.test("a declared store mints under uploads/{plugin}/{store}", () => {
+    LocalObjectStore$ReventlessLocal.registerStore("Catalog.productImages", LocalObjectStore$ReventlessLocal.localPrefixFor("Catalog.productImages"));
+    let ref = LocalUploadResolvers$ReventlessLocal.mintRef("Catalog.productImages", "logo.svg");
+    globalThis.expect(ref.startsWith("/uploads/Catalog/productImages/")).toEqual(true);
+    globalThis.expect(ref.endsWith("/logo.svg")).toEqual(true);
+  });
+  globalThis.test("an undeclared store falls back to the shared uploads prefix", () => {
+    let ref = LocalUploadResolvers$ReventlessLocal.mintRef("Nobody.knows", "logo.svg");
+    globalThis.expect(ref.startsWith("/uploads/")).toEqual(true);
+  });
+  globalThis.test("a store's objects stay under the served uploads prefix", () => {
+    LocalObjectStore$ReventlessLocal.registerStore("Catalog.productImages", "uploads/Catalog/productImages");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/uploads/Catalog/productImages/abc/logo.svg")).toEqual("uploads/Catalog/productImages/abc/logo.svg");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/Catalog/productImages/abc/logo.svg")).toEqual(undefined);
+    globalThis.expect(LocalObjectStore$ReventlessLocal.servedKey("/Ordering/invoices/abc/x.pdf")).toEqual(undefined);
+  });
+  globalThis.test("two plugins declaring the same store name stay apart", () => {
+    [
+      "Catalog.images",
+      "Ordering.images"
+    ].forEach(q => LocalObjectStore$ReventlessLocal.registerStore(q, LocalObjectStore$ReventlessLocal.localPrefixFor(q)));
+    globalThis.expect(LocalObjectStore$ReventlessLocal.storePrefix("Catalog.images")).toEqual("uploads/Catalog/images");
+    globalThis.expect(LocalObjectStore$ReventlessLocal.storePrefix("Ordering.images")).toEqual("uploads/Ordering/images");
+  });
+});
+
+export {
+  tempRoot,
+  bytes,
+}
+/*  Not a pure module */