@reventlessdev/reventless-core 3.0.0-alpha.239 → 3.0.0-alpha.241

package/tests/api/GraphQL_FragmentGeneratorTest.res

@@ -368,7 +368,6 @@ let refDoorFragment = (~subIdField=?) =>
 // What a caller holding a pointer to a withheld row may learn about it, and what
 // the two doors that could never answer for one can now be asked.
 describe("the reference door and the archive argument", () => {
-  open Expect
 
   // The narrowness is the type's, not a rule each backend re-implements: a caller
   // cannot ask this door for a price, because there is no price on it.
@@ -511,3 +510,65 @@ describe("the by-index door", () => {
     ))->toEqual(("XByOwner", "XByOwnerId", "XByBy"))
   )
 })
+
+// ── @internal: a field that is not on the GraphQL surface ────────────────────
+//
+// A read model's `@schema type state` is otherwise simultaneously the storage
+// shape and the API shape. `@internal` separates them: the field stays in the
+// record and in storage, and every generated object type drops it.
+//
+// The declaration is read off the schema rather than passed in, which is the
+// point — the alternative is a hand-written exclude list beside the query entry,
+// kept in step with the record by whoever next edits it. That is exactly what
+// `PluginBaseFragment` maintained and what this replaces.
+//
+// The fixture is `PsInternalFieldsReadModel`, a spec file: the annotation machinery
+// runs under `@@reventless.spec`.
+
+describe("@internal keeps a field off the generated type", () => {
+  let stateSchema = PsInternalFieldsReadModel.stateSchema->S.castToUnknown
+
+  let types = (~excludeFields=?) =>
+    GraphQL_FragmentGenerator.deriveObjectTypeWithNested(
+      ~typeName="Platform_Widget",
+      ~excludeFields?,
+      stateSchema,
+    )->Array.join("\n")
+
+  testSync("the declared fields are absent", () =>
+    expect((
+      types()->String.includes("eventCollector"),
+      types()->String.includes("extensionNames"),
+    ))->toEqual((false, false))
+  )
+
+  testSync("and everything else is untouched", () =>
+    expect((types()->String.includes("name"), types()->String.includes("itemId")))->toEqual((
+      true,
+      true,
+    ))
+  )
+
+  // The caller's own exclusions still apply. The two lists answer different
+  // questions — one is a decision made where the entry is assembled, the other a
+  // declaration on the field — so the marker joins the list rather than
+  // replacing it.
+  testSync("a caller's excludeFields still applies alongside", () => {
+    let sdl = types(~excludeFields=["name"])
+    expect((sdl->String.includes("name"), sdl->String.includes("eventCollector")))->toEqual((
+      false,
+      false,
+    ))
+  })
+
+  // The published state schema and the SDL have to agree, because AutoUI builds
+  // its list query from the former and sends it against the latter. This is the
+  // pairing that used to need two hand-maintained lists to hold.
+  testSync("the published state schema drops them too", () => {
+    let json = SuryToJsonSchema.deriveObjectSchema(stateSchema)->JSON.stringify
+    expect((json->String.includes("eventCollector"), json->String.includes("name")))->toEqual((
+      false,
+      true,
+    ))
+  })
+})

package/tests/api/GraphQL_FragmentGeneratorTest.res.mjs

@@ -1,20 +1,22 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 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 SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+import * as PsInternalFieldsReadModel$ReventlessCore from "./PsInternalFieldsReadModel.res.mjs";
 import * as OutboundTranslationSlice_Callback$ReventlessCore from "../../src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "CancelOrder",
-    orderId: s.m(S.string)
+    orderId: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "ReopenOrder",
-    orderId: s.m(S.string)
+    orderId: s.m(Sury.string)
   }))
 ]);
 
@@ -52,9 +54,9 @@ globalThis.describe("GraphQL_FragmentGenerator.generate mutation id injection",
   });
 });
 
-let outboundItemSchema = S.schema(s => ({
-  customerId: s.m(S.string),
-  address: s.m(S.string)
+let outboundItemSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  address: s.m(Sury.string)
 }));
 
 let GeocodeItem = {
@@ -86,9 +88,9 @@ 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)
+    let schema = Sury.$schema(s => ({
+      productId: s.m(Sury.string),
+      name: s.m(Sury.string)
     }));
     globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("AvailableProducts", schema)).toEqual([
       "productId",
@@ -96,9 +98,9 @@ globalThis.describe("resolveKeyField — the ladder", () => {
     ]);
   });
   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)
