@reventlessdev/reventless-core 3.0.0-alpha.253 → 3.0.0-alpha.255

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -13,8 +13,11 @@ import * as Percent$Reventless from "@reventlessdev/reventless-spec/src/semantic
 import * as Currency$Reventless from "@reventlessdev/reventless-spec/src/semantic/Currency.res.mjs";
 import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
 import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
+import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
 import * as DateRange$Reventless from "@reventlessdev/reventless-spec/src/semantic/DateRange.res.mjs";
+import * as MemberRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/MemberRef.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
@@ -130,6 +133,45 @@ globalThis.describe("SuryToJsonSchema:", () => {
       globalThis.expect(ownerOf(optJson, "customerId")).toEqual(true);
     });
   });
+  globalThis.describe("deriveObjectSchema with a sensitive field:", () => {
+    let sensitiveOf = (json, name) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, "x-reventless-sensitive"));
+    let ownerOf = (json, name) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, "x-reventless-owner"));
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({
+      resetToken: s.m(Sensitive$Reventless.string),
+      note: s.m(Sury.string),
+      contact: s.m(Email$Reventless.schema)
+    })));
+    globalThis.test("the marked field carries x-reventless-sensitive", () => {
+      globalThis.expect(sensitiveOf(json, "resetToken")).toEqual(true);
+    });
+    globalThis.test("an unmarked string field carries nothing", () => {
+      globalThis.expect(sensitiveOf(json, "note")).toBe(undefined);
+    });
+    globalThis.test("an email field is sensitive with no annotation", () => {
+      globalThis.expect(sensitiveOf(json, "contact")).toEqual(true);
+    });
+    globalThis.test("the field is still a plain string on the wire", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(json, "resetToken"), s => getProperty(s, "type"))).toEqual("string");
+    });
+    globalThis.test("an optional sensitive field is still recognised", () => {
+      let optJson = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({
+        resetToken: s.m(Sury.$option(Sensitive$Reventless.string))
+      })));
+      globalThis.expect(sensitiveOf(optJson, "resetToken")).toEqual(true);
+    });
+    globalThis.test("sensitivity composes with ownership on one field", () => {
+      let bothJson = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({
+        customerId: s.m(Sensitive$Reventless.mark(Owner$Reventless.string))
+      })));
+      globalThis.expect([
+        sensitiveOf(bothJson, "customerId"),
+        ownerOf(bothJson, "customerId")
+      ]).toEqual([
+        true,
+        true
+      ]);
+    });
+  });
   globalThis.describe("deriveObjectSchema with stateAnnotations metadata:", () => {
     globalThis.test("emits x-reventless-id on field listed in ids", () => {
       let schema = Sury.$schema(s => ({
@@ -872,6 +914,45 @@ globalThis.describe("SuryToJsonSchema:", () => {
       globalThis.expect(semanticOf(json, "imageUrl")).toEqual("storageRef");
     });
   });
+  globalThis.describe("a member-reference field:", () => {
+    let targetOf = (json, name) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, "x-reventless-semantic-target"));
+    globalThis.test("carries the collection, the view holding it, and what a member is", () => {
+      let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({
+        productImage: s.m(MemberRef$Reventless.of_(undefined, "Products", Semantic$Reventless.Id.imageRef, "productImages"))
+      })));
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(json, "productImage"), s => getProperty(s, "x-reventless-semantic"))).toEqual("memberRef");
+      globalThis.expect(targetOf(json, "productImage")).toEqual(Object.fromEntries([
+        [
+          "field",
+          "productImages"
+        ],
+        [
+          "view",
+          "Products"
+        ],
+        [
+          "content",
+          "imageRef"
+        ]
+      ]));
+    });
+    globalThis.test("omits the view where the collection is on this very record", () => {
+      globalThis.expect(targetOf(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({
+        productImage: s.m(MemberRef$Reventless.of_(undefined, undefined, undefined, "productImages"))
+      }))), "productImage")).toEqual(Object.fromEntries([[
+          "field",
+          "productImages"
+        ]]));
+    });
+    globalThis.test("declares no store, so nothing is provisioned for it", () => {
+      globalThis.expect(StorageRef$Reventless.getFieldStore(MemberRef$Reventless.of_(undefined, "Products", undefined, "productImages"))).toBe(undefined);
+    });
+    globalThis.test("stays a plain string on the wire", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({
+        productImage: s.m(MemberRef$Reventless.of_(undefined, undefined, undefined, "productImages"))
+      }))), "productImage"), s => getProperty(s, "type"))).toEqual("string");
+    });
+  });
   globalThis.describe("branded scalars keep their underlying shape:", () => {
     let keyOf = (json, name, key) => Stdlib_Option.flatMap(getPropertyOf(json, name), s => getProperty(s, key));
     let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(Sury.$schema(s => ({

package/tests/plugin/PluginStructureTest.res

@@ -1300,6 +1300,28 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       )->toBe(Some("currency"))
     })
 
+    testSync("@sensitive flows through the PPX to x-reventless-sensitive", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("contact")
+        ->Option.flatMap(s => getProperty(s, "x-reventless-sensitive"))
+        ->Option.flatMap(JSON.Decode.bool),
+      )->toBe(Some(true))
+    })
+
+    // The case the marker exists for. A renderer composes from an event payload,
+    // and the annotation path `deriveObjectSchema` reads for state is
+    // state-only — so a marker that lived there would be absent exactly where
+    // the value is about to be interpolated into a message.
+    testSync("@sensitive reaches an event variant's payload, not only state", () =>
+      expect(
+        Reventless.Sensitive.variantFieldNames(
+          PsAnnotatedView.consumedEventSchema->S.castToUnknown,
+          ~variant="ItemRecorded",
+        ),
+      )->toEqual(["contact"])
+    )
+
     testSync("@metric flows through the PPX to x-reventless-metric {aggregate,label}", () => {
       let metricObj =
         annotatedSchema

package/tests/plugin/PluginStructureTest.res.mjs

@@ -11,6 +11,7 @@ import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/component
 import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as Api_Naming$ReventlessCore from "../../src/components/Api/Api_Naming.res.mjs";
 import * as PsShipOrder$ReventlessCore from "./StateChangeSlice/PsShipOrder.res.mjs";
@@ -1444,6 +1445,12 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     globalThis.test("@semantic(\"currency\") flows through the PPX to x-reventless-semantic", () => {
       globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "total"), s => getProperty(s, "x-reventless-semantic")), Stdlib_JSON.Decode.string)).toBe("currency");
     });
+    globalThis.test("@sensitive flows through the PPX to x-reventless-sensitive", () => {
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "contact"), s => getProperty(s, "x-reventless-sensitive")), Stdlib_JSON.Decode.bool)).toBe(true);
+    });
+    globalThis.test("@sensitive reaches an event variant's payload, not only state", () => {
+      globalThis.expect(Sensitive$Reventless.variantFieldNames(PsAnnotatedView$ReventlessCore.consumedEventSchema, "ItemRecorded")).toEqual(["contact"]);
+    });
     globalThis.test("@metric flows through the PPX to x-reventless-metric {aggregate,label}", () => {
       let metricObj = Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "total"), s => getProperty(s, "x-reventless-metric"));
       globalThis.expect([

package/tests/plugin/StateViewSlice/PsAnnotatedView.res

@@ -7,7 +7,16 @@
 
 @schema
 type consumedEvent =
-  | ItemRecorded({itemId: string, ownerId: string, version: string, name: string, total: float})
+  | ItemRecorded({
+      itemId: string,
+      ownerId: string,
+      version: string,
+      name: string,
+      total: float,
+      // On the event, not just the state: a renderer composes from an event
+      // payload, so this is the case the marker has to reach.
+      @sensitive contact: string,
+    })
 
 @live(false)
 @schema
@@ -17,10 +26,11 @@ type state = {
   @index("byOwner") ownerId: string,
   name: string,
   @semantic("currency") @metric({aggregate: "sum", label: "Revenue"}) total: float,
+  @sensitive contact: string,
 }
 
 let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
   switch event {
-  | ItemRecorded({itemId, ownerId, version, name, total}) =>
-    [Set(itemId, {itemId, ownerId, version, name, total})]
+  | ItemRecorded({itemId, ownerId, version, name, total, contact}) =>
+    [Set(itemId, {itemId, ownerId, version, name, total, contact})]
   }

package/tests/plugin/StateViewSlice/PsAnnotatedView.res.mjs

@@ -3,6 +3,7 @@
 import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 
 let consumedEventSchema = Sury.$schema(s => ({
@@ -11,7 +12,8 @@ let consumedEventSchema = Sury.$schema(s => ({
   ownerId: s.m(DcbTag$Reventless.string),
   version: s.m(Sury.string),
   name: s.m(Sury.string),
-  total: s.m(Sury.float)
+  total: s.m(Sury.float),
+  contact: s.m(Sensitive$Reventless.string)
 }));
 
 let stateSchema = Sury.$schema(s => ({
@@ -19,7 +21,8 @@ let stateSchema = Sury.$schema(s => ({
   version: s.m(Sury.string),
   ownerId: s.m(Sury.string),
   name: s.m(Sury.string),
-  total: s.m(Sury.float)
+  total: s.m(Sury.float),
+  contact: s.m(Sensitive$Reventless.string)
 }));
 
 function project(param) {
@@ -33,7 +36,8 @@ function project(param) {
         version: event.version,
         ownerId: event.ownerId,
         name: event.name,
-        total: event.total
+        total: event.total,
+        contact: event.contact
       }
     }];
 }

package/tests/plugin/pluginDefinitionRequiredScalars.txt

@@ -94,6 +94,12 @@
 .structure.inboundTranslationSlices[].name: string
 .structure.inboundTranslationSlices[].targetName: string
 .structure.outboundTranslationSlices[].consumedEventTypes[]: string
+# `consumedSources` is itself `js_nullable` and is NEW, so no persisted payload
+# carries the array: a stored structure heals to null and this line is never
+# reached — the same call `traitDeclarations` made below. Required inside it
+# because a source name is a topic key the slice subscribes to, and a fabricated
+# `""` would name a topic that does not exist rather than saying nothing.
+.structure.outboundTranslationSlices[].consumedSources[]: string
 .structure.outboundTranslationSlices[].inboundCommandTypes[]: string
 .structure.outboundTranslationSlices[].name: string
 .structure.readModels[].consumedEventTypes[]: string