@reventlessdev/reventless-local 3.0.0-alpha.211 → 3.0.0-alpha.213

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -77,6 +77,14 @@ type plainState = {
   name: string,
 }
 
+// No `*Id` field at all, so the key ladder has nothing to nominate — the state
+// that still produces an empty capability.
+@schema
+type keylessState = {
+  name: string,
+  note: string,
+}
+
 @schema
 type indexedState = {
   productId: @s.matches(Reventless.DcbTag.string) string,
@@ -582,7 +590,12 @@ describe("GraphQL_SchemaInspector", () => {
   // ── Phase 1: server capability — auto-derived Filter / OrderBy ─────────
 
   describe("server capability — auto-derived Filter / OrderBy", () => {
-    testPromise("read model with no annotations emits the unchanged search-only Filter", async () => {
+    // This used to assert that a state with no annotations got a search-only
+    // Filter and no OrderBy at all. It no longer does: `plainState` has exactly
+    // one `*Id` field, so the key is knowable without `@id` and the queryable now
+    // gets that key's eq filter and sort. The search-only case is the one below,
+    // where nothing identifies the row.
+    testPromise("read model with no annotations gets its inferred key's Eq + OrderBy", async () => {
       let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(
         ~mutationEntries=[],
         ~queryEntries=[
@@ -599,16 +612,44 @@ describe("GraphQL_SchemaInspector", () => {
       )
       let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
       let sdl = inspection.sdlPreview
-      // Filter has only the legacy block
+      // The legacy block is untouched …
       expect(sdl->String.includes("input PlainViewFilter"))->toBe(true)
       expect(sdl->String.includes("search: String"))->toBe(true)
       expect(sdl->String.includes("searchPrefix: String"))->toBe(true)
       expect(sdl->String.includes("ids: [ID!]"))->toBe(true)
-      // No per-field eq inputs
+      // … and `productId`, the sole candidate, now narrows and sorts.
+      expect(sdl->String.includes("productIdEq: ID"))->toBe(true)
+      expect(sdl->String.includes("PlainViewOrderBy"))->toBe(true)
+      expect(sdl->String.includes("PlainViewOrderField"))->toBe(true)
+      expect(sdl->String.includes("orderBy:"))->toBe(true)
+      // Only the key — an inferred key never drags the rest of the record in.
+      expect(sdl->String.includes("nameEq:"))->toBe(false)
+    })
+
+    // The remaining empty-capability case: no `*Id` field, so nothing says which
+    // field identifies a row and the ladder declines rather than guessing.
+    testPromise("read model whose key cannot be resolved stays search-only", async () => {
+      let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(
+        ~mutationEntries=[],
+        ~queryEntries=[
+          {
+            singleFieldName: "Keyless_View",
+            listFieldName: "Keyless_Views",
+            returnTypeName: "KeylessView",
+            stateSchema: keylessStateSchema->S.castToUnknown,
+            authorization: None,
+            includeIdParam: false,
+            connectionSpec: true,
+          },
+        ],
+      )
+      let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
+      let sdl = inspection.sdlPreview
+      expect(sdl->String.includes("input KeylessViewFilter"))->toBe(true)
+      expect(sdl->String.includes("search: String"))->toBe(true)
       expect(sdl->String.includes("Eq:"))->toBe(false)
-      // No OrderBy / OrderField types or arg
-      expect(sdl->String.includes("PlainViewOrderBy"))->toBe(false)
-      expect(sdl->String.includes("PlainViewOrderField"))->toBe(false)
+      expect(sdl->String.includes("KeylessViewOrderBy"))->toBe(false)
+      expect(sdl->String.includes("KeylessViewOrderField"))->toBe(false)
       expect(sdl->String.includes("orderBy:"))->toBe(false)
     })
 

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -84,6 +84,11 @@ let plainStateSchema = S.schema(s => ({
   name: s.m(S.string)
 }));
 
+let keylessStateSchema = S.schema(s => ({
+  name: s.m(S.string),
+  note: s.m(S.string)
+}));
+
 let indexedStateSchema = S.schema(s => ({
   productId: s.m(DcbTag$Reventless.string),
   ownerId: s.m(S.string),
@@ -453,7 +458,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
     });
   });
   globalThis.describe("server capability — auto-derived Filter / OrderBy", () => {
-    globalThis.test("read model with no annotations emits the unchanged search-only Filter", async () => {
+    globalThis.test("read model with no annotations gets its inferred key's Eq + OrderBy", async () => {
       let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
           singleFieldName: "Plain_View",
           listFieldName: "Plain_Views",
@@ -469,9 +474,29 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
       globalThis.expect(sdl.includes("search: String")).toBe(true);
       globalThis.expect(sdl.includes("searchPrefix: String")).toBe(true);
       globalThis.expect(sdl.includes("ids: [ID!]")).toBe(true);
+      globalThis.expect(sdl.includes("productIdEq: ID")).toBe(true);
+      globalThis.expect(sdl.includes("PlainViewOrderBy")).toBe(true);
+      globalThis.expect(sdl.includes("PlainViewOrderField")).toBe(true);
+      globalThis.expect(sdl.includes("orderBy:")).toBe(true);
+      globalThis.expect(sdl.includes("nameEq:")).toBe(false);
+    });
+    globalThis.test("read model whose key cannot be resolved stays search-only", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Keyless_View",
+          listFieldName: "Keyless_Views",
+          returnTypeName: "KeylessView",
+          stateSchema: keylessStateSchema,
+          authorization: undefined,
+          includeIdParam: false,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("input KeylessViewFilter")).toBe(true);
+      globalThis.expect(sdl.includes("search: String")).toBe(true);
       globalThis.expect(sdl.includes("Eq:")).toBe(false);
-      globalThis.expect(sdl.includes("PlainViewOrderBy")).toBe(false);
-      globalThis.expect(sdl.includes("PlainViewOrderField")).toBe(false);
+      globalThis.expect(sdl.includes("KeylessViewOrderBy")).toBe(false);
+      globalThis.expect(sdl.includes("KeylessViewOrderField")).toBe(false);
       globalThis.expect(sdl.includes("orderBy:")).toBe(false);
     });
     globalThis.test("read model with @id + @index emits Eq filters + OrderBy + orderBy arg", async () => {
@@ -701,6 +726,7 @@ export {
   dcbSingleCommandSchema,
   dcbMultiCommandSchema,
   plainStateSchema,
+  keylessStateSchema,
   indexedStateSchema,
   indexedStateSchemaWithAnnotations,
   orderedStateSchema,

package/tests/adapter/QueryDbListPushdownParityTest.res

@@ -21,23 +21,30 @@ let capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability = {
   sortFields: ["name", "qty", "status"],
 }
 
-let mk = (id, status, name, qty) => {
+let mk = (id, status, name, qty, owner) => {
   let o = Dict.make()
   o->Dict.set("id", JSON.Encode.string(id))
   o->Dict.set("status", JSON.Encode.string(status))
   o->Dict.set("name", JSON.Encode.string(name))
   o->Dict.set("qty", JSON.Encode.int(qty))
+  o->Dict.set("owner", JSON.Encode.string(owner))
   JSON.Encode.object(o)
 }
 
 // Names differ from id-order; status has duplicates (tiebreak); qty exercises the
-// numeric-field-as-string comparison the push-down must match.
+// numeric-field-as-string comparison the push-down must match. `owner` is split
+// so that no owner holds all the rows and none holds none — a scoped read that
+// returned everything and one that returned nothing would both stand out.
+//
+// Note `owner` is deliberately absent from `capability` below: owner scoping has
+// to work on a field the client-visible filter surface does not admit, which is
+// the normal case and the reason the predicate travels separately.
 let rows = [
-  ("p-1", "active", "Charlie", 3),
-  ("p-2", "active", "Alpha", 1),
-  ("p-3", "inactive", "Echo", 5),
-  ("p-4", "active", "Bravo", 2),
-  ("p-5", "inactive", "Delta", 4),
+  ("p-1", "active", "Charlie", 3, "u-a"),
+  ("p-2", "active", "Alpha", 1, "u-b"),
+  ("p-3", "inactive", "Echo", 5, "u-a"),
+  ("p-4", "active", "Bravo", 2, "u-c"),
+  ("p-5", "inactive", "Delta", 4, "u-a"),
 ]
 
 type setup = {
@@ -45,6 +52,7 @@ type setup = {
     ~argsDict: dict<JSON.t>,
     ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
     ~labelField: string,
+    ~ownerScope: (string, string)=?,
   ) => option<JSON.t>,
   fullScan: unit => array<JSON.t>,
 }
@@ -58,8 +66,8 @@ let build = async (): setup => {
   let s = Storage.make(~name="items", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
   let ops = await s.operations->TestRunner.resolve
   for i in 0 to rows->Array.length - 1 {
-    let (id, status, name, qty) = rows->Array.getUnsafe(i)
-    let _ = await ops.save(id, mk(id, status, name, qty), ReventlessCore.QueryDb.Any, None)
+    let (id, status, name, qty, owner) = rows->Array.getUnsafe(i)
+    let _ = await ops.save(id, mk(id, status, name, qty, owner), ReventlessCore.QueryDb.Any, None)
   }
   {
     listPage: TestBus.getQueryDbListPage("items")->Option.getOrThrow,
@@ -110,7 +118,7 @@ let orderBy = (f, dir) =>
 let cur = ReventlessCore.QueryDbListQuery.encodeCursor
 
 // Assert the push-down serves this shape AND matches the spec exactly.
-let checkPushed = async (~label, args) => {
+let checkPushed = async (~label, ~ownerScope=?, args) => {
   let s = await build()
   let argsDict = argsOf(args)
   let expected =
@@ -120,8 +128,9 @@ let checkPushed = async (~label, args) => {
       ~capability,
       ~labelField="name",
       ~decodeLocalId=_ => None,
+      ~ownerScope?,
     )->norm
-  switch s.listPage(~argsDict, ~capability, ~labelField="name") {
+  switch s.listPage(~argsDict, ~capability, ~labelField="name", ~ownerScope?) {
   | Some(actual) => expect(actual->norm)->toEqual(expected)
   | None => expect("push-down for " ++ label)->toBe("returned None")
   }
@@ -133,6 +142,20 @@ let checkFallback = async args => {
   expect(s.listPage(~argsDict=argsOf(args), ~capability, ~labelField="name")->Option.isSome)->toBe(false)
 }
 
+// The ids a scoped read actually returns, from the push-down.
+let scopedIds = async (~owner, args) => {
+  let s = await build()
+  switch s.listPage(
+    ~argsDict=argsOf(args),
+    ~capability,
+    ~labelField="name",
+    ~ownerScope=("owner", owner),
+  ) {
+  | Some(conn) => (conn->norm).edges->Array.map(e => e.id)
+  | None => []
+  }
+}
+
 describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery spec)", () => {
   testPromise("bare page", () => checkPushed(~label="bare", []))
   testPromise("first:2", () => checkPushed(~label="first", [("first", JSON.Encode.int(2))]))
@@ -194,4 +217,62 @@ describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery spec)", ()
   testPromise("backward (last/before) → fallback", () =>
     checkFallback([("last", JSON.Encode.int(2)), ("before", JSON.Encode.string(cur("p-4")))])
   )
+
+  // ── Owner scoping ─────────────────────────────────────────────────────────
+  // Parity matters more here than anywhere else in this file. The push-down is
+  // the path a deployment actually takes; the spec is the path the tests most
+  // easily reach. A predicate implemented in only one of them is a hole that
+  // every fallback-based test would still call green.
+  describe("owner scoping", () => {
+    testPromise("bare page, scoped", () =>
+      checkPushed(~label="owner-bare", ~ownerScope=("owner", "u-a"), [])
+    )
+    testPromise("scoped + orderBy", () =>
+      checkPushed(
+        ~label="owner-order",
+        ~ownerScope=("owner", "u-a"),
+        [("orderBy", orderBy("name", "DESC"))],
+      )
+    )
+    // The client's own filter must survive alongside the scope, not be replaced
+    // by it — a scoped read is still a filtered read.
+    testPromise("scoped + client filter compose", () =>
+      checkPushed(
+        ~label="owner-and-filter",
+        ~ownerScope=("owner", "u-a"),
+        [("filter", filterOf([("statusEq", JSON.Encode.string("inactive"))]))],
+      )
+    )
+
+    testPromise("a scoped read returns exactly that owner's rows", async () =>
+      expect(await scopedIds(~owner="u-a", []))->toEqual(["p-1", "p-3", "p-5"])
+    )
+
+    // The control: a different owner sees a different, also non-empty, set. An
+    // implementation that scoped to nothing would pass an "is not everything"
+    // assertion and fail this one.
+    testPromise("a second owner sees their own rows, not the first's", async () =>
+      expect(await scopedIds(~owner="u-b", []))->toEqual(["p-2"])
+    )
+
+    // The case that catches a predicate applied AFTER the page rather than
+    // inside the SQL: u-a owns 3 of 5 rows, so a LIMIT 2 taken before scoping
+    // would return p-1 alone (p-2 belongs to u-b and would be dropped), not the
+    // two rows actually asked for.
+    testPromise("paging a scoped read fills each page from owned rows only", async () =>
+      expect(await scopedIds(~owner="u-a", [("first", JSON.Encode.int(2))]))->toEqual([
+        "p-1",
+        "p-3",
+      ])
+    )
+
+    testPromise("the second page continues the scoped sequence", async () =>
+      expect(
+        await scopedIds(
+          ~owner="u-a",
+          [("first", JSON.Encode.int(2)), ("after", JSON.Encode.string(cur("p-3")))],
+        ),
+      )->toEqual(["p-5"])
+    )
+  })
 })

package/tests/adapter/QueryDbListPushdownParityTest.res.mjs

@@ -36,12 +36,13 @@ let capability = {
   sortFields: capability_sortFields
 };
 
-function mk(id, status, name, qty) {
+function mk(id, status, name, qty, owner) {
   let o = {};
   o["id"] = id;
   o["status"] = status;
   o["name"] = name;
   o["qty"] = qty;
+  o["owner"] = owner;
   return o;
 }
 
@@ -50,31 +51,36 @@ let rows = [
     "p-1",
     "active",
     "Charlie",
-    3
+    3,
+    "u-a"
   ],
   [
     "p-2",
     "active",
     "Alpha",
-    1
+    1,
+    "u-b"
   ],
   [
     "p-3",
     "inactive",
     "Echo",
-    5
+    5,
+    "u-a"
   ],
   [
     "p-4",
     "active",
     "Bravo",
-    2
+    2,
+    "u-c"
   ],
   [
     "p-5",
     "inactive",
     "Delta",
-    4
+    4,
+    "u-a"
   ]
 ];
 
@@ -90,7 +96,7 @@ async function build() {
   for (let i = 0, i_finish = rows.length; i < i_finish; ++i) {
     let match = rows[i];
     let id = match[0];
-    await ops.save(id, mk(id, match[1], match[2], match[3]), "Any", undefined);
+    await ops.save(id, mk(id, match[1], match[2], match[3], match[4]), "Any", undefined);
   }
   return {
     listPage: Stdlib_Option.getOrThrow(TestBus.getQueryDbListPage("items"), undefined),
@@ -142,11 +148,11 @@ function orderBy(f, dir) {
   ]);
 }
 
-async function checkPushed(label, args) {
+async function checkPushed(label, ownerScope, args) {
   let s = await build();
   let argsDict = Object.fromEntries(args);
-  let expected = norm(QueryDbListQuery$ReventlessCore.run(s.fullScan(), argsDict, capability, "name", param => {}));
-  let actual = s.listPage(argsDict, capability, "name");
+  let expected = norm(QueryDbListQuery$ReventlessCore.run(s.fullScan(), argsDict, capability, "name", param => {}, ownerScope));
+  let actual = s.listPage(argsDict, capability, "name", ownerScope);
   if (actual !== undefined) {
     globalThis.expect(norm(actual)).toEqual(expected);
   } else {
@@ -156,16 +162,29 @@ async function checkPushed(label, args) {
 
 async function checkFallback(args) {
   let s = await build();
-  globalThis.expect(Stdlib_Option.isSome(s.listPage(Object.fromEntries(args), capability, "name"))).toBe(false);
+  globalThis.expect(Stdlib_Option.isSome(s.listPage(Object.fromEntries(args), capability, "name", undefined))).toBe(false);
+}
+
+async function scopedIds(owner, args) {
+  let s = await build();
+  let conn = s.listPage(Object.fromEntries(args), capability, "name", [
+    "owner",
+    owner
+  ]);
+  if (conn !== undefined) {
+    return norm(conn).edges.map(e => e.id);
+  } else {
+    return [];
+  }
 }
 
 globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery spec)", () => {
-  globalThis.test("bare page", () => checkPushed("bare", []));
-  globalThis.test("first:2", () => checkPushed("first", [[
+  globalThis.test("bare page", () => checkPushed("bare", undefined, []));
+  globalThis.test("first:2", () => checkPushed("first", undefined, [[
       "first",
       2
     ]]));
-  globalThis.test("first:2 + after", () => checkPushed("after", [
+  globalThis.test("first:2 + after", () => checkPushed("after", undefined, [
     [
       "first",
       2
@@ -175,14 +194,14 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       QueryDbListQuery$ReventlessCore.encodeCursor("p-2")
     ]
   ]));
-  globalThis.test("statusEq active", () => checkPushed("eq", [[
+  globalThis.test("statusEq active", () => checkPushed("eq", undefined, [[
       "filter",
       Object.fromEntries([[
           "statusEq",
           "active"
         ]])
     ]]));
-  globalThis.test("statusEq active + first:2", () => checkPushed("eq+first", [
+  globalThis.test("statusEq active + first:2", () => checkPushed("eq+first", undefined, [
     [
       "filter",
       Object.fromEntries([[
@@ -195,15 +214,15 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       2
     ]
   ]));
-  globalThis.test("orderBy name ASC", () => checkPushed("order-asc", [[
+  globalThis.test("orderBy name ASC", () => checkPushed("order-asc", undefined, [[
       "orderBy",
       orderBy("name", "ASC")
     ]]));
-  globalThis.test("orderBy name DESC", () => checkPushed("order-desc", [[
+  globalThis.test("orderBy name DESC", () => checkPushed("order-desc", undefined, [[
       "orderBy",
       orderBy("name", "DESC")
     ]]));
-  globalThis.test("orderBy name DESC + first:2 + after", () => checkPushed("order-desc-after", [
+  globalThis.test("orderBy name DESC + first:2 + after", () => checkPushed("order-desc-after", undefined, [
     [
       "orderBy",
       orderBy("name", "DESC")
@@ -217,11 +236,11 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       QueryDbListQuery$ReventlessCore.encodeCursor("Delta")
     ]
   ]));
-  globalThis.test("orderBy status ASC (tiebreak by id)", () => checkPushed("order-tiebreak", [[
+  globalThis.test("orderBy status ASC (tiebreak by id)", () => checkPushed("order-tiebreak", undefined, [[
       "orderBy",
       orderBy("status", "ASC")
     ]]));
-  globalThis.test("qty range From/To (numeric-as-string)", () => checkPushed("range", [[
+  globalThis.test("qty range From/To (numeric-as-string)", () => checkPushed("range", undefined, [[
       "filter",
       Object.fromEntries([
         [
@@ -234,7 +253,7 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
         ]
       ])
     ]]));
-  globalThis.test("orderBy qty ASC (numeric-as-string sort)", () => checkPushed("order-qty", [[
+  globalThis.test("orderBy qty ASC (numeric-as-string sort)", () => checkPushed("order-qty", undefined, [[
       "orderBy",
       orderBy("qty", "ASC")
     ]]));
@@ -269,6 +288,60 @@ globalThis.describe("QueryDb list push-down parity (SQLite ≡ QueryDbListQuery
       QueryDbListQuery$ReventlessCore.encodeCursor("p-4")
     ]
   ]));
+  globalThis.describe("owner scoping", () => {
+    globalThis.test("bare page, scoped", () => checkPushed("owner-bare", [
+      "owner",
+      "u-a"
+    ], []));
+    globalThis.test("scoped + orderBy", () => checkPushed("owner-order", [
+      "owner",
+      "u-a"
+    ], [[
+        "orderBy",
+        orderBy("name", "DESC")
+      ]]));
+    globalThis.test("scoped + client filter compose", () => checkPushed("owner-and-filter", [
+      "owner",
+      "u-a"
+    ], [[
+        "filter",
+        Object.fromEntries([[
+            "statusEq",
+            "inactive"
+          ]])
+      ]]));
+    globalThis.test("a scoped read returns exactly that owner's rows", async () => {
+      globalThis.expect(await scopedIds("u-a", [])).toEqual([
+        "p-1",
+        "p-3",
+        "p-5"
+      ]);
+    });
+    globalThis.test("a second owner sees their own rows, not the first's", async () => {
+      globalThis.expect(await scopedIds("u-b", [])).toEqual(["p-2"]);
+    });
+    globalThis.test("paging a scoped read fills each page from owned rows only", async () => {
+      globalThis.expect(await scopedIds("u-a", [[
+          "first",
+          2
+        ]])).toEqual([
+        "p-1",
+        "p-3"
+      ]);
+    });
+    globalThis.test("the second page continues the scoped sequence", async () => {
+      globalThis.expect(await scopedIds("u-a", [
+        [
+          "first",
+          2
+        ],
+        [
+          "after",
+          QueryDbListQuery$ReventlessCore.encodeCursor("p-3")
+        ]
+      ])).toEqual(["p-5"]);
+    });
+  });
 });
 
 let cur = QueryDbListQuery$ReventlessCore.encodeCursor;
@@ -288,5 +361,6 @@ export {
   cur,
   checkPushed,
   checkFallback,
+  scopedIds,
 }
 /*  Not a pure module */