@reventlessdev/reventless-aws 3.0.0-alpha.302 → 3.0.0-alpha.303

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res

@@ -113,6 +113,71 @@ describe("toEntryWith heals a structure persisted before a required list existed
   })
 })
 
+// The `statusField` → `lifecycleField` rename has the same shape of problem one
+// severity down: the SDL field is a nullable `String`, so an absent key answers
+// null rather than blackholing the query. That is worse to find, not better —
+// lists keep rendering while command-menu filtering, board columns, group
+// sections, progress trackers and state diagrams all go quiet. Asserted because
+// the shim is the one part of the rename with nothing to fail at compile time.
+describe("toEntryWith reads a pre-rename structure's lifecycle field", () => {
+  let legacyStructure = Dict.fromArray([
+    (
+      "readModels",
+      JSON.Encode.array([
+        JSON.parseOrThrow(`{"name": "Customers", "statusField": "locationStatus"}`),
+      ]),
+    ),
+    (
+      "stateViewSlices",
+      JSON.Encode.array([JSON.parseOrThrow(`{"name": "Orders", "statusField": "status"}`)]),
+    ),
+  ])->JSON.Encode.object
+
+  let fieldOf = (~collection) =>
+    entry(~filter=false, legacyStructure)
+    ->Option.map(members(_, collection))
+    ->Option.flatMap(Array.get(_, 0))
+    ->Option.flatMap(c => c->Dict.get("lifecycleField"))
+
+  testSync("a read model's legacy key answers on the new name", () =>
+    expect(fieldOf(~collection="readModels"))->toEqual(
+      Some(JSON.Encode.string("locationStatus")),
+    )
+  )
+
+  testSync("so does a state view slice's", () =>
+    expect(fieldOf(~collection="stateViewSlices"))->toEqual(Some(JSON.Encode.string("status")))
+  )
+
+  testSync("a post-rename structure is left alone", () => {
+    let current = Dict.fromArray([
+      (
+        "readModels",
+        JSON.Encode.array([
+          JSON.parseOrThrow(`{"name": "Orders", "lifecycleField": "lifecycle", "statusField": "stale"}`),
+        ]),
+      ),
+    ])->JSON.Encode.object
+    let field =
+      entry(~filter=false, current)
+      ->Option.map(members(_, "readModels"))
+      ->Option.flatMap(Array.get(_, 0))
+      ->Option.flatMap(c => c->Dict.get("lifecycleField"))
+    expect(field)->toEqual(Some(JSON.Encode.string("lifecycle")))
+  })
+
+  testSync("a structure declaring neither still answers nothing", () => {
+    let neither = Dict.fromArray([
+      ("readModels", JSON.Encode.array([JSON.parseOrThrow(`{"name": "Products"}`)])),
+    ])->JSON.Encode.object
+    let component =
+      entry(~filter=false, neither)
+      ->Option.map(members(_, "readModels"))
+      ->Option.flatMap(Array.get(_, 0))
+    expect(component->Option.flatMap(c => c->Dict.get("lifecycleField")))->toEqual(None)
+  })
+})
+
 // The persisted structure is pre-filter, so this handler is a twin of the
 // in-memory `encodePluginStructureEntry` rather than a consequence of it. A shell
 // reading `internalQueryables` against a platform that emits it on only one

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res.mjs

@@ -67,6 +67,42 @@ globalThis.describe("toEntryWith heals a structure persisted before a required l
   });
 });
 