+    let schema = Sury.$schema(s => ({
+      productId: s.m(Sury.string),
+      categoryId: s.m(Sury.string)
     }));
     globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Products", schema)).toEqual([
       "productId",
@@ -106,9 +108,9 @@ globalThis.describe("resolveKeyField — the ladder", () => {
     ]);
   });
   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)
+    let schema = Sury.$schema(s => ({
+      categoryId: s.m(Sury.string),
+      ownerId: s.m(Sury.string)
     }));
     globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Categories", schema)).toEqual([
       "categoryId",
@@ -116,23 +118,23 @@ globalThis.describe("resolveKeyField — the ladder", () => {
     ]);
   });
   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)
+    let schema = Sury.$schema(s => ({
+      productId: s.m(Sury.string),
+      categoryId: s.m(Sury.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)
+    let schema = Sury.$schema(s => ({
+      email: s.m(Sury.string),
+      address: s.m(Sury.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)
+    let schema = Sury.$schema(s => ({
+      paid: s.m(Sury.string),
+      valid: s.m(Sury.string)
     }));
     globalThis.expect(GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField("Invoices", schema)).toEqual(undefined);
   });
@@ -140,17 +142,17 @@ globalThis.describe("resolveKeyField — the ladder", () => {
 
 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 schema = Sury.$schema(s => ({
+      orderId: s.m(Sury.string),
+      total: s.m(Sury.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 schema = Sury.$schema(s => ({
+      email: s.m(Sury.string)
     }));
     let c = GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Customers", schema);
     globalThis.expect([
@@ -162,15 +164,15 @@ globalThis.describe("deriveServerCapability — inferred keys reach the SDL surf
     ]);
   });
   globalThis.test("the filter input carries the inferred key's eq field", () => {
-    let schema = S.schema(s => ({
-      orderId: s.m(S.string)
+    let schema = Sury.$schema(s => ({
+      orderId: s.m(Sury.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 schema = Sury.$schema(s => ({
+      orderId: s.m(Sury.string)
     }));
     let types = GraphQL_FragmentGenerator$ReventlessCore.deriveConnectionOrderByType("Ordering_Order", GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability("Orders", schema));
     globalThis.expect(types.length).toBe(2);
@@ -178,15 +180,15 @@ globalThis.describe("deriveServerCapability — inferred keys reach the SDL surf
   });
 });
 
-let commandSchema$1 = S.union([
-  S.schema(s => ({
+let commandSchema$1 = Sury.union([
+  Sury.$schema(s => ({
     TAG: "AddProduct",
-    productId: s.m(S.string),
+    productId: s.m(Sury.string),
     price: s.m(Money$Reventless.schema)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "ArchiveProduct",
-    productId: s.m(S.string)
+    productId: s.m(Sury.string)
   }))
 ]);
 
@@ -199,15 +201,15 @@ let AddProductCmd = {
   commandAuthorization: commandAuthorization$1
 };
 
-let commandSchema$2 = S.union([
-  S.schema(s => ({
+let commandSchema$2 = Sury.union([
+  Sury.$schema(s => ({
     TAG: "ChangeProductPrice",
-    productId: s.m(S.string),
+    productId: s.m(Sury.string),
     price: s.m(Money$Reventless.schema)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "ClearProductPrice",
-    productId: s.m(S.string)
+    productId: s.m(Sury.string)
   }))
 ]);
 
@@ -244,8 +246,8 @@ globalThis.describe("semantic composites are named once, not once per field", ()
     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),
+    let types = GraphQL_FragmentGenerator$ReventlessCore.deriveObjectTypeWithNested("Catalog_Product", undefined, false, Sury.$schema(s => ({
+      productId: s.m(Sury.string),
       price: s.m(Money$Reventless.schema)
     })));
     globalThis.expect([
@@ -260,17 +262,17 @@ globalThis.describe("semantic composites are named once, not once per field", ()
   });
 });
 
-let shippingMethodSchema = S.union([
-  S.literal("Standard"),
-  S.literal("Express")
+let shippingMethodSchema = Sury.union([
+  Sury.literal("Standard"),
+  Sury.literal("Express")
 ]);
 
-let schema = S.schema(s => ({
-  orderId: s.m(S.string),
+let schema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
   shippingMethod: s.m(shippingMethodSchema),
   total: s.m(Money$Reventless.schema),
-  tip: s.m(S.option(Money$Reventless.schema)),
-  itemCount: s.m(S.int)
+  tip: s.m(Sury.$option(Money$Reventless.schema)),
+  itemCount: s.m(Sury.int)
 }));
 
 let PlaceOrder = {
@@ -322,9 +324,9 @@ globalThis.describe("GraphQL_FragmentGenerator.mutationArgTypes", () => {
   });
 });
 
-let stateSchema = S.schema(s => ({
-  id: s.m(S.string),
-  name: s.m(S.string)
+let stateSchema = Sury.$schema(s => ({
+  id: s.m(Sury.string),
+  name: s.m(Sury.string)
 }));
 
 let RefDoorRow = {
@@ -427,6 +429,48 @@ globalThis.describe("the by-index door", () => {
   });
 });
 
+globalThis.describe("@internal keeps a field off the generated type", () => {
+  let types = excludeFields => GraphQL_FragmentGenerator$ReventlessCore.deriveObjectTypeWithNested("Platform_Widget", excludeFields, undefined, PsInternalFieldsReadModel$ReventlessCore.stateSchema).join("\n");
+  globalThis.test("the declared fields are absent", () => {
+    globalThis.expect([
+      types(undefined).includes("eventCollector"),
+      types(undefined).includes("extensionNames")
+    ]).toEqual([
+      false,
+      false
+    ]);
+  });
+  globalThis.test("and everything else is untouched", () => {
+    globalThis.expect([
+      types(undefined).includes("name"),
+      types(undefined).includes("itemId")
+    ]).toEqual([
+      true,
+      true
+    ]);
+  });
+  globalThis.test("a caller's excludeFields still applies alongside", () => {
+    let sdl = types(["name"]);
+    globalThis.expect([
+      sdl.includes("name"),
+      sdl.includes("eventCollector")
+    ]).toEqual([
+      false,
+      false
+    ]);
+  });
+  globalThis.test("the published state schema drops them too", () => {
+    let json = JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(PsInternalFieldsReadModel$ReventlessCore.stateSchema));
+    globalThis.expect([
+      json.includes("eventCollector"),
+      json.includes("name")
+    ]).toEqual([
+      false,
+      true
+    ]);
+  });
+});
+
 export {
   OrderSliceCmd,
   mutationFor,

package/tests/api/PsInternalFieldsReadModel.res

@@ -0,0 +1,21 @@
+// Fixture for `@internal`: a state record whose storage shape and API shape
+// differ. `eventCollector` and `extensionNames` are projected and stored and
+// belong on no generated surface; everything else is ordinary.
+//
+// A spec file rather than a module inside the test, and named `*ReadModel*`
+// deliberately: the annotation machinery runs under `@@reventless.spec` AND only
+// for a file the PPX recognises as a read model or state view. That is also the
+// honest scope for `@internal` — it describes a read model's state.
+
+@@reventless.spec("InternalFieldsReadModel")
+
+@schema
+type consumedEvent = ItemRecorded({itemId: string, name: string})
+
+@schema
+type state = {
+  @id itemId: string,
+  name: string,
+  @internal eventCollector: string,
+  @internal extensionNames: array<string>,
+}

package/tests/api/PsInternalFieldsReadModel.res.mjs

@@ -0,0 +1,74 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "ItemRecorded",
+  itemId: s.m(Sury.string),
+  name: s.m(Sury.string)
+}));
+
+let stateSchema = Sury.$schema(s => ({
+  itemId: s.m(Sury.string),
+  name: s.m(Sury.string),
+  eventCollector: s.m(Sury.string),
+  extensionNames: s.m(Sury.array(Sury.string))
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let makeId = (state => state.itemId);
+
+let stateSchema$1 = Sury.$Metadata_set(stateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: ["itemId"],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  internal: [
+    "eventCollector",
+    "extensionNames"
+  ],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  semantic: [],
+  metric: [],
+  lifecycle: undefined,
+  groupBy: undefined,
+  visibility: undefined,
+  live: undefined,
+  retired: undefined
+});
+
+let name = "InternalFieldsReadModel";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/tests/api/PsInternalFieldsReadModel.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  config,
+  subIdConfig,
+  makeId,
+  stateSchema$1 as stateSchema,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* consumedEventSchema Not a pure module */

package/tests/api/StorageRefFieldsTest.res.mjs

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as StorageRefFields$ReventlessCore from "../../src/components/Api/StorageRefFields.res.mjs";
 
 function variant(tag, fields) {
-  return S.object(s => {
-    s.f("TAG", S.literal(tag));
+  return Sury.object(s => {
+    s.f("TAG", Sury.literal(tag));
     fields.forEach(param => {
       s.f(param[0], param[1]);
     });
@@ -17,7 +17,7 @@ let ref_ = StorageRef$Reventless.forStore;
 
 globalThis.describe("StorageRefFields.fromEventSchema", () => {
   globalThis.test("finds a declared single-valued ref field and qualifies its store", () => {
-    let schema = S.union([variant("ProductImageChanged", [[
+    let schema = Sury.union([variant("ProductImageChanged", [[
           "imageUrl",
           StorageRef$Reventless.forStore(undefined, "productImages")
         ]])]);
@@ -31,16 +31,16 @@ globalThis.describe("StorageRefFields.fromEventSchema", () => {
       }]);
   });
   globalThis.test("a qualified declaration keeps the store it names", () => {
-    let schema = S.union([variant("OrderPhotoAttached", [[
+    let schema = Sury.union([variant("OrderPhotoAttached", [[
           "photo",
           StorageRef$Reventless.forStore("Catalog", "productImages")
         ]])]);
     globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Ordering", schema).flatMap(e => e.fields.map(f => f.store))).toEqual(["Catalog.productImages"]);
   });
   globalThis.test("finds a multi-valued ref field and records its arity", () => {
-    let schema = S.union([variant("GalleryReplaced", [[
+    let schema = Sury.union([variant("GalleryReplaced", [[
           "imageUrls",
-          S.array(StorageRef$Reventless.forStore(undefined, "productImages"))
+          Sury.array(StorageRef$Reventless.forStore(undefined, "productImages"))
         ]])]);
     globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema).flatMap(e => e.fields)).toEqual([{
         field: "imageUrls",
@@ -49,10 +49,10 @@ globalThis.describe("StorageRefFields.fromEventSchema", () => {
       }]);
   });
   globalThis.test("a variant with no declared field is omitted entirely", () => {
-    let schema = S.union([
+    let schema = Sury.union([
       variant("ProductRenamed", [[
           "name",
-          S.string
+          Sury.string
         ]]),
       variant("ProductImageChanged", [[
           "imageUrl",
@@ -62,16 +62,16 @@ globalThis.describe("StorageRefFields.fromEventSchema", () => {
     globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema).map(e => e.eventType)).toEqual(["ProductImageChanged"]);
   });
   globalThis.test("an event schema with no declaration anywhere yields nothing", () => {
-    let schema = S.union([variant("ProductRenamed", [[
+    let schema = Sury.union([variant("ProductRenamed", [[
           "name",
-          S.string
+          Sury.string
         ]])]);
     globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema)).toEqual([]);
   });
   globalThis.test("an unannotated string field is not treated as a ref", () => {
-    let schema = S.union([variant("ProductImported", [[
+    let schema = Sury.union([variant("ProductImported", [[
           "imageUrl",
-          S.string
+          Sury.string
         ]])]);
     globalThis.expect(StorageRefFields$ReventlessCore.fromEventSchema("Catalog", schema)).toEqual([]);
   });

package/tests/api/SuryToJsonSchemaTest.res

@@ -256,6 +256,49 @@ describe("SuryToJsonSchema:", () => {
       ))->toEqual((Some(true), None))
     })
 
+    // `@internal` drops the property rather than marking it. A marker is the
+    // right answer for a field that is on the surface and merely unwanted — that
+    // is `@hidden`, above. This one is not on the surface at all, so an entry
+    // here would describe a field the SDL does not declare, which is the
+    // mismatch that makes a generated list query name fields the server rejects.
+    testSync("drops a field listed in internal rather than annotating it", () => {
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "eventCollector": s.matches(S.string),
+        }
+      )->S.castToUnknown
+      let schema' = schema->withSpec({...emptySpec, internal: ["eventCollector"]})
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      expect((
+        getPropertyOf(json, "eventCollector")->Option.isNone,
+        getPropertyOf(json, "id")->Option.isSome,
+      ))->toEqual((true, true))
+    })
+
+    // A dropped property must not be left behind in `required`, or a consumer
+    // building a form from the schema asks for a field it was never given.
+    testSync("keeps a dropped field out of required", () => {
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "eventCollector": s.matches(S.string),
+        }
+      )->S.castToUnknown
+      let json =
+        schema
+        ->withSpec({...emptySpec, internal: ["eventCollector"]})
+        ->SuryToJsonSchema.deriveObjectSchema
+      expect(
+        json
+        ->JSON.Decode.object
+        ->Option.flatMap(o => o->Dict.get("required"))
+        ->Option.flatMap(JSON.Decode.array)
+        ->Option.getOr([])
+        ->Array.filterMap(JSON.Decode.string),
+      )->toEqual(["id"])
+    })
+
     testSync("emits x-reventless-summary on field listed in summary", () => {
       let schema = S.schema(s =>
         {