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

package/tests/aggregate/AggregateSnapshotTest.res

@@ -1,4 +1,4 @@
-// Step 5 of docs/plans/aggregate-snapshotting.md — the Aggregate_Callback
+// Step 5 of docs/plans/done/aggregate-snapshotting.md — the Aggregate_Callback
 // snapshot wiring: a snapshot-enabled behavior seeds cold replays from the
 // latest persisted snapshot (hash-gated) and writes a fresh one every
 // `interval` events, fire-and-forget. Snapshots never affect correctness — the

package/tests/api/Api_IdsTest.res.mjs

@@ -77,7 +77,7 @@ globalThis.describe("filter.ids matches whichever form each side holds", () => {
         "ids",
         filterIds.map(prim => prim)
       ]]);
-    let conn = QueryDbListQuery$ReventlessCore.run([row(rowId)], args, GraphQL_FragmentGenerator$ReventlessCore.emptyCapability, "name", undefined, undefined);
+    let conn = QueryDbListQuery$ReventlessCore.run([row(rowId)], args, GraphQL_FragmentGenerator$ReventlessCore.emptyCapability, "name", undefined, undefined, undefined);
     return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(conn), d => d["edges"]), Stdlib_JSON.Decode.array), []).length;
   };
   globalThis.test("storage key row, storage key filter", () => {

package/tests/api/SuryToJsonSchemaTest.res

@@ -31,10 +31,11 @@ let emptySpec: Reventless.StateAnnotations.stateAnnotationSpec = {
   scanSort: [],
   semantic: [],
   metric: [],
-  status: None,
+  lifecycle: None,
   groupBy: None,
   visibility: None,
   live: None,
+  retired: None,
 }
 
 describe("SuryToJsonSchema:", () => {
@@ -420,6 +421,145 @@ describe("SuryToJsonSchema:", () => {
       ))->toEqual((Some("sum"), None))
     })
 
+    testSync("emits x-reventless-retired {label,showWhenFalse} on the retired field", () => {
+      let schema = S.schema(s =>
+        {
+          "id": s.matches(S.string),
+          "archived": s.matches(S.bool),
+        }
+      )->S.castToUnknown
+      let schema' =
+        schema->withSpec({
+          ...emptySpec,
+          retired: Some({field: "archived", label: "Archived", showWhenFalse: true, values: None}),
+        })
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let retiredObj =
+        getPropertyOf(json, "archived")->Option.flatMap(s => getProperty(s, "x-reventless-retired"))
+      expect((
+        retiredObj->Option.flatMap(r => getProperty(r, "label"))->Option.flatMap(JSON.Decode.string),
+        retiredObj
+        ->Option.flatMap(r => getProperty(r, "showWhenFalse"))
+        ->Option.flatMap(JSON.Decode.bool),
+        // Only the named field carries it.
+        getPropertyOf(json, "id")->Option.flatMap(s => getProperty(s, "x-reventless-retired")),
+      ))->toEqual((Some("Archived"), Some(true), None))
+    })
+
+    // The state form. `values` is what tells a consumer which of the two forms a
+    // view declared, so it travels on the same key and only when present.
+    let stateFormJson = (~values: array<string>) => {
+      let schema = S.schema(s =>
+        {
+          "customerId": s.matches(S.string),
+          "accountStatus": s.matches(S.union([S.literal("Active"), S.literal("Deactivated")])),
+        }
+      )->S.castToUnknown
+      schema
+      ->withSpec({
+        ...emptySpec,
+        lifecycle: Some("accountStatus"),
+        retired: Some({
+          field: "accountStatus",
+          label: "",
+          showWhenFalse: false,
+          values: Some(values),
+        }),
+      })
+      ->SuryToJsonSchema.deriveObjectSchema
+    }
+
+    let retiredOn = (json, field) =>
+      getPropertyOf(json, field)->Option.flatMap(s => getProperty(s, "x-reventless-retired"))
+
+    let stringsAt = (retiredObj, key) =>
+      retiredObj
+      ->Option.flatMap(r => getProperty(r, key))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.map(a => a->Array.filterMap(JSON.Decode.string))
+
+    testSync("carries one retirement state as a one-element set", () => {
+      expect(
+        stateFormJson(~values=["Deactivated"])->retiredOn("accountStatus")->stringsAt("values"),
+      )->toEqual(Some(["Deactivated"]))
+    })
+
+    testSync("carries every retirement state a lifecycle declares", () => {
+      expect(
+        stateFormJson(~values=["Archived", "Discontinued"])
+        ->retiredOn("accountStatus")
+        ->stringsAt("values"),
+      )->toEqual(Some(["Archived", "Discontinued"]))
+    })
+
+    // The transitional key, for one release. A consumer pinned before the set
+    // degrades to nothing at all rather than to a missing badge — and enforcement
+    // never depended on it, so the whole of the lag is cosmetic either way.
+    testSync("emits the singular value beside a one-element set", () => {
+      expect(
+        stateFormJson(~values=["Deactivated"])
+        ->retiredOn("accountStatus")
+        ->Option.flatMap(r => getProperty(r, "value"))
+        ->Option.flatMap(JSON.Decode.string),
+      )->toEqual(Some("Deactivated"))
+    })
+
+    // There is no singular reading of two states, so the shim simply stops. A
+    // consumer that understands only `value` sees no retirement rather than one
+    // of the two picked arbitrarily.
+    testSync("omits the singular value for a set of two", () => {
+      expect(
+        stateFormJson(~values=["Archived", "Discontinued"])
+        ->retiredOn("accountStatus")
+        ->Option.flatMap(r => getProperty(r, "value")),
+      )->toEqual(None)
+    })
+
+    // Absent rather than null: a consumer reads the key's absence as "the boolean
+    // form", the same way it reads an absent label as "derive one from the name".
+    testSync("omits both value and values entirely on the boolean form", () => {
+      let schema = S.schema(s => {"archived": s.matches(S.bool)})->S.castToUnknown
+      let schema' =
+        schema->withSpec({
+          ...emptySpec,
+          retired: Some({field: "archived", label: "", showWhenFalse: false, values: None}),
+        })
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let retiredObj = json->retiredOn("archived")
+      expect((
+        retiredObj->Option.flatMap(r => getProperty(r, "value")),
+        retiredObj->Option.flatMap(r => getProperty(r, "values")),
+      ))->toEqual((None, None))
+    })
+
+    testSync("omits the retired label when empty but always states showWhenFalse", () => {
+      let schema = S.schema(s => {"deactivated": s.matches(S.bool)})->S.castToUnknown
+      let schema' =
+        schema->withSpec({
+          ...emptySpec,
+          retired: Some({field: "deactivated", label: "", showWhenFalse: false, values: None}),
+        })
+      let json = SuryToJsonSchema.deriveObjectSchema(schema')
+      let retiredObj =
+        getPropertyOf(json, "deactivated")->Option.flatMap(s =>
+          getProperty(s, "x-reventless-retired")
+        )
+      expect((
+        retiredObj->Option.flatMap(r => getProperty(r, "label")),
+        retiredObj
+        ->Option.flatMap(r => getProperty(r, "showWhenFalse"))
+        ->Option.flatMap(JSON.Decode.bool),
+      ))->toEqual((None, Some(false)))
+    })
+
+    testSync("emits nothing for a schema with no retired annotation", () => {
+      let schema = S.schema(s => {"archived": s.matches(S.bool)})->S.castToUnknown
+      let json = SuryToJsonSchema.deriveObjectSchema(schema->withSpec(emptySpec))
+      expect(
+        getPropertyOf(json, "archived")->Option.flatMap(s => getProperty(s, "x-reventless-retired")),
+      )->toBe(None)
+    })
+
     testSync("emits x-reventless-group-by on the field named by groupBy", () => {
       let schema = S.schema(s =>
         {