@reventlessdev/reventless-core 3.0.0-alpha.236 → 3.0.0-alpha.237

package/tests/plugin/PluginStructureTest.res

@@ -670,33 +670,189 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     )
   })
 
-  describe("statusField — the shape rule", () => {
-    let statusOf = schema =>
-      Plugin_Structure.statusFieldFromStateSchema(~entityName="Test", schema->S.castToUnknown)
+  describe("lifecycleField — the name rule and the shape rule", () => {
+    let lifecycleOf = schema =>
+      Plugin_Structure.lifecycleFieldFromStateSchema(~entityName="Test", schema->S.castToUnknown)
 
-    testSync("a `status` field holding a closed set of values is the lifecycle field", () => {
+    let withLifecycle = (schema, ~field) =>
+      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: Some(field),
+          groupBy: None,
+          visibility: None,
+          live: None,
+          retired: None,
+        },
+      )
+
+    testSync("a `lifecycle` field holding a closed set of values is the lifecycle field", () => {
       let schema = S.schema(s =>
         {
-          "status": s.matches(S.union([S.literal("Placed"), S.literal("Shipped")])),
+          "lifecycle": s.matches(S.union([S.literal("Placed"), S.literal("Shipped")])),
         }
       )
-      expect(statusOf(schema))->toEqual(Some("status"))
+      expect(lifecycleOf(schema))->toEqual(Some("lifecycle"))
     })
 
     testSync("an optional one counts too", () => {
       let schema = S.schema(s =>
         {
-          "status": s.matches(S.option(S.union([S.literal("Placed"), S.literal("Shipped")]))),
+          "lifecycle": s.matches(S.option(S.union([S.literal("Placed"), S.literal("Shipped")]))),
         }
       )
-      expect(statusOf(schema))->toEqual(Some("status"))
+      expect(lifecycleOf(schema))->toEqual(Some("lifecycle"))
     })
 
-    testSync("free text named `status` is not a lifecycle", () => {
+    testSync("free text named `lifecycle` is not a lifecycle", () => {
       // `allowedStates` filtering needs states to compare against; a string
-      // field named `status` gives a command menu nothing to match.
-      let schema = S.schema(s => {"status": s.matches(S.string)})
-      expect(statusOf(schema))->toEqual(None)
+      // field named `lifecycle` gives a command menu nothing to match.
+      let schema = S.schema(s => {"lifecycle": s.matches(S.string)})
+      expect(lifecycleOf(schema))->toEqual(None)
+    })
+
+    // The one behaviour the rename deliberately changes, so it is asserted rather
+    // than assumed. `status` is a promiscuous name — geocoding progress, todo-queue
+    // progress, translation audit outcome — and a convention keyed on it guessed
+    // often. A record whose lifecycle really does live in a field called `status`
+    // says so with `@lifecycle`.
+    testSync("an unannotated field named `status` resolves to None", () => {
+      let schema = S.schema(s =>
+        {
+          "status": s.matches(S.union([S.literal("Placed"), S.literal("Shipped")])),
+        }
+      )
+      expect(lifecycleOf(schema))->toEqual(None)
+    })
+
+    testSync("the annotation names a field the convention would never reach", () => {
+      let schema = S.schema(s =>
+        {
+          "locationStatus": s.matches(S.union([S.literal("Pending"), S.literal("Located")])),
+        }
+      )
+      expect(lifecycleOf(schema->withLifecycle(~field="locationStatus")))->toEqual(
+        Some("locationStatus"),
+      )
+    })
+  })
+
+  describe("retiredField — annotation and nothing else", () => {
+    let retiredOf = schema =>
+      Plugin_Structure.retiredFieldFromStateSchema(schema->S.castToUnknown)
+
+    let withRetired = (schema, ~field) =>
+      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: None,
+          groupBy: None,
+          visibility: None,
+          live: None,
+          retired: Some({field, label: "", showWhenFalse: false, values: None}),
+        },
+      )
+
+    // The state form. The value is published beside the field so a client holding
+    // the def holds the whole predicate — two places deriving one comparison is
+    // how they come to disagree about which rows a caller may see.
+    testSync("publishes the retirement state beside the field", () => {
+      let withState = schema =>
+        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: Some("accountStatus"),
+            groupBy: None,
+            visibility: None,
+            live: None,
+            retired: Some({
+              field: "accountStatus",
+              label: "",
+              showWhenFalse: false,
+              values: Some(["Deactivated", "Closed"]),
+            }),
+          },
+        )
+      let schema = S.schema(s => {"accountStatus": s.matches(S.string)})->withState
+      expect((
+        Plugin_Structure.retiredFieldFromStateSchema(schema),
+        Plugin_Structure.retiredValuesFromStateSchema(schema),
+      ))->toEqual((Some("accountStatus"), Some(["Deactivated", "Closed"])))
+    })
+
+    // Absent is what says "boolean form", so it has to stay tellable from a state
+    // form — including one naming nothing, which is `Some([])`.
+    testSync("publishes no states on the boolean form", () => {
+      let schema = S.schema(s => {"archived": s.matches(S.bool)})
+      expect(
+        Plugin_Structure.retiredValuesFromStateSchema(schema->withRetired(~field="archived")),
+      )->toEqual(None)
+    })
+
+    testSync("names the annotated field", () => {
+      let schema = S.schema(s => {"archived": s.matches(S.bool)})
+      expect(retiredOf(schema->withRetired(~field="archived")))->toEqual(Some("archived"))
+    })
+
+    // The whole reason this has no convention rung. `lifecycleField` may still fall
+    // back to a field literally named `lifecycle` because guessing wrong there makes
+    // a command menu filter oddly; guessing wrong here makes rows disappear for every caller who is not
+    // elevated, so an unannotated boolean stays as visible as it was.
+    testSync("declines a conventionally-named boolean nobody annotated", () => {
+      let schema = S.schema(s =>
+        {
+          "archived": s.matches(S.bool),
+          "deactivated": s.matches(S.bool),
+        }
+      )
+      expect(retiredOf(schema))->toEqual(None)
+    })
+
+    testSync("declines a schema carrying no annotation spec at all", () => {
+      let schema = S.schema(s => {"id": s.matches(S.string)})
+      expect(retiredOf(schema))->toEqual(None)
     })
   })
 

package/tests/plugin/PluginStructureTest.res.mjs

@@ -14,6 +14,7 @@ import * as Api_Naming$ReventlessCore from "../../src/components/Api/Api_Naming.
 import * as PsShipOrder$ReventlessCore from "./StateChangeSlice/PsShipOrder.res.mjs";
 import * as PsOrdersView$ReventlessCore from "./StateViewSlice/PsOrdersView.res.mjs";
 import * as PsPlaceOrder$ReventlessCore from "./StateChangeSlice/PsPlaceOrder.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as PsChangePhoto$ReventlessCore from "./StateChangeSlice/PsChangePhoto.res.mjs";
 import * as CapabilityManifest$Reventless from "@reventlessdev/reventless-spec/src/components/CapabilityManifest.res.mjs";
 import * as PsReserveStock$ReventlessCore from "./StateChangeSlice/PsReserveStock.res.mjs";
@@ -796,30 +797,166 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ]);
     });
   });
-  globalThis.describe("statusField — the shape rule", () => {
-    globalThis.test("a `status` field holding a closed set of values is the lifecycle field", () => {
+  globalThis.describe("lifecycleField — the name rule and the shape rule", () => {
+    let withLifecycle = (schema, field) => S.Metadata.set(schema, StateAnnotations$Reventless.stateAnnotationsId, {
+      ids: [],
+      compositeIds: [],
+      subIds: [],
+      compositeSubIds: [],
+      indexes: [],
+      hidden: [],
+      summary: [],
+      drillTargets: [],
+      drillTargetKeys: [],
+      collapsed: [],
+      scan: [],
+      scanSort: [],
+      semantic: [],
+      metric: [],
+      lifecycle: field,
+      groupBy: undefined,
+      visibility: undefined,
+      live: undefined,
+      retired: undefined
+    });
+    globalThis.test("a `lifecycle` field holding a closed set of values is the lifecycle field", () => {
       let schema = S.schema(s => ({
-        status: s.m(S.union([
+        lifecycle: s.m(S.union([
           S.literal("Placed"),
           S.literal("Shipped")
         ]))
       }));
-      globalThis.expect(Plugin_Structure$ReventlessCore.statusFieldFromStateSchema("Test", schema)).toEqual("status");
+      globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleFieldFromStateSchema("Test", schema)).toEqual("lifecycle");
     });
     globalThis.test("an optional one counts too", () => {
       let schema = S.schema(s => ({
-        status: s.m(S.option(S.union([
+        lifecycle: s.m(S.option(S.union([
           S.literal("Placed"),
           S.literal("Shipped")
         ])))
       }));
-      globalThis.expect(Plugin_Structure$ReventlessCore.statusFieldFromStateSchema("Test", schema)).toEqual("status");
+      globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleFieldFromStateSchema("Test", schema)).toEqual("lifecycle");
+    });
+    globalThis.test("free text named `lifecycle` is not a lifecycle", () => {
+      let schema = S.schema(s => ({
+        lifecycle: s.m(S.string)
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleFieldFromStateSchema("Test", schema)).toEqual(undefined);
+    });
+    globalThis.test("an unannotated field named `status` resolves to None", () => {
+      let schema = S.schema(s => ({
+        status: s.m(S.union([
+          S.literal("Placed"),
+          S.literal("Shipped")
+        ]))
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleFieldFromStateSchema("Test", schema)).toEqual(undefined);
+    });
+    globalThis.test("the annotation names a field the convention would never reach", () => {
+      let schema = S.schema(s => ({
+        locationStatus: s.m(S.union([
+          S.literal("Pending"),
+          S.literal("Located")
+        ]))
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleFieldFromStateSchema("Test", withLifecycle(schema, "locationStatus"))).toEqual("locationStatus");
+    });
+  });
+  globalThis.describe("retiredField — annotation and nothing else", () => {
+    let withRetired = (schema, field) => S.Metadata.set(schema, StateAnnotations$Reventless.stateAnnotationsId, {
+      ids: [],
+      compositeIds: [],
+      subIds: [],
+      compositeSubIds: [],
+      indexes: [],
+      hidden: [],
+      summary: [],
+      drillTargets: [],
+      drillTargetKeys: [],
+      collapsed: [],
+      scan: [],
+      scanSort: [],
+      semantic: [],
+      metric: [],
+      lifecycle: undefined,
+      groupBy: undefined,
+      visibility: undefined,
+      live: undefined,
+      retired: {
+        field: field,
+        label: "",
+        showWhenFalse: false,
+        values: undefined
+      }
+    });
+    globalThis.test("publishes the retirement state beside the field", () => {
+      let withState = schema => S.Metadata.set(schema, StateAnnotations$Reventless.stateAnnotationsId, {
+        ids: [],
+        compositeIds: [],
+        subIds: [],
+        compositeSubIds: [],
+        indexes: [],
+        hidden: [],
+        summary: [],
+        drillTargets: [],
+        drillTargetKeys: [],
+        collapsed: [],
+        scan: [],
+        scanSort: [],
+        semantic: [],
+        metric: [],
+        lifecycle: "accountStatus",
+        groupBy: undefined,
+        visibility: undefined,
+        live: undefined,
+        retired: {
+          field: "accountStatus",
+          label: "",
+          showWhenFalse: false,
+          values: [
+            "Deactivated",
+            "Closed"
+          ]
+        }
+      });
+      let schema = withState(S.schema(s => ({
+        accountStatus: s.m(S.string)
+      })));
+      globalThis.expect([
+        Plugin_Structure$ReventlessCore.retiredFieldFromStateSchema(schema),
+        Plugin_Structure$ReventlessCore.retiredValuesFromStateSchema(schema)
+      ]).toEqual([
+        "accountStatus",
+        [
+          "Deactivated",
+          "Closed"
+        ]
+      ]);
+    });
+    globalThis.test("publishes no states on the boolean form", () => {
+      let schema = S.schema(s => ({
+        archived: s.m(S.bool)
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.retiredValuesFromStateSchema(withRetired(schema, "archived"))).toEqual(undefined);
+    });
+    globalThis.test("names the annotated field", () => {
+      let schema = S.schema(s => ({
+        archived: s.m(S.bool)
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.retiredFieldFromStateSchema(withRetired(schema, "archived"))).toEqual("archived");
+    });
+    globalThis.test("declines a conventionally-named boolean nobody annotated", () => {
+      let schema = S.schema(s => ({
+        archived: s.m(S.bool),
+        deactivated: s.m(S.bool)
+      }));
+      globalThis.expect(Plugin_Structure$ReventlessCore.retiredFieldFromStateSchema(schema)).toEqual(undefined);
     });
-    globalThis.test("free text named `status` is not a lifecycle", () => {
+    globalThis.test("declines a schema carrying no annotation spec at all", () => {
       let schema = S.schema(s => ({
-        status: s.m(S.string)
+        id: s.m(S.string)
       }));
-      globalThis.expect(Plugin_Structure$ReventlessCore.statusFieldFromStateSchema("Test", schema)).toEqual(undefined);
+      globalThis.expect(Plugin_Structure$ReventlessCore.retiredFieldFromStateSchema(schema)).toEqual(undefined);
     });
   });
   let getProperty = (json, key) => {

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

@@ -79,10 +79,11 @@ let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stat
         label: "Revenue"
       }
     ]],
-  status: undefined,
+  lifecycle: undefined,
   groupBy: undefined,
   visibility: undefined,
-  live: false
+  live: false,
+  retired: undefined
 });
 
 let name = "AnnotatedView";

package/tests/plugin/pluginDefinitionRequiredScalars.txt

@@ -79,6 +79,7 @@
 .structure.readModels[].name: string
 .structure.readModels[].queryField: string
 .structure.readModels[].requiredAccess[]: string
+.structure.readModels[].retiredValues[]: string
 .structure.readModels[].schema: string
 .structure.readModels[].searchableFields[]: string
 .structure.requiredStoreDeclarations[].component: string
@@ -110,6 +111,7 @@
 .structure.stateViewSlices[].name: string
 .structure.stateViewSlices[].queryField: string
 .structure.stateViewSlices[].requiredAccess[]: string
+.structure.stateViewSlices[].retiredValues[]: string
 .structure.stateViewSlices[].schema: string
 .structure.stateViewSlices[].searchableFields[]: string
 .version: string