@reventlessdev/reventless-core 3.0.0-alpha.238 → 3.0.0-alpha.240

package/tests/plugin/PluginSpecExperiment.res.mjs

@@ -1,31 +1,29 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 
-S.enableJson();
-
-let recordSchema = S.schema(s => ({
-  a: s.m(S.meta(S.string, {
+let recordSchema = Sury.$schema(s => ({
+  a: s.m(Sury.meta(Sury.string, {
     description: "aaa"
   })),
-  b: s.m(S.string)
+  b: s.m(Sury.string)
 }));
 
-let variantSchema = S.union([
-  S.schema(s => ({
+let variantSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Q",
-    _0: s.m(S.int)
+    _0: s.m(Sury.int)
   })),
-  S.literal("X"),
-  S.literal("Y")
+  Sury.literal("X"),
+  Sury.literal("Y")
 ]);
 
-console.log("Record:", JSON.stringify(S.toJSONSchema(recordSchema), undefined, 2));
+console.log("Record:", JSON.stringify(Sury.toJSONSchema(recordSchema), undefined, 2));
 
-console.log("Variant:", JSON.stringify(S.toJSONSchema(variantSchema), undefined, 2));
+console.log("Variant:", JSON.stringify(Sury.toJSONSchema(variantSchema), undefined, 2));
 
 export {
   recordSchema,
   variantSchema,
 }
-/*  Not a pure module */
+/* recordSchema Not a pure module */

package/tests/plugin/PluginStructureTest.res

@@ -116,6 +116,34 @@ module PsUploadAvatarSlice: ReventlessInfra.StateChangeSlice.T = {
   let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
 }
 
+module PsUploadImagesSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsUploadImages
+  module Behavior = {
+    type state = PsUploadImages.state
+    let initialState = PsUploadImages.initialState
+    let evolve = PsUploadImages.evolve
+    let decide = PsUploadImages.decide
+    let moduleUrl = PsUploadImages.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
+}
+
+module PsTypoStoreSlice: ReventlessInfra.StateChangeSlice.T = {
+  module Spec = PsTypoStore
+  module Behavior = {
+    type state = PsTypoStore.state
+    let initialState = PsTypoStore.initialState
+    let evolve = PsTypoStore.evolve
+    let decide = PsTypoStore.decide
+    let moduleUrl = PsTypoStore.moduleUrl
+  }
+  let isAsync = false
+  type component = scsComponent
+  let make = (~dcbEventLog as _, ~publishJsons as _, ~tagKeysByEventType as _=?, ~crossPartitionTagKeys as _=?, ~runtime as _=?, ~opts as _=?): component => Obj.magic(0)
+}
+
 module PsChangePhotoSlice: ReventlessInfra.StateChangeSlice.T = {
   module Spec = PsChangePhoto
   module Behavior = {
@@ -277,7 +305,7 @@ describe("@transition cross-check", () => {
       )->ignore
       None
     } catch {
-    | Exn.Error(e) => Some(Exn.message(e)->Option.getOr(""))
+    | JsExn(e) => Some(JsExn.message(e)->Option.getOr(""))
     | _ => Some("")
     }
 
@@ -938,7 +966,7 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
           groupBy: None,
           visibility: None,
           live: None,
-          retired: Some({field, label: "", showWhenFalse: false, values: None}),
+          retired: Some({field, label: "", showWhenFalse: false, values: None, namedWhenRetired: false}),
         },
       )
 
@@ -973,6 +1001,7 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
               label: "",
               showWhenFalse: false,
               values: Some(["Deactivated", "Closed"]),
+              namedWhenRetired: false,
             }),
           },
         )
@@ -1017,6 +1046,108 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     })
   })
 