+globalThis.describe("toEntryWith reads a pre-rename structure's lifecycle field", () => {
+  let legacyStructure = Object.fromEntries([
+    [
+      "readModels",
+      [JSON.parse(`{"name": "Customers", "statusField": "locationStatus"}`)]
+    ],
+    [
+      "stateViewSlices",
+      [JSON.parse(`{"name": "Orders", "statusField": "status"}`)]
+    ]
+  ]);
+  let fieldOf = collection => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, legacyStructure), __x => members(__x, collection)), __x => __x[0]), c => c["lifecycleField"]);
+  globalThis.test("a read model's legacy key answers on the new name", () => {
+    globalThis.expect(fieldOf("readModels")).toEqual("locationStatus");
+  });
+  globalThis.test("so does a state view slice's", () => {
+    globalThis.expect(fieldOf("stateViewSlices")).toEqual("status");
+  });
+  globalThis.test("a post-rename structure is left alone", () => {
+    let current = Object.fromEntries([[
+        "readModels",
+        [JSON.parse(`{"name": "Orders", "lifecycleField": "lifecycle", "statusField": "stale"}`)]
+      ]]);
+    let field = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, current), __x => members(__x, "readModels")), __x => __x[0]), c => c["lifecycleField"]);
+    globalThis.expect(field).toEqual("lifecycle");
+  });
+  globalThis.test("a structure declaring neither still answers nothing", () => {
+    let neither = Object.fromEntries([[
+        "readModels",
+        [JSON.parse(`{"name": "Products"}`)]
+      ]]);
+    let component = Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, neither), __x => members(__x, "readModels")), __x => __x[0]);
+    globalThis.expect(Stdlib_Option.flatMap(component, c => c["lifecycleField"])).toEqual(undefined);
+  });
+});
+
 globalThis.describe("toEntryWith carries Internal queryables on the filtered field", () => {
   let mixed = Object.fromEntries([
     [

package/tests/QueryDbResolvers_AppSyncTest.res.mjs

@@ -19,18 +19,18 @@ globalThis.describe("QueryDbResolvers_AppSync.internalRowRequiredAttr", () => {
 
 globalThis.describe("AppSync_Resolver_Retrying.Functions.listAllItemsConnection", () => {
   globalThis.test("with ~requireAttribute emits an attribute_exists filter that excludes internal rows", () => {
-    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, "name", undefined, undefined);
+    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, "name", undefined, undefined, undefined, undefined);
     globalThis.expect(code.includes("attribute_exists(#name)")).toBe(true);
     globalThis.expect(code.includes("names['#name'] = 'name'")).toBe(true);
   });
   globalThis.test("without ~requireAttribute emits no attribute_exists filter (default read models unchanged)", () => {
-    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined);
+    let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
     globalThis.expect(code.includes("attribute_exists")).toBe(false);
   });
 });
 
 globalThis.describe("listAllItemsConnection — Scan cursor round-trip (paging fixes 1–3)", () => {
-  let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined);
+  let code = AppSync_Resolver_Functions$PulumiAws.listAllItemsConnection("name", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
   globalThis.test("Fix 1: response encodes the real nextToken as the cursor", () => {
     globalThis.expect(code.includes("const next = ctx.result?.nextToken ?? null;")).toBe(true);
     globalThis.expect(code.includes("util.base64Encode(JSON.stringify({ token: next, index: i }))")).toBe(true);

package/tests/StateChangeDescriptorParityTest.res

@@ -29,7 +29,7 @@ describe("state-change descriptor parity", () => {
   testAsync("every implementation builds the same descriptor", async () => {
     let cases = await buildAll()
     // A silent zero-case run would pass while asserting nothing.
-    expect(cases->Array.length)->toBe(6)
+    expect(cases->Array.length)->toBe(11)
     cases->Array.forEach(c => {
       expect((c.name, c.relay))->toEqual((c.name, c.local))
       expect((c.name, c.postgres))->toEqual((c.name, c.local))
@@ -55,4 +55,85 @@ describe("state-change descriptor parity", () => {
     | None => expect("oversized case missing")->toBe("present")
     }
   })
+
+  // The live channel is the third place a retired row could reach a caller the
+  // resolvers refuse it to, and the only one that cannot be scoped per
+  // subscriber — the channel is keyed by view and entity, and everyone watching
+  // receives the frame. So the payload has to go, in all three implementations.
+  testAsync("a retired row publishes as metadata only, everywhere", async () => {
+    let cases = await buildAll()
+    let keyOf = (d: JSON.t, k) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(k))
+    let byName = name => cases->Array.find(c => c.name == name)
+
+    switch byName("retired row degrades to metadata only") {
+    | Some(c) =>
+      // Not just the payload: the sort value is a timestamp off a row the
+      // subscriber may not read, and this row carries one.
+      expect((keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((None, None))
+      expect((keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((None, None))
+      expect((keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((None, None))
+      // `Updated`, never `Removed`: the row is not gone. Saying so would be
+      // false for an elevated subscriber reading with `includeRetired`, and
+      // false again the moment the row is restored.
+      expect(keyOf(c.local, "changeKind"))->toEqual(Some(JSON.Encode.string("Updated")))
+    | None => expect("retired case missing")->toBe("present")
+    }
+
+    // The control that separates "drops a retired row" from "drops any row on a
+    // view that declares the flag".
+    switch byName("live row with a retirement flag carries the row") {
+    | Some(c) =>
+      expect(keyOf(c.local, "state")->Option.isSome)->toBe(true)
+      expect(keyOf(c.relay, "state")->Option.isSome)->toBe(true)
+      expect(keyOf(c.postgres, "state")->Option.isSome)->toBe(true)
+    | None => expect("live-with-flag case missing")->toBe("present")
+    }
+  })
+
+  // The state form, where the predicate is membership rather than equality. Both
+  // states are asserted, so an implementation comparing against only the first
+  // member of the set fails on the second — which is the shape of mistake a set
+  // invites and a single value could not.
+  testAsync("a row in any retired state publishes as metadata only", async () => {
+    let cases = await buildAll()
+    let keyOf = (d: JSON.t, k) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(k))
+    let byName = name => cases->Array.find(c => c.name == name)
+
+    [
+      "row in the first retired state degrades to metadata only",
+      "row in the second retired state degrades to metadata only",
+    ]->Array.forEach(name =>
+      switch byName(name) {
+      | Some(c) =>
+        expect((name, keyOf(c.local, "state"), keyOf(c.local, "sortKeyValue")))->toEqual((
+          name,
+          None,
+          None,
+        ))
+        expect((name, keyOf(c.relay, "state"), keyOf(c.relay, "sortKeyValue")))->toEqual((
+          name,
+          None,
+          None,
+        ))
+        expect((name, keyOf(c.postgres, "state"), keyOf(c.postgres, "sortKeyValue")))->toEqual((
+          name,
+          None,
+          None,
+        ))
+      | None => expect(name ++ " missing")->toBe("present")
+      }
+    )
+
+    // The control for the state form: a live state on the same lifecycle, so an
+    // implementation dropping every row of a view that declares states fails.
+    switch byName("row in a live state carries the row") {
+    | Some(c) =>
+      expect((
+        keyOf(c.local, "state")->Option.isSome,
+        keyOf(c.relay, "state")->Option.isSome,
+        keyOf(c.postgres, "state")->Option.isSome,
+      ))->toEqual((true, true, true))
+    | None => expect("live-state case missing")->toBe("present")
+    }
+  })
 })

package/tests/StateChangeDescriptorParityTest.res.mjs

@@ -11,7 +11,7 @@ function buildAll(prim) {
 globalThis.describe("state-change descriptor parity", () => {
   globalThis.test("every implementation builds the same descriptor", async () => {
     let cases = await StateChangeDescriptorParityMjs.buildAll();
-    globalThis.expect(cases.length).toBe(6);
+    globalThis.expect(cases.length).toBe(11);
     cases.forEach(c => {
       globalThis.expect([
         c.name,
@@ -52,6 +52,102 @@ globalThis.describe("state-change descriptor parity", () => {
       globalThis.expect("oversized case missing").toBe("present");
     }
   });
+  globalThis.test("a retired row publishes as metadata only, everywhere", async () => {
+    let cases = await StateChangeDescriptorParityMjs.buildAll();
+    let keyOf = (d, k) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(d), o => o[k]);
+    let byName = name => cases.find(c => c.name === name);
+    let c = byName("retired row degrades to metadata only");
+    if (c !== undefined) {
+      globalThis.expect([
+        keyOf(c.local, "state"),
+        keyOf(c.local, "sortKeyValue")
+      ]).toEqual([
+        undefined,
+        undefined
+      ]);
+      globalThis.expect([
+        keyOf(c.relay, "state"),
+        keyOf(c.relay, "sortKeyValue")
+      ]).toEqual([
+        undefined,
+        undefined
+      ]);
+      globalThis.expect([
+        keyOf(c.postgres, "state"),
+        keyOf(c.postgres, "sortKeyValue")
+      ]).toEqual([
+        undefined,
+        undefined
+      ]);
+      globalThis.expect(keyOf(c.local, "changeKind")).toEqual("Updated");
+    } else {
+      globalThis.expect("retired case missing").toBe("present");
+    }
+    let c$1 = byName("live row with a retirement flag carries the row");
+    if (c$1 !== undefined) {
+      globalThis.expect(Stdlib_Option.isSome(keyOf(c$1.local, "state"))).toBe(true);
+      globalThis.expect(Stdlib_Option.isSome(keyOf(c$1.relay, "state"))).toBe(true);
+      globalThis.expect(Stdlib_Option.isSome(keyOf(c$1.postgres, "state"))).toBe(true);
+    } else {
+      globalThis.expect("live-with-flag case missing").toBe("present");
+    }
+  });
+  globalThis.test("a row in any retired state publishes as metadata only", async () => {
+    let cases = await StateChangeDescriptorParityMjs.buildAll();
+    let keyOf = (d, k) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(d), o => o[k]);
+    let byName = name => cases.find(c => c.name === name);
+    [
+      "row in the first retired state degrades to metadata only",
+      "row in the second retired state degrades to metadata only"
+    ].forEach(name => {
+      let c = byName(name);
+      if (c !== undefined) {
+        globalThis.expect([
+          name,
+          keyOf(c.local, "state"),
+          keyOf(c.local, "sortKeyValue")
+        ]).toEqual([
+          name,
+          undefined,
+          undefined
+        ]);
+        globalThis.expect([
+          name,
+          keyOf(c.relay, "state"),
+          keyOf(c.relay, "sortKeyValue")
+        ]).toEqual([
+          name,
+          undefined,
+          undefined
+        ]);
+        globalThis.expect([
+          name,
+          keyOf(c.postgres, "state"),
+          keyOf(c.postgres, "sortKeyValue")
+        ]).toEqual([
+          name,
+          undefined,
+          undefined
+        ]);
+      } else {
+        globalThis.expect(name + " missing").toBe("present");
+      }
+    });
+    let c = byName("row in a live state carries the row");
+    if (c !== undefined) {
+      globalThis.expect([
+        Stdlib_Option.isSome(keyOf(c.local, "state")),
+        Stdlib_Option.isSome(keyOf(c.relay, "state")),
+        Stdlib_Option.isSome(keyOf(c.postgres, "state"))
+      ]).toEqual([
+        true,
+        true,
+        true
+      ]);
+    } else {
+      globalThis.expect("live-state case missing").toBe("present");
+    }
+  });
 });
 
 export {

package/tests/stateChangeDescriptorParity.mjs

@@ -49,6 +49,59 @@ const CASES = [
     entityKey: "p3",
     state: { id: "p3", blob: "x".repeat(70 * 1024), updatedAt: "2026-05-19T12:00:00Z" },
   },
+  // Retirement: the row is withdrawn, so every implementation must publish the
+  // metadata-only shape — no state, and no sortKeyValue either, even though this
+  // row carries an updatedAt that the same row would publish while live.
+  {
+    name: "retired row degrades to metadata only",
+    changeKind: "Updated",
+    entityKey: "p4",
+    state: { id: "p4", name: "Widget", archived: true, updatedAt: "2026-05-19T12:00:00Z" },
+    retiredField: "archived",
+  },
+  // The control: same field declared, flag false, so nothing changes. Without
+  // this, an implementation that dropped the payload unconditionally whenever a
+  // retiredField was configured would still pass the case above.
+  {
+    name: "live row with a retirement flag carries the row",
+    changeKind: "Updated",
+    entityKey: "p5",
+    state: { id: "p5", name: "Widget", archived: false, updatedAt: "2026-05-19T12:00:00Z" },
+    retiredField: "archived",
+  },
+  // The state form, and the reason it is a set: a lifecycle may end in more than
+  // one way, and both ways withdraw the row identically. Two cases rather than
+  // one so an implementation comparing against only the first member fails.
+  {
+    name: "row in the first retired state degrades to metadata only",
+    changeKind: "Updated",
+    entityKey: "p6",
+    state: { id: "p6", name: "Widget", shelfStatus: "Archived", updatedAt: "2026-05-19T12:00:00Z" },
+    retiredField: "shelfStatus",
+    retiredValues: ["Archived", "Discontinued"],
+  },
+  {
+    name: "row in the second retired state degrades to metadata only",
+    changeKind: "Updated",
+    entityKey: "p7",
+    state: {
+      id: "p7",
+      name: "Widget",
+      shelfStatus: "Discontinued",
+      updatedAt: "2026-05-19T12:00:00Z",
+    },
+    retiredField: "shelfStatus",
+    retiredValues: ["Archived", "Discontinued"],
+  },
+  // The state-form control: a live state on the same declared lifecycle.
+  {
+    name: "row in a live state carries the row",
+    changeKind: "Updated",
+    entityKey: "p8",
+    state: { id: "p8", name: "Widget", shelfStatus: "Listed", updatedAt: "2026-05-19T12:00:00Z" },
+    retiredField: "shelfStatus",
+    retiredValues: ["Archived", "Discontinued"],
+  },
   {
     name: "delete carries no row",
     changeKind: "Removed",
@@ -79,10 +132,17 @@ export async function buildAll() {
     return { ...descriptor, seq: "<seq>" };
   };
 
-  return CASES.map(({ name, changeKind, entityKey, state }) => ({
+  return CASES.map(({ name, changeKind, entityKey, state, retiredField, retiredValues }) => ({
     name,
     local: normalise(
-      local.make(changeKind, entityKey, state === undefined ? undefined : state, local.nextSequence()),
+      local.make(
+        changeKind,
+        entityKey,
+        state === undefined ? undefined : state,
+        local.nextSequence(),
+        retiredField,
+        retiredValues,
+      ),
     ),
     relay: normalise(
       relay.makeDescriptor(
@@ -93,10 +153,19 @@ export async function buildAll() {
         // OldImage, which makeDescriptor then drops.
         state === undefined ? { id: entityKey } : state,
         "49590300000000016818000000",
+        retiredField,
+        retiredValues,
       ),
     ),
     postgres: normalise(
-      postgres.makeDescriptor({ changeKind, entityKey, state, seq: postgres.nextSequence() }),
+      postgres.makeDescriptor({
+        changeKind,
+        entityKey,
+        state,
+        seq: postgres.nextSequence(),
+        retiredField,
+        retiredValues,
+      }),
     ),
   }));
 }