@reventlessdev/reventless-core 3.0.0-alpha.223 → 3.0.0-alpha.225

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -23,7 +23,9 @@ let cmd = {
   references: cmd_references,
   allowedStates: undefined,
   targetState: undefined,
-  apiExposed: cmd_apiExposed
+  apiExposed: cmd_apiExposed,
+  requiredAccess: undefined,
+  ownerField: undefined
 };
 
 let qbl_consumedEventTypes = ["ProductAdded"];
@@ -34,6 +36,12 @@ let qbl_searchableFields = ["displayName"];
 
 let qbl_labelFieldSource = "annotation";
 
+let qbl_singleQueryField = "Catalog_Product";
+
+let qbl_idField = "productId";
+
+let qbl_idFieldSource = "convention";
+
 let qbl = {
   name: "Products",
   queryField: "Catalog_Products",
@@ -44,8 +52,13 @@ let qbl = {
   searchableFields: qbl_searchableFields,
   labelFieldSource: qbl_labelFieldSource,
   statusField: undefined,
+  ownerField: undefined,
   visibility: undefined,
-  chapter: undefined
+  chapter: undefined,
+  singleQueryField: qbl_singleQueryField,
+  idField: qbl_idField,
+  idFieldSource: qbl_idFieldSource,
+  requiredAccess: undefined
 };
 
 let wbl_commands = [cmd];
@@ -257,6 +270,9 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
   let internalQbl_searchableFields = ["name"];
   let internalQbl_labelFieldSource = "convention";
   let internalQbl_visibility = "Internal";
+  let internalQbl_singleQueryField = "Ordering_AvailableProduct";
+  let internalQbl_idField = "productId";
+  let internalQbl_idFieldSource = "sole";
   let internalQbl = {
     name: "AvailableProducts",
     queryField: "Ordering_AvailableProducts",
@@ -267,14 +283,22 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     searchableFields: internalQbl_searchableFields,
     labelFieldSource: internalQbl_labelFieldSource,
     statusField: undefined,
+    ownerField: undefined,
     visibility: internalQbl_visibility,
-    chapter: undefined
+    chapter: undefined,
+    singleQueryField: internalQbl_singleQueryField,
+    idField: internalQbl_idField,
+    idFieldSource: internalQbl_idFieldSource,
+    requiredAccess: undefined
   };
   let internalSlice_consumedEventTypes = internalQbl_consumedEventTypes;
   let internalSlice_linkedWriteSide = internalQbl_linkedWriteSide;
   let internalSlice_searchableFields = internalQbl_searchableFields;
   let internalSlice_labelFieldSource = "convention";
   let internalSlice_visibility = "Internal";
+  let internalSlice_singleQueryField = "Ordering_AvailableProduct";
+  let internalSlice_idField = "productId";
+  let internalSlice_idFieldSource = "sole";
   let internalSlice = {
     name: "PendingShipments",
     queryField: "Ordering_PendingShipments",
@@ -285,8 +309,13 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     searchableFields: internalSlice_searchableFields,
     labelFieldSource: internalSlice_labelFieldSource,
     statusField: undefined,
+    ownerField: undefined,
     visibility: internalSlice_visibility,
-    chapter: undefined
+    chapter: undefined,
+    singleQueryField: internalSlice_singleQueryField,
+    idField: internalSlice_idField,
+    idFieldSource: internalSlice_idFieldSource,
+    requiredAccess: undefined
   };
   let mixed_readModels = [
     qbl,
@@ -364,13 +393,16 @@ globalThis.describe("allowedStates + statusField populated", () => {
     references: cmdWithStates_references,
     allowedStates: cmdWithStates_allowedStates,
     targetState: cmdWithStates_targetState,
-    apiExposed: cmdWithStates_apiExposed
+    apiExposed: cmdWithStates_apiExposed,
+    requiredAccess: undefined,
+    ownerField: undefined
   };
   let qblWithStatus_consumedEventTypes = [];
   let qblWithStatus_linkedWriteSide = ["Plugin"];
   let qblWithStatus_searchableFields = ["name"];
   let qblWithStatus_labelFieldSource = "convention";
   let qblWithStatus_statusField = "status";
+  let qblWithStatus_singleQueryField = "Platform_Plugin";
   let qblWithStatus = {
     name: "Plugin",
     queryField: "Platform_Plugins",
@@ -381,8 +413,13 @@ globalThis.describe("allowedStates + statusField populated", () => {
     searchableFields: qblWithStatus_searchableFields,
     labelFieldSource: qblWithStatus_labelFieldSource,
     statusField: qblWithStatus_statusField,
+    ownerField: undefined,
     visibility: undefined,
-    chapter: undefined
+    chapter: undefined,
+    singleQueryField: qblWithStatus_singleQueryField,
+    idField: undefined,
+    idFieldSource: undefined,
+    requiredAccess: undefined
   };
   let wblWithStates_commands = [cmdWithStates];
   let wblWithStates_producedEventTypes = [];
@@ -438,6 +475,98 @@ globalThis.describe("allowedStates + statusField populated", () => {
   });
 });
 
+globalThis.describe("singleQueryField reaches the caller", () => {
+  globalThis.test("encodes the stated singular beside the list field", () => {
+    globalThis.expect(json.includes("\"queryField\":\"Catalog_Products\"")).toEqual(true);
+    globalThis.expect(json.includes("\"singleQueryField\":\"Catalog_Product\"")).toEqual(true);
+  });
+  globalThis.test("encodes an unstated singular as null", () => {
+    let unstated = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", {
+      readModels: [{
+          name: "Products",
+          queryField: "Catalog_Products",
+          schema: "{}",
+          consumedEventTypes: qbl_consumedEventTypes,
+          linkedWriteSide: qbl_linkedWriteSide,
+          labelField: "displayName",
+          searchableFields: qbl_searchableFields,
+          labelFieldSource: "annotation",
+          statusField: undefined,
+          ownerField: undefined,
+          visibility: undefined,
+          chapter: undefined,
+          singleQueryField: undefined,
+          idField: "productId",
+          idFieldSource: "convention",
+          requiredAccess: undefined
+        }],
+      stateViewSlices: structure_stateViewSlices,
+      stateChangeSlices: structure_stateChangeSlices,
+      aggregates: structure_aggregates,
+      automationSlices: structure_automationSlices,
+      outboundTranslationSlices: structure_outboundTranslationSlices,
+      inboundTranslationSlices: structure_inboundTranslationSlices,
+      extensions: structure_extensions,
+      extensionPoints: undefined,
+      requiredStores: undefined,
+      requiredStoreDeclarations: undefined
+    }));
+    globalThis.expect(unstated.includes("\"singleQueryField\":null")).toEqual(true);
+  });
+  globalThis.test("types it as a nullable String on the read-side SDL", () => {
+    let sdl = Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes.join("\n");
+    globalThis.expect(sdl.includes("singleQueryField: String\n")).toEqual(true);
+    globalThis.expect(sdl.includes("singleQueryField: String!")).toEqual(false);
+  });
+});
+
+globalThis.describe("idField / idFieldSource reach the caller", () => {
+  globalThis.test("encodes the key field and the rung that produced it", () => {
+    globalThis.expect(json.includes("\"idField\":\"productId\"")).toEqual(true);
+    globalThis.expect(json.includes("\"idFieldSource\":\"convention\"")).toEqual(true);
+  });
+  globalThis.test("encodes an unresolved key as null on both fields", () => {
+    let unresolved = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", {
+      readModels: [{
+          name: "Products",
+          queryField: "Catalog_Products",
+          schema: "{}",
+          consumedEventTypes: qbl_consumedEventTypes,
+          linkedWriteSide: qbl_linkedWriteSide,
+          labelField: "displayName",
+          searchableFields: qbl_searchableFields,
+          labelFieldSource: "annotation",
+          statusField: undefined,
+          ownerField: undefined,
+          visibility: undefined,
+          chapter: undefined,
+          singleQueryField: "Catalog_Product",
+          idField: undefined,
+          idFieldSource: undefined,
+          requiredAccess: undefined
+        }],
+      stateViewSlices: structure_stateViewSlices,
+      stateChangeSlices: structure_stateChangeSlices,
+      aggregates: structure_aggregates,
+      automationSlices: structure_automationSlices,
+      outboundTranslationSlices: structure_outboundTranslationSlices,
+      inboundTranslationSlices: structure_inboundTranslationSlices,
+      extensions: structure_extensions,
+      extensionPoints: undefined,
+      requiredStores: undefined,
+      requiredStoreDeclarations: undefined
+    }));
+    globalThis.expect(unresolved.includes("\"idField\":null")).toEqual(true);
+    globalThis.expect(unresolved.includes("\"idFieldSource\":null")).toEqual(true);
+  });
+  globalThis.test("types both as nullable Strings on the read-side SDL", () => {
+    let sdl = Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes.join("\n");
+    globalThis.expect(sdl.includes("idField: String\n")).toEqual(true);
+    globalThis.expect(sdl.includes("idFieldSource: String\n")).toEqual(true);
+    globalThis.expect(sdl.includes("idField: String!")).toEqual(false);
+  });
+});
+
 export {
   cmd,
   qbl,

package/tests/admin/Platform_PluginStructuresApiTest.res

@@ -19,6 +19,11 @@ let publicRm: queryableDef = {
   statusField: None,
   visibility: None,
   chapter: Some("Inventory"),
+  singleQueryField: Some("Catalog_Product"),
+  idField: Some("productId"),
+  idFieldSource: Some("convention"),
+  requiredAccess: None,
+  ownerField: None,
 }
 
 // The component `Platform_ComponentDefinitions` drops and this query must keep.
@@ -113,6 +118,13 @@ describe("Platform_PluginStructures entry", () => {
     )->toEqual(true)
   )
 
+  // Both read-side queries share `encodeQueryableDef`, so this asserts the singular
+  // name is not a ComponentDefinitions-only field: a developer tool building a detail
+  // query reads it from here.
+  testSync("encodes the singular query field beside the list one", () =>
+    expect(json->String.includes("\"singleQueryField\":\"Catalog_Product\""))->toEqual(true)
+  )
+
   testSync("encodes required stores with their provenance", () =>
     expect(json->String.includes("\"requiredStores\":[\"Catalog.images\"]"))->toEqual(true)
   )

package/tests/admin/Platform_PluginStructuresApiTest.res.mjs

@@ -16,6 +16,12 @@ let publicRm_labelFieldSource = "annotation";
 
 let publicRm_chapter = "Inventory";
 
+let publicRm_singleQueryField = "Catalog_Product";
+
+let publicRm_idField = "productId";
+
+let publicRm_idFieldSource = "convention";
+
 let publicRm = {
   name: "Products",
   queryField: "Catalog_Products",
@@ -26,8 +32,13 @@ let publicRm = {
   searchableFields: publicRm_searchableFields,
   labelFieldSource: publicRm_labelFieldSource,
   statusField: undefined,
+  ownerField: undefined,
   visibility: undefined,
-  chapter: publicRm_chapter
+  chapter: publicRm_chapter,
+  singleQueryField: publicRm_singleQueryField,
+  idField: publicRm_idField,
+  idFieldSource: publicRm_idFieldSource,
+  requiredAccess: undefined
 };
 
 let internalRm_consumedEventTypes = publicRm_consumedEventTypes;
@@ -42,6 +53,12 @@ let internalRm_visibility = "Internal";
 
 let internalRm_chapter = "Inventory";
 
+let internalRm_singleQueryField = "Catalog_Product";
+
+let internalRm_idField = "productId";
+
+let internalRm_idFieldSource = "convention";
+
 let internalRm = {
   name: "ProductAudit",
   queryField: "Catalog_ProductAudit",
@@ -52,8 +69,13 @@ let internalRm = {
   searchableFields: internalRm_searchableFields,
   labelFieldSource: internalRm_labelFieldSource,
   statusField: undefined,
+  ownerField: undefined,
   visibility: internalRm_visibility,
-  chapter: internalRm_chapter
+  chapter: internalRm_chapter,
+  singleQueryField: internalRm_singleQueryField,
+  idField: internalRm_idField,
+  idFieldSource: internalRm_idFieldSource,
+  requiredAccess: undefined
 };
 
 let structure_readModels = [
@@ -150,6 +172,9 @@ globalThis.describe("Platform_PluginStructures entry", () => {
   globalThis.test("encodes extension points with their source event types", () => {
     globalThis.expect(json.includes("\"extensionPoints\":[{\"name\":\"Catalog.Products\",\"delegateNames\":[\"onAdded\"],\"sourceEventTypes\":[\"Catalog.ProductAdded\"],\"commandTypes\":null}]")).toEqual(true);
   });
+  globalThis.test("encodes the singular query field beside the list one", () => {
+    globalThis.expect(json.includes("\"singleQueryField\":\"Catalog_Product\"")).toEqual(true);
+  });
   globalThis.test("encodes required stores with their provenance", () => {
     globalThis.expect(json.includes("\"requiredStores\":[\"Catalog.images\"]")).toEqual(true);
   });

package/tests/api/Api_IdsTest.res

@@ -0,0 +1,143 @@
+// The id contract: which form each door accepts, in one place.
+//
+// A row advertises a Relay global id (`btoa("<Type>:<localId>")`) while the
+// storage key is the local id. Before this, the typed doors took only the local
+// id, so the obvious `X(id: row.id)` returned null with no error. These pin the
+// rule that makes either form work — and, just as importantly, the cases where a
+// string must NOT be treated as a global id.
+
+open JestGlobals
+
+@val external btoa: string => string = "btoa"
+
+describe("Api_Ids.encode / decode", () => {
+  testSync("round-trips a type name and a local id", () => {
+    let g = Api_Ids.encode(~typeName="Ordering_Customer", ~localId="cust-42")
+    expect(g)->toEqual(btoa("Ordering_Customer:cust-42"))
+    expect(Api_Ids.decode(g))->toEqual(Some(("Ordering_Customer", "cust-42")))
+  })
+
+  // Ids carrying a colon of their own: only the first one separates.
+  testSync("a local id containing a colon survives the round trip", () => {
+    let g = Api_Ids.encode(~typeName="Platform_Plugin", ~localId="Catalog@1.0.0:beta")
+    expect(Api_Ids.decode(g))->toEqual(Some(("Platform_Plugin", "Catalog@1.0.0:beta")))
+  })
+
+  testSync("a plain storage key is not a global id", () =>
+    expect(Api_Ids.decode("cust-42"))->toEqual(None)
+  )
+
+  // `atob` accepts this and yields text with no colon — decoding must still say no.
+  testSync("valid base64 without a colon is not a global id", () =>
+    expect(Api_Ids.decode(btoa("nocolonhere")))->toEqual(None)
+  )
+
+  // A leading colon would mean an empty type name — nothing `node` could resolve.
+  testSync("a decoded value starting with the separator is not a global id", () =>
+    expect(Api_Ids.decode(btoa(":cust-42")))->toEqual(None)
+  )
+})
+
+describe("Api_Ids.alternateKey — the fallback a door tries on a miss", () => {
+  testSync("a global id offers the storage key inside it", () =>
+    expect(Api_Ids.alternateKey(Api_Ids.encode(~typeName="Catalog_Product", ~localId="p-1")))
+    ->toEqual(Some("p-1"))
+  )
+
+  testSync("a plain key offers nothing, so the lookup is never retried", () =>
+    expect(Api_Ids.alternateKey("p-1"))->toEqual(None)
+  )
+
+  // The reason doors try the raw key FIRST and only fall back here: a storage key
+  // that happens to be valid base64 must keep resolving to its own row.
+  testSync("a key that merely looks like base64 is not silently rewritten", () => {
+    let looksBase64 = btoa("Type:inner")
+    expect(Api_Ids.alternateKey(looksBase64))->toEqual(Some("inner"))
+    // …but the door asks for `looksBase64` first, so a row stored under that exact
+    // string wins. `alternateKey` only ever supplies the second attempt.
+    expect(Api_Ids.alternateKey("cGxhaW4="))->toEqual(None)
+  })
+})
+
+// A resolver that stamps the Relay `id` onto a row must not stamp it onto the
+// *stored* row: `JSON.Decode.object` hands back the very object the in-memory
+// QueryDb holds, so a `Dict.set` writes through. The symptom was a row whose
+// advertised id depended on query history — a list answered the storage key
+// until someone loaded the detail page, and the global id ever after.
+describe("stamping an id onto a row leaves the stored row alone", () => {
+  let storedRow = () => {
+    let d = Dict.make()
+    d->Dict.set("id", JSON.Encode.string("cust-42"))
+    d->Dict.set("email", JSON.Encode.string("a@b.c"))
+    JSON.Encode.object(d)
+  }
+
+  testSync("Dict.copy before set — the pattern the resolvers use", () => {
+    let row = storedRow()
+    let stamped = {
+      let obj = row->JSON.Decode.object->Option.mapOr(Dict.make(), Dict.copy)
+      obj->Dict.set(
+        "id",
+        Api_Ids.encode(~typeName="Ordering_Customer", ~localId="cust-42")->JSON.Encode.string,
+      )
+      JSON.Encode.object(obj)
+    }
+    let idOf = j =>
+      j->JSON.Decode.object->Option.flatMap(d => d->Dict.get("id"))->Option.flatMap(JSON.Decode.string)
+    expect(idOf(stamped))->toEqual(Some(Api_Ids.encode(~typeName="Ordering_Customer", ~localId="cust-42")))
+    // The stored row still carries its storage key.
+    expect(idOf(row))->toEqual(Some("cust-42"))
+  })
+})
+
+// `filter.ids` is the door that has always taken either form. Which side needs
+// decoding flipped when the typed doors stopped stamping global ids onto rows:
+// the row now carries its storage key and the *argument* may be the global one.
+describe("filter.ids matches whichever form each side holds", () => {
+  let row = (id: string) => {
+    let d = Dict.make()
+    d->Dict.set("id", JSON.Encode.string(id))
+    d->Dict.set("name", JSON.Encode.string("Alpha"))
+    JSON.Encode.object(d)
+  }
+  let idsIn = (~rowId, ~filterIds) => {
+    let args = Dict.make()
+    args->Dict.set(
+      "filter",
+      JSON.Encode.object(
+        Dict.fromArray([("ids", JSON.Encode.array(filterIds->Array.map(JSON.Encode.string)))]),
+      ),
+    )
+    let conn = QueryDbListQuery.run(
+      ~items=[row(rowId)],
+      ~argsDict=args,
+      ~capability=GraphQL_FragmentGenerator.emptyCapability,
+      ~labelField="name",
+    )
+    conn
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("edges"))
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.getOr([])
+    ->Array.length
+  }
+  let globalFor = localId => Api_Ids.encode(~typeName="Catalog_Product", ~localId)
+
+  testSync("storage key row, storage key filter", () =>
+    expect(idsIn(~rowId="p-1", ~filterIds=["p-1"]))->toBe(1)
+  )
+
+  // The case the flip fixes: a client passes back the global id it was given by
+  // `node`, while the list rows carry storage keys.
+  testSync("storage key row, global id filter", () =>
+    expect(idsIn(~rowId="p-1", ~filterIds=[globalFor("p-1")]))->toBe(1)
+  )
+
+  testSync("global id row, storage key filter", () =>
+    expect(idsIn(~rowId=globalFor("p-1"), ~filterIds=["p-1"]))->toBe(1)
+  )
+
+  testSync("a filter for another row still excludes it", () =>
+    expect(idsIn(~rowId="p-1", ~filterIds=[globalFor("p-2")]))->toBe(0)
+  )
+})

package/tests/api/Api_IdsTest.res.mjs

@@ -0,0 +1,97 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Api_Ids$ReventlessCore from "../../src/components/Api/Api_Ids.res.mjs";
+import * as QueryDbListQuery$ReventlessCore from "../../src/components/Api/QueryDbListQuery.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+globalThis.describe("Api_Ids.encode / decode", () => {
+  globalThis.test("round-trips a type name and a local id", () => {
+    let g = Api_Ids$ReventlessCore.encode("Ordering_Customer", "cust-42");
+    globalThis.expect(g).toEqual(btoa("Ordering_Customer:cust-42"));
+    globalThis.expect(Api_Ids$ReventlessCore.decode(g)).toEqual([
+      "Ordering_Customer",
+      "cust-42"
+    ]);
+  });
+  globalThis.test("a local id containing a colon survives the round trip", () => {
+    let g = Api_Ids$ReventlessCore.encode("Platform_Plugin", "Catalog@1.0.0:beta");
+    globalThis.expect(Api_Ids$ReventlessCore.decode(g)).toEqual([
+      "Platform_Plugin",
+      "Catalog@1.0.0:beta"
+    ]);
+  });
+  globalThis.test("a plain storage key is not a global id", () => {
+    globalThis.expect(Api_Ids$ReventlessCore.decode("cust-42")).toEqual(undefined);
+  });
+  globalThis.test("valid base64 without a colon is not a global id", () => {
+    globalThis.expect(Api_Ids$ReventlessCore.decode(btoa("nocolonhere"))).toEqual(undefined);
+  });
+  globalThis.test("a decoded value starting with the separator is not a global id", () => {
+    globalThis.expect(Api_Ids$ReventlessCore.decode(btoa(":cust-42"))).toEqual(undefined);
+  });
+});
+
+globalThis.describe("Api_Ids.alternateKey — the fallback a door tries on a miss", () => {
+  globalThis.test("a global id offers the storage key inside it", () => {
+    globalThis.expect(Api_Ids$ReventlessCore.alternateKey(Api_Ids$ReventlessCore.encode("Catalog_Product", "p-1"))).toEqual("p-1");
+  });
+  globalThis.test("a plain key offers nothing, so the lookup is never retried", () => {
+    globalThis.expect(Api_Ids$ReventlessCore.alternateKey("p-1")).toEqual(undefined);
+  });
+  globalThis.test("a key that merely looks like base64 is not silently rewritten", () => {
+    let looksBase64 = btoa("Type:inner");
+    globalThis.expect(Api_Ids$ReventlessCore.alternateKey(looksBase64)).toEqual("inner");
+    globalThis.expect(Api_Ids$ReventlessCore.alternateKey("cGxhaW4=")).toEqual(undefined);
+  });
+});
+
+globalThis.describe("stamping an id onto a row leaves the stored row alone", () => {
+  let storedRow = () => {
+    let d = {};
+    d["id"] = "cust-42";
+    d["email"] = "a@b.c";
+    return d;
+  };
+  globalThis.test("Dict.copy before set — the pattern the resolvers use", () => {
+    let row = storedRow();
+    let obj = Stdlib_Option.mapOr(Stdlib_JSON.Decode.object(row), {}, prim => Object.assign({}, prim));
+    obj["id"] = Api_Ids$ReventlessCore.encode("Ordering_Customer", "cust-42");
+    let idOf = j => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["id"]), Stdlib_JSON.Decode.string);
+    globalThis.expect(idOf(obj)).toEqual(Api_Ids$ReventlessCore.encode("Ordering_Customer", "cust-42"));
+    globalThis.expect(idOf(row)).toEqual("cust-42");
+  });
+});
+
+globalThis.describe("filter.ids matches whichever form each side holds", () => {
+  let row = id => {
+    let d = {};
+    d["id"] = id;
+    d["name"] = "Alpha";
+    return d;
+  };
+  let idsIn = (rowId, filterIds) => {
+    let args = {};
+    args["filter"] = Object.fromEntries([[
+        "ids",
+        filterIds.map(prim => prim)
+      ]]);
+    let conn = QueryDbListQuery$ReventlessCore.run([row(rowId)], args, GraphQL_FragmentGenerator$ReventlessCore.emptyCapability, "name", undefined, undefined);
+    return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(conn), d => d["edges"]), Stdlib_JSON.Decode.array), []).length;
+  };
+  globalThis.test("storage key row, storage key filter", () => {
+    globalThis.expect(idsIn("p-1", ["p-1"])).toBe(1);
+  });
+  globalThis.test("storage key row, global id filter", () => {
+    globalThis.expect(idsIn("p-1", [Api_Ids$ReventlessCore.encode("Catalog_Product", "p-1")])).toBe(1);
+  });
+  globalThis.test("global id row, storage key filter", () => {
+    globalThis.expect(idsIn(Api_Ids$ReventlessCore.encode("Catalog_Product", "p-1"), ["p-1"])).toBe(1);
+  });
+  globalThis.test("a filter for another row still excludes it", () => {
+    globalThis.expect(idsIn("p-1", [Api_Ids$ReventlessCore.encode("Catalog_Product", "p-2")])).toBe(0);
+  });
+});
+
+/*  Not a pure module */