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

package/tests/api/GraphQL_FragmentGeneratorTest.res

@@ -87,3 +87,172 @@ describe("GraphQL_FragmentGenerator slice TODO rows", () => {
     expect(item->String.includes("address: String!"))->toBe(true)
   })
 })
+
+// A state that declares no `@id` used to produce `emptyCapability` — no per-field
+// filter and no order-by at all, so every narrowing a client asked for happened
+// client-side over one page. The key is knowable without the annotation in the
+// common cases; these pin which cases those are, and which still need `@id`.
+describe("resolveKeyField — the ladder", () => {
+  let rungFor = (~entityName, schema) =>
+    GraphQL_FragmentGenerator.resolveKeyField(~entityName, schema->S.castToUnknown)
+
+  testSync("a lone `*Id` field is the only thing the key could be", () => {
+    let schema = S.schema(s => {"productId": s.matches(S.string), "name": s.matches(S.string)})
+    expect(rungFor(~entityName="AvailableProducts", schema))->toEqual(Some(("productId", "sole")))
+  })
+
+  testSync("several `*Id` fields are disambiguated by the component name", () => {
+    let schema = S.schema(s =>
+      {"productId": s.matches(S.string), "categoryId": s.matches(S.string)}
+    )
+    expect(rungFor(~entityName="Products", schema))->toEqual(Some(("productId", "convention")))
+  })
+
+  // The `-ies` plural the naive singulariser gets wrong, on the key side too.
+  testSync("the convention rung singularises the way Api_Naming does", () => {
+    let schema = S.schema(s =>
+      {"categoryId": s.matches(S.string), "ownerId": s.matches(S.string)}
+    )
+    expect(rungFor(~entityName="Categories", schema))->toEqual(Some(("categoryId", "convention")))
+  })
+
+  // ProductDemand: two `*Id` fields, and the name yields `productDemandId`, which
+  // is not a field. Declining is the honest answer — this is what `@id` is for.
+  testSync("several `*Id` fields with no name match declines", () => {
+    let schema = S.schema(s =>
+      {"productId": s.matches(S.string), "categoryId": s.matches(S.string)}
+    )
+    expect(rungFor(~entityName="ProductDemand", schema))->toEqual(None)
+  })
+
+  testSync("no `*Id` field at all declines", () => {
+    let schema = S.schema(s => {"email": s.matches(S.string), "address": s.matches(S.string)})
+    expect(rungFor(~entityName="Customers", schema))->toEqual(None)
+  })
+
+  // `paid` / `valid` end with a lowercase "id". SchemaType.isIdFieldName accepts
+  // them (it lowercases first, which is right for its own use); a key field must
+  // not be nominated that way.
+  testSync("a word merely ending in `id` is not a key", () => {
+    let schema = S.schema(s => {"paid": s.matches(S.string), "valid": s.matches(S.string)})
+    expect(rungFor(~entityName="Invoices", schema))->toEqual(None)
+  })
+})
+
+describe("deriveServerCapability — inferred keys reach the SDL surface", () => {
+  let capabilityFor = (~entityName, schema) =>
+    GraphQL_FragmentGenerator.deriveServerCapability(~entityName, schema->S.castToUnknown)
+
+  testSync("an inferred key yields an eq filter and a sort field", () => {
+    let schema = S.schema(s => {"orderId": s.matches(S.string), "total": s.matches(S.float)})
+    let c = capabilityFor(~entityName="Orders", schema)
+    expect(c.filterFields->Array.map(f => f.name))->toEqual(["orderId"])
+    expect(c.sortFields)->toEqual(["orderId"])
+  })
+
+  testSync("an unresolvable key still yields nothing — the old behaviour, now narrowed", () => {
+    let schema = S.schema(s => {"email": s.matches(S.string)})
+    let c = capabilityFor(~entityName="Customers", schema)
+    expect((c.filterFields->Array.length, c.sortFields->Array.length))->toEqual((0, 0))
+  })
+
+  testSync("the filter input carries the inferred key's eq field", () => {
+    let schema = S.schema(s => {"orderId": s.matches(S.string)})
+    let input = GraphQL_FragmentGenerator.deriveConnectionFilterType(
+      ~filterTypeName="Ordering_OrderFilter",
+      ~capability=capabilityFor(~entityName="Orders", schema),
+    )
+    // `ID`, not `String`: a `*Id`-named field is an EntityId in the IR, and the
+    // filter input mirrors the field's own GraphQL type.
+    expect(input->String.includes("orderIdEq: ID"))->toBe(true)
+  })
+
+  // No OrderBy type is emitted at all when nothing is sortable, so an inferred
+  // key is the difference between having the type and not having it.
+  testSync("the order-by pair exists because of the inferred key", () => {
+    let schema = S.schema(s => {"orderId": s.matches(S.string)})
+    let types = GraphQL_FragmentGenerator.deriveConnectionOrderByType(
+      ~singularTypeName="Ordering_Order",
+      ~capability=capabilityFor(~entityName="Orders", schema),
+    )
+    expect(types->Array.length)->toBe(2)
+    expect(types->Array.join("\n")->String.includes("enum Ordering_OrderOrderField"))->toBe(true)
+  })
+})
+
+// A semantic composite is one type wherever it appears. Named from the field
+// path that reached it, two commands taking a price produced two identical
+// `{amount, currency}` inputs and, beside each, its own copy of the 165-value
+// ISO 4217 enum — six copies of it across one example schema.
+module AddProductCmd = {
+  @schema
+  type command =
+    | AddProduct({productId: string, price: Reventless.Money.t})
+    | ArchiveProduct({productId: string})
+}
+
+module ChangePriceCmd = {
+  @schema
+  type command =
+    | ChangeProductPrice({productId: string, price: Reventless.Money.t})
+    | ClearProductPrice({productId: string})
+}
+
+describe("semantic composites are named once, not once per field", () => {
+  let countDefs = (types, keyword, name) =>
+    types->Array.filter(t => t->String.startsWith(`${keyword} ${name} {`))->Array.length
+
+  let fragmentTypes = GraphQL_Stitcher.decode(
+    GraphQL_FragmentGenerator.generate(
+      ~mutationEntries=[
+        {
+          ReventlessInfra.Api.fieldNames: ["Catalog_AddProduct"],
+          commandSchema: AddProductCmd.commandSchema->S.castToUnknown,
+          injectIdArg: false,
+        },
+        {
+          ReventlessInfra.Api.fieldNames: ["Catalog_ChangeProductPrice"],
+          commandSchema: ChangePriceCmd.commandSchema->S.castToUnknown,
+          injectIdArg: false,
+        },
+      ],
+      ~queryEntries=[],
+    ),
+  ).types
+
+  testSync("two commands taking a price share one input definition", () =>
+    expect(fragmentTypes->countDefs("input", "MoneyInput"))->toBe(1)
+  )
+
+  testSync("and one currency enum between them", () =>
+    expect(fragmentTypes->countDefs("enum", "MoneyCurrency"))->toBe(1)
+  )
+
+  // The control: these are the names the field-path naming produced, and their
+  // absence is the whole change. Without this the assertions above would pass
+  // just as well against a schema that emitted both namings.
+  testSync("nothing is named after the field path that reached it", () =>
+    expect(fragmentTypes->Array.some(t => t->String.includes("AddProductPrice")))->toBe(false)
+  )
+
+  // GraphQL forbids one name serving as both an object and an input, so the two
+  // positions differ by suffix — while sharing the enum, which has no such
+  // restriction and would otherwise be emitted twice over.
+  testSync("the output position keeps the bare name", () => {
+    let types = GraphQL_FragmentGenerator.deriveObjectTypeWithNested(
+      ~typeName="Catalog_Product",
+      ~includeIdParam=false,
+      S.schema(s =>
+        {
+          "productId": s.matches(S.string),
+          "price": s.matches(Reventless.Money.schema),
+        }
+      )->S.castToUnknown,
+    )
+    expect((
+      types->countDefs("type", "Money"),
+      types->countDefs("enum", "MoneyCurrency"),
+      types->Array.some(t => t->String.includes("price: Money!")),
+    ))->toEqual((1, 1, true))
+  })
+})

package/tests/api/GraphQL_FragmentGeneratorTest.res.mjs

@@ -2,6 +2,7 @@
 
 import * as S from "sury/src/S.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Money$Reventless from "@reventlessdev/reventless-spec/src/semantic/Money.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "../../src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
@@ -83,10 +84,188 @@ globalThis.describe("GraphQL_FragmentGenerator slice TODO rows", () => {
   });
 });
 
+globalThis.describe("resolveKeyField — the ladder", () => {
+  globalThis.test("a lone `*Id` field is the only thing the key could be", () => {
+    let schema = S.schema(s => ({
+      productId: s.m(S.string),
+      name: s.m(S.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("AvailableProducts", schema)).toEqual([
+      "productId",
+      "sole"
+    ]);
+  });
+  globalThis.test("several `*Id` fields are disambiguated by the component name", () => {
+    let schema = S.schema(s => ({
+      productId: s.m(S.string),
+      categoryId: s.m(S.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Products", schema)).toEqual([
+      "productId",
+      "convention"
+    ]);
+  });
+  globalThis.test("the convention rung singularises the way Api_Naming does", () => {
+    let schema = S.schema(s => ({
+      categoryId: s.m(S.string),
+      ownerId: s.m(S.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Categories", schema)).toEqual([
+      "categoryId",
+      "convention"
+    ]);
+  });
+  globalThis.test("several `*Id` fields with no name match declines", () => {
+    let schema = S.schema(s => ({
+      productId: s.m(S.string),
+      categoryId: s.m(S.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("ProductDemand", schema)).toEqual(undefined);
+  });
+  globalThis.test("no `*Id` field at all declines", () => {
+    let schema = S.schema(s => ({
+      email: s.m(S.string),
+      address: s.m(S.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Customers", schema)).toEqual(undefined);
+  });
+  globalThis.test("a word merely ending in `id` is not a key", () => {
+    let schema = S.schema(s => ({
+      paid: s.m(S.string),
+      valid: s.m(S.string)
+    }));
+    globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Invoices", schema)).toEqual(undefined);
+  });
+});
+
+globalThis.describe("deriveServerCapability — inferred keys reach the SDL surface", () => {
+  globalThis.test("an inferred key yields an eq filter and a sort field", () => {
+    let schema = S.schema(s => ({
+      orderId: s.m(S.string),
+      total: s.m(S.float)
+    }));
+    let c = GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Orders", schema);
+    globalThis.expect(c.filterFields.map(f => f.name)).toEqual(["orderId"]);
+    globalThis.expect(c.sortFields).toEqual(["orderId"]);
+  });
+  globalThis.test("an unresolvable key still yields nothing — the old behaviour, now narrowed", () => {
+    let schema = S.schema(s => ({
+      email: s.m(S.string)
+    }));
+    let c = GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Customers", schema);
+    globalThis.expect([
+      c.filterFields.length,
+      c.sortFields.length
+    ]).toEqual([
+      0,
+      0
+    ]);
+  });
+  globalThis.test("the filter input carries the inferred key's eq field", () => {
+    let schema = S.schema(s => ({
+      orderId: s.m(S.string)
+    }));
+    let input = GraphQL_FragmentGenerator$ReventlessCore.deriveConnectionFilterType("Ordering_OrderFilter", GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Orders", schema));
+    globalThis.expect(input.includes("orderIdEq: ID")).toBe(true);
+  });
+  globalThis.test("the order-by pair exists because of the inferred key", () => {
+    let schema = S.schema(s => ({
+      orderId: s.m(S.string)
+    }));
+    let types = GraphQL_FragmentGenerator$ReventlessCore.deriveConnectionOrderByType("Ordering_Order", GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Orders", schema));
+    globalThis.expect(types.length).toBe(2);
+    globalThis.expect(types.join("\n").includes("enum Ordering_OrderOrderField")).toBe(true);
+  });
+});
+
+let commandSchema$1 = S.union([
+  S.schema(s => ({
+    TAG: "AddProduct",
+    productId: s.m(S.string),
+    price: s.m(Money$Reventless.schema)
+  })),
+  S.schema(s => ({
+    TAG: "ArchiveProduct",
+    productId: s.m(S.string)
+  }))
+]);
+
+function commandAuthorization$1(param) {
+  return "AllowAuthenticated";
+}
+
+let AddProductCmd = {
+  commandSchema: commandSchema$1,
+  commandAuthorization: commandAuthorization$1
+};
+
+let commandSchema$2 = S.union([
+  S.schema(s => ({
+    TAG: "ChangeProductPrice",
+    productId: s.m(S.string),
+    price: s.m(Money$Reventless.schema)
+  })),
+  S.schema(s => ({
+    TAG: "ClearProductPrice",
+    productId: s.m(S.string)
+  }))
+]);
+
+function commandAuthorization$2(param) {
+  return "AllowAuthenticated";
+}
+
+let ChangePriceCmd = {
+  commandSchema: commandSchema$2,
+  commandAuthorization: commandAuthorization$2
+};
+
+globalThis.describe("semantic composites are named once, not once per field", () => {
+  let countDefs = (types, keyword, name) => types.filter(t => t.startsWith(keyword + ` ` + name + ` {`)).length;
+  let fragmentTypes = GraphQL_Stitcher$ReventlessCore.decode(GraphQL_FragmentGenerator$ReventlessCore.generate([
+    {
+      fieldNames: ["Catalog_AddProduct"],
+      commandSchema: commandSchema$1,
+      injectIdArg: false
+    },
+    {
+      fieldNames: ["Catalog_ChangeProductPrice"],
+      commandSchema: commandSchema$2,
+      injectIdArg: false
+    }
+  ], [])).types;
+  globalThis.test("two commands taking a price share one input definition", () => {
+    globalThis.expect(countDefs(fragmentTypes, "input", "MoneyInput")).toBe(1);
+  });
+  globalThis.test("and one currency enum between them", () => {
+    globalThis.expect(countDefs(fragmentTypes, "enum", "MoneyCurrency")).toBe(1);
+  });
+  globalThis.test("nothing is named after the field path that reached it", () => {
+    globalThis.expect(fragmentTypes.some(t => t.includes("AddProductPrice"))).toBe(false);
+  });
+  globalThis.test("the output position keeps the bare name", () => {
+    let types = GraphQL_FragmentGenerator$ReventlessCore.deriveObjectTypeWithNested("Catalog_Product", undefined, false, S.schema(s => ({
+      productId: s.m(S.string),
+      price: s.m(Money$Reventless.schema)
+    })));
+    globalThis.expect([
+      countDefs(types, "type", "Money"),
+      countDefs(types, "enum", "MoneyCurrency"),
+      types.some(t => t.includes("price: Money!"))
+    ]).toEqual([
+      1,
+      1,
+      true
+    ]);
+  });
+});
+
 export {
   OrderSliceCmd,
   mutationFor,
   GeocodeItem,
   typeDefFor,
+  AddProductCmd,
+  ChangePriceCmd,
 }
 /* commandSchema Not a pure module */

package/tests/api/OwnerScopeDiagnosticsTest.res

@@ -0,0 +1,109 @@
+open JestGlobals
+
+// This file asserts on EMITTED log output, so it pins the level it needs rather
+// than inheriting whatever the runner exported — `LOG_LEVEL=silent` would
+// suppress the warning and turn every case below green for the wrong reason.
+// `Logger` re-reads process.env on each call, so a file-scope assignment holds.
+NodeProcess.env->Dict.set("LOG_LEVEL", "warn")
+
+type consoleObj = {mutable log: string => unit}
+@val external console: consoleObj = "console"
+
+let capture = (fn: unit => unit): array<string> => {
+  let lines: array<string> = []
+  let original = console.log
+  console.log = s => lines->Array.push(s)
+  let result = try {
+    fn()
+    Ok()
+  } catch {
+  | e => Error(e)
+  }
+  console.log = original
+  switch result {
+  | Ok() => lines
+  | Error(e) => throw(e)
+  }
+}
+
+let warnFor = (~view, ~ownerField, ~elevated) => {
+  OwnerScopeDiagnostics.resetWarnings()
+  Reventless.OwnerScope.setElevatedGroups(elevated)
+  let lines = capture(() =>
+    OwnerScopeDiagnostics.warnIfNoElevatedGroups(~comp="Test", ~view, ~ownerField)
+  )
+  Reventless.OwnerScope.setElevatedGroups([])
+  lines
+}
+
+describe("OwnerScopeDiagnostics:", () => {
+  testSync("an owner-scoped view with no elevated groups warns", () =>
+    expect(warnFor(~view="Orders", ~ownerField=Some("customerId"), ~elevated=[])->Array.length)->toBe(
+      1,
+    )
+  )
+
+  // The consequence is the whole point of the line — an operator reading
+  // "configure elevated groups" without being told that admins are currently
+  // scoped has no reason to treat it as urgent.
+  testSync("the warning names the view, the field, and what will happen", () => {
+    let line =
+      warnFor(~view="Orders", ~ownerField=Some("customerId"), ~elevated=[])
+      ->Array.get(0)
+      ->Option.getOr("")
+    expect((
+      line->String.includes("Orders"),
+      line->String.includes("customerId"),
+      line->String.includes("only their own rows"),
+    ))->toEqual((true, true, true))
+  })
+
+  testSync("a view with no owner field is silent", () =>
+    expect(warnFor(~view="Products", ~ownerField=None, ~elevated=[])->Array.length)->toBe(0)
+  )
+
+  testSync("a configured deployment is silent", () =>
+    expect(
+      warnFor(~view="Orders", ~ownerField=Some("customerId"), ~elevated=["Admin"])->Array.length,
+    )->toBe(0)
+  )
+
+  // Registration runs more than once per process — tests build several
+  // platforms, a deploy walks every plugin. A line repeated per construction is
+  // one people learn to scroll past.
+  testSync("the same view warns once, not once per registration", () => {
+    OwnerScopeDiagnostics.resetWarnings()
+    Reventless.OwnerScope.setElevatedGroups([])
+    let lines = capture(() => {
+      OwnerScopeDiagnostics.warnIfNoElevatedGroups(
+        ~comp="Test",
+        ~view="Orders",
+        ~ownerField=Some("customerId"),
+      )
+      OwnerScopeDiagnostics.warnIfNoElevatedGroups(
+        ~comp="Test",
+        ~view="Orders",
+        ~ownerField=Some("customerId"),
+      )
+    })
+    expect(lines->Array.length)->toBe(1)
+  })
+
+  testSync("a second view gets its own warning", () => {
+    OwnerScopeDiagnostics.resetWarnings()
+    Reventless.OwnerScope.setElevatedGroups([])
+    let lines = capture(() => {
+      OwnerScopeDiagnostics.warnIfNoElevatedGroups(
+        ~comp="Test",
+        ~view="Orders",
+        ~ownerField=Some("customerId"),
+      )
+      OwnerScopeDiagnostics.warnIfNoElevatedGroups(
+        ~comp="Test",
+        ~view="Invoices",
+        ~ownerField=Some("payerId"),
+      )
+    })
+    expect(lines->Array.length)->toBe(2)
+  })
+})

package/tests/api/OwnerScopeDiagnosticsTest.res.mjs

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
+import * as OwnerScopeDiagnostics$ReventlessCore from "../../src/components/Api/OwnerScopeDiagnostics.res.mjs";
+
+process.env["LOG_LEVEL"] = "warn";
+
+function capture(fn) {
+  let lines = [];
+  let original = console.log;
+  console.log = s => {
+    lines.push(s);
+  };
+  let result;
+  try {
+    fn();
+    result = {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } catch (raw_e) {
+    let e = Primitive_exceptions.internalToException(raw_e);
+    result = {
+      TAG: "Error",
+      _0: e
+    };
+  }
+  console.log = original;
+  if (result.TAG === "Ok") {
+    return lines;
+  }
+  throw result._0;
+}
+
+function warnFor(view, ownerField, elevated) {
+  OwnerScopeDiagnostics$ReventlessCore.resetWarnings();
+  OwnerScope$Reventless.setElevatedGroups(elevated);
+  let lines = capture(() => OwnerScopeDiagnostics$ReventlessCore.warnIfNoElevatedGroups("Test", view, ownerField));
+  OwnerScope$Reventless.setElevatedGroups([]);
+  return lines;
+}
+
+globalThis.describe("OwnerScopeDiagnostics:", () => {
+  globalThis.test("an owner-scoped view with no elevated groups warns", () => {
+    globalThis.expect(warnFor("Orders", "customerId", []).length).toBe(1);
+  });
+  globalThis.test("the warning names the view, the field, and what will happen", () => {
+    let line = Stdlib_Option.getOr(warnFor("Orders", "customerId", [])[0], "");
+    globalThis.expect([
+      line.includes("Orders"),
+      line.includes("customerId"),
+      line.includes("only their own rows")
+    ]).toEqual([
+      true,
+      true,
+      true
+    ]);
+  });
+  globalThis.test("a view with no owner field is silent", () => {
+    globalThis.expect(warnFor("Products", undefined, []).length).toBe(0);
+  });
+  globalThis.test("a configured deployment is silent", () => {
+    globalThis.expect(warnFor("Orders", "customerId", ["Admin"]).length).toBe(0);
+  });
+  globalThis.test("the same view warns once, not once per registration", () => {
+    OwnerScopeDiagnostics$ReventlessCore.resetWarnings();
+    OwnerScope$Reventless.setElevatedGroups([]);
+    let lines = capture(() => {
+      OwnerScopeDiagnostics$ReventlessCore.warnIfNoElevatedGroups("Test", "Orders", "customerId");
+      OwnerScopeDiagnostics$ReventlessCore.warnIfNoElevatedGroups("Test", "Orders", "customerId");
+    });
+    globalThis.expect(lines.length).toBe(1);
+  });
+  globalThis.test("a second view gets its own warning", () => {
+    OwnerScopeDiagnostics$ReventlessCore.resetWarnings();
+    OwnerScope$Reventless.setElevatedGroups([]);
+    let lines = capture(() => {
+      OwnerScopeDiagnostics$ReventlessCore.warnIfNoElevatedGroups("Test", "Orders", "customerId");
+      OwnerScopeDiagnostics$ReventlessCore.warnIfNoElevatedGroups("Test", "Invoices", "payerId");
+    });
+    globalThis.expect(lines.length).toBe(2);
+  });
+});
+
+export {
+  capture,
+  warnFor,
+}
+/*  Not a pure module */

package/tests/api/SuryToJsonSchemaTest.res

@@ -73,6 +73,51 @@ describe("SuryToJsonSchema:", () => {
     })
   })
 
+  describe("deriveObjectSchema with an owner field:", () => {
+    let ownerOf = (json, name) =>
+      getPropertyOf(json, name)->Option.flatMap(s => getProperty(s, "x-reventless-owner"))
+
+    let json = SuryToJsonSchema.deriveObjectSchema(
+      S.schema(s =>
+        {
+          "customerId": s.matches(Reventless.Owner.string),
+          "note": s.matches(S.string),
+        }
+      )->S.castToUnknown,
+    )
+
+    testSync("the marked field carries x-reventless-owner", () =>
+      expect(ownerOf(json, "customerId"))->toEqual(Some(JSON.Encode.bool(true)))
+    )
+
+    // The control: ownership is opt-in, and an unmarked string must stay one.
+    // Without this, a bug that marked every field would still pass above.
+    testSync("an unmarked string field carries nothing", () =>
+      expect(ownerOf(json, "note"))->toBe(None)
+    )
+
+    testSync("the field is still a plain string on the wire", () =>
+      expect(
+        getPropertyOf(json, "customerId")->Option.flatMap(s => getProperty(s, "type")),
+      )->toEqual(Some(JSON.Encode.string("string")))
+    )
+
+    // An optional field keeps its marker inside the union wrapper. A reader that
+    // only inspects the outer schema answers "not the owner" here — which for a
+    // predicate that scopes reads means an unscoped view, silently. This is the
+    // case `Owner.isFieldOwner` exists for.
+    testSync("an optional owner field is still recognised", () => {
+      let optJson = SuryToJsonSchema.deriveObjectSchema(
+        S.schema(s =>
+          {
+            "customerId": s.matches(S.option(Reventless.Owner.string)),
+          }
+        )->S.castToUnknown,
+      )
+      expect(ownerOf(optJson, "customerId"))->toEqual(Some(JSON.Encode.bool(true)))
+    })
+  })
+
   describe("deriveObjectSchema with stateAnnotations metadata:", () => {
     let withSpec = (schema, spec) =>
       schema->S.Metadata.set(~id=Reventless.StateAnnotations.stateAnnotationsId, spec)

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -6,6 +6,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Email$Reventless from "@reventlessdev/reventless-spec/src/semantic/Email.res.mjs";
 import * as Money$Reventless from "@reventlessdev/reventless-spec/src/semantic/Money.res.mjs";
+import * as Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Percent$Reventless from "@reventlessdev/reventless-spec/src/semantic/Percent.res.mjs";
@@ -106,6 +107,28 @@ globalThis.describe("SuryToJsonSchema:", () => {
       globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(json, "name"), s => getProperty(s, "format"))).toBe(undefined);
     });
   });
+  globalThis.describe("deriveObjectSchema with an owner field:", () => {
+    let ownerOf = (json, name) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, "x-reventless-owner"));
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(S.schema(s => ({
+      customerId: s.m(Owner$Reventless.string),
+      note: s.m(S.string)
+    })));
+    globalThis.test("the marked field carries x-reventless-owner", () => {
+      globalThis.expect(ownerOf(json, "customerId")).toEqual(true);
+    });
+    globalThis.test("an unmarked string field carries nothing", () => {
+      globalThis.expect(ownerOf(json, "note")).toBe(undefined);
+    });
+    globalThis.test("the field is still a plain string on the wire", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(json, "customerId"), s => getProperty(s, "type"))).toEqual("string");
+    });
+    globalThis.test("an optional owner field is still recognised", () => {
+      let optJson = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(S.schema(s => ({
+        customerId: s.m(S.option(Owner$Reventless.string))
+      })));
+      globalThis.expect(ownerOf(optJson, "customerId")).toEqual(true);
+    });
+  });
   globalThis.describe("deriveObjectSchema with stateAnnotations metadata:", () => {
     let withSpec = (schema, spec) => S.Metadata.set(schema, StateAnnotations$Reventless.stateAnnotationsId, spec);
     globalThis.test("emits x-reventless-id on field listed in ids", () => {