+  // A misspelled retirement state used to be fatal or merely logged depending on
+  // where the enum happened to be declared — the PPX refuses it when the enum is
+  // in the same file, and this pass, which sees the resolved schema, only warned.
+  // File layout is not a defensible arbiter of whether a data-exposure bug stops
+  // a build, so this rung was raised to match the other.
+  describe("@retired state names are checked against the field's own enum", () => {
+    let withRetiredStates = (schema, ~field, ~lifecycle, ~values) =>
+      schema->S.castToUnknown->S.Metadata.set(
+        ~id=Reventless.StateAnnotations.stateAnnotationsId,
+        {
+          ids: [],
+          compositeIds: [],
+          subIds: [],
+          compositeSubIds: [],
+          indexes: [],
+          hidden: [],
+          summary: [],
+          drillTargets: [],
+          drillTargetKeys: [],
+          collapsed: [],
+          scan: [],
+          scanSort: [],
+          semantic: [],
+          metric: [],
+          lifecycle,
+          groupBy: None,
+          visibility: None,
+          live: None,
+          retired: Some({field, label: "", showWhenFalse: false, values, namedWhenRetired: false}),
+        },
+      )
+
+    let shelf = values =>
+      S.schema(s =>
+        {
+          "shelf": s.matches(S.union([S.literal("Listed"), S.literal("Archived")])),
+        }
+      )->withRetiredStates(~field="shelf", ~lifecycle=Some("shelf"), ~values=Some(values))
+
+    let check = schema => Plugin_Structure.checkRetiredValue(~entityName="Products", schema)
+
+    testSync("a declared state passes", () => {
+      expect(check(shelf(["Archived"])))->toEqual(Plugin_Structure.Checked([]))
+    })
+
+    // Reported per state rather than as a set: one wrong entry among several
+    // still narrows something, so the symptom is a subset of rows leaking.
+    testSync("each undeclared state is reported on its own", () => {
+      switch check(shelf(["Archived", "Discontinud", "Withdrawn"])) {
+      | Checked(failures) =>
+        expect(failures->Array.length)->toBe(2)
+        expect(failures->Array.some(f => f->String.includes("Discontinud")))->toBe(true)
+        expect(failures->Array.some(f => f->String.includes("Withdrawn")))->toBe(true)
+        // Naming what the field does declare is what turns the failure into a fix.
+        expect(failures->Array.every(f => f->String.includes("Listed, Archived")))->toBe(true)
+      | other => expect(other)->toEqual(Plugin_Structure.Checked([]))
+      }
+    })
+
+    // The condition that came with promoting this: a fatal rule that is silent
+    // when it cannot run looks exactly like one that passed.
+    testSync("a field with no cases to compare against says so instead of passing", () => {
+      let schema =
+        S.schema(s => {"shelf": s.matches(S.string)})->withRetiredStates(
+          ~field="shelf",
+          ~lifecycle=Some("shelf"),
+          ~values=Some(["Archived"]),
+        )
+      switch check(schema) {
+      | Unchecked(why) => expect(why->String.includes("no cases"))->toBe(true)
+      | other => expect(other)->toEqual(Plugin_Structure.Unchecked(""))
+      }
+    })
+
+    // The boolean form names no state, so there is nothing to compare — which is
+    // not the same as having failed to compare it.
+    testSync("the boolean form is not a skip", () => {
+      let schema =
+        S.schema(s => {"archived": s.matches(S.bool)})->withRetiredStates(
+          ~field="archived",
+          ~lifecycle=None,
+          ~values=None,
+        )
+      expect(Plugin_Structure.checkRetiredValue(~entityName="Products", schema))->toEqual(
+        Plugin_Structure.NotDeclared,
+      )
+    })
+
+    // The second rule stays a warning: retirement still works, and which field
+    // carries it is a modelling judgement rather than a name that is wrong.
+    testSync("a state on a non-lifecycle field is not a failure", () => {
+      let schema =
+        S.schema(s =>
+          {
+            "shelf": s.matches(S.union([S.literal("Listed"), S.literal("Archived")])),
+            "lifecycle": s.matches(S.union([S.literal("Draft"), S.literal("Live")])),
+          }
+        )->withRetiredStates(~field="shelf", ~lifecycle=Some("lifecycle"), ~values=Some(["Archived"]))
+      expect(check(schema))->toEqual(Plugin_Structure.Checked([]))
+    })
+  })
+
   // Shared by the read-side and write-side schema cases below, which ask the
   // same question of the same emitter.
   let getProperty = (json: JSON.t, key: string): option<JSON.t> =>
@@ -1270,6 +1401,165 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     })
   })
 
+  // A field typed uploadable declares its store by being named. The collection
+  // walk is unchanged: it matches the `StoredIn` payload, never the semantic id,
+  // so a new id carrying one is provisioned by machinery that knows nothing
+  // about it.
+  describe("uploadable types derive their store from the field name", () => {
+    let withUploads = Plugin_Structure.make(
+      ~name="TestPlugin",
+      ~stateChangeSlices=[module(PsUploadImagesSlice)],
+    )
+    let stores = withUploads.requiredStores->Option.getOr([])
+
+    testSync("the derived store is the field name, pluralised", () =>
+      expect(stores->Array.includes("TestPlugin.productImages"))->toBe(true)
+    )
+
+    testSync("an optional field still declares its store", () =>
+      expect(stores->Array.includes("TestPlugin.categoryImages"))->toBe(true)
+    )
+
+    // The array marker lives on the element type. Reading the field schema
+    // directly answers `None`, which is the same silence as never declaring —
+    // so this asserts collection, not just that the fixture compiled.
+    testSync("an array field declares through its element", () =>
+      expect(stores->Array.includes("TestPlugin.datasheets"))->toBe(true)
+    )
+
+    testSync("an explicit @storageRef overrides the derived name", () =>
+      expect(stores->Array.includes("branding.logos"))->toBe(true)
+    )
+
+    testSync("nothing else is collected", () => expect(stores->Array.length)->toBe(4))
+
+    // The event field derives the same store as the command field of the same
+    // name, so the two collapse to one declaration site — the behaviour the
+    // annotation form already had, reached without an annotation.
+    testSync("each requirement keeps its declaring sites", () => {
+      let expected: array<Reventless.Plugin.requiredStoreDeclaration> = [
+        {
+          store: "TestPlugin.categoryImages",
+          component: "UploadImages",
+          field: "categoryImage",
+          annotation: Some("categoryImages"),
+        },
+        {
+          store: "TestPlugin.datasheets",
+          component: "UploadImages",
+          field: "datasheets",
+          annotation: Some("datasheets"),
+        },
+        {
+          store: "TestPlugin.productImages",
+          component: "UploadImages",
+          field: "productImage",
+          annotation: Some("productImages"),
+        },
+        {
+          store: "branding.logos",
+          component: "UploadImages",
+          field: "logo",
+          annotation: Some("branding.logos"),
+        },
+      ]
+      expect(withUploads.requiredStoreDeclarations)->toEqual(Some(expected))
+    })
+
+    let commandJson =
+      ((withUploads.stateChangeSlices->Array.getUnsafe(0)).commands->Array.getUnsafe(0)).schema
+      ->JSON.parseOrThrow
+
+    let semanticOf = field =>
+      commandJson
+      ->getPropertyOf(field)
+      ->Option.flatMap(s => getProperty(s, "x-reventless-semantic"))
+      ->Option.flatMap(JSON.Decode.string)
+
+    // The whole point of the family: one declaration states the content type
+    // too, so the UI stops learning "this is an image" from the field's name.
+    testSync("the wire carries the content half, not just the store", () =>
+      expect(semanticOf("productImage"))->toBe(Some("uploadableImage"))
+    )
+
+    // The override replaces the *store*, not the type's semantic: a field
+    // pointing at another plugin's store is still an image.
+    testSync("an overridden field keeps its uploadable semantic", () =>
+      expect(semanticOf("logo"))->toBe(Some("uploadableImage"))
+    )
+
+    testSync("the non-image arm carries its own id, on the element", () =>
+      expect(
+        commandJson
+        ->getPropertyOf("datasheets")
+        ->Option.flatMap(s => getProperty(s, "items"))
+        ->Option.flatMap(s => getProperty(s, "x-reventless-semantic"))
+        ->Option.flatMap(JSON.Decode.string),
+      )->toBe(Some("uploadableFile"))
+    )
+  })
+
+  // Deriving the store from the field name turns a typo into a second store
+  // rather than into a compile error, so the plugin has to refuse it.
+  describe("near-duplicate stores are refused", () => {
+    let failureText = () =>
+      try {
+        Plugin_Structure.make(
+          ~name="TestPlugin",
+          ~stateChangeSlices=[module(PsTypoStoreSlice)],
+        )->ignore
+        ""
+      } catch {
+      | JsExn(e) => JsExn.message(e)->Option.getOr("(no message)")
+      | _ => "(not a JS error)"
+      }
+
+    testSync("two stores one transposition apart fail the build", () =>
+      expect(failureText() != "")->toBe(true)
+    )
+
+    testSync("the failure names both stores and both fields", () => {
+      let text = failureText()
+      expect([
+        text->String.includes("TestPlugin.productImages"),
+        text->String.includes("TestPlugin.productImgaes"),
+        text->String.includes("TypoStore.productImage"),
+        text->String.includes("@storageRef"),
+      ])->toEqual([true, true, true, true])
+    })
+
+    // Every legitimate pair in the other fixtures has to stay legitimate — a
+    // check that fails on real designs is worse than the typo it catches.
+    testSync("the four stores of the uploadable fixture do not collide", () =>
+      expect(
+        Capability_Inference.collisions(
+          Plugin_Structure.make(
+            ~name="TestPlugin",
+            ~stateChangeSlices=[module(PsUploadImagesSlice)],
+          ).requiredStoreDeclarations->Option.getOr([]),
+        ),
+      )->toEqual([])
+    )
+
+    testSync("one edit, transpositions included; two edits not", () =>
+      expect(
+        [
+          ("productImages", "productImgaes"),
+          ("productImages", "productImage"),
+          ("logos", "logo"),
+          ("documents", "logos"),
+          ("productImages", "productImgeas"),
+        ]->Array.map(((a, b)) => Capability_Inference.withinOneEdit(a, b)),
+      )->toEqual([true, true, true, false, false])
+    )
+
+    // Reached only through an explicit override: two *derived* names cannot
+    // differ by number, because each is pluralised through its singular stem.
+    testSync("a singular/plural pair collides even at two edits apart", () =>
+      expect(Capability_Inference.sameStem("productImage", "productImages"))->toBe(true)
+    )
+  })
+
   // Making a field optional says the value may be absent. It does not say the
   // field stopped being a storage ref or a reference — but both walks read the
   // marker through `Semantic.get`, and an optional field's marker sits on the