@reventlessdev/reventless-aws 3.0.0-alpha.274 → 3.0.0-alpha.275

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.275 (2026-08-09)
+
+### Bug Fixes
+
+* **aws:** fire the deploy-time re-detect after the deferred plugin callback ([b373ff1](https://github.com/ReventlessDev/reventless-core/commit/b373ff19cf910328c098ca63d5e52015d070a236))
+* **aws:** heal a persisted structure that predates a required list field ([dc4c42c](https://github.com/ReventlessDev/reventless-core/commit/dc4c42cab5a7db538d90edbce6d13b949830aad6))
+
+
 # 3.0.0-alpha.274 (2026-08-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.274",
+  "version": "3.0.0-alpha.275",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -12,18 +12,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.4",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.5",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-node": "2.0.0-alpha.2",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.67",
+    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.68",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.217",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.129",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.218",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.82",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.128",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.81",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.102"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.103"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -2472,38 +2472,51 @@ module MakeWithConfig = (
     // fails) the handover still completes on the next natural heartbeat — graceful
     // degradation.
     // heartbeatConfigRef holds the just-built plugin's config (deployPlugin builds
-    // exactly one plugin per call, and registerHeartbeatConfig ran during P.make()).
-    let hbConfig = PluginRuntime_Builder.heartbeatConfigRef.contents
-    switch (Pulumi.Pulumi.isDryRun(), hbConfig.epQueueUrl) {
-    | (true, _) => () // `pulumi preview` — no deploy-time side effects
-    | (false, Some(epQueueUrl)) =>
-      let _ = epQueueUrl->Pulumi.Output.apply(async url => {
-        let queue: Util_SQS_Runtime.resolvedQueue = {id: url, name: "", arn: ""}
-        let publishHeartbeat = queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO)
-        let message: ReventlessCore.Message.commandJson = {
-          id: hbConfig.pluginId,
-          meta: ReventlessCore.Message.generateMeta(
-            ~service=ReventlessInfra.PluginExtensionPointSpec.name,
-            ~user="DeployHeartbeat",
-          ),
-          commandJson: ReventlessInfra.PluginExtensionPointSpec.RedetectPlugin(
-            hbConfig.heartbeatTimeout,
-          )->S.reverseConvertToJsonOrThrow(ReventlessInfra.PluginExtensionPointSpec.commandSchema),
-        }
-        try await publishHeartbeat([message]) catch {
-        | _ =>
-          log.warn(
-            ~comp="Platform:deployPlugin",
-            `synthetic heartbeat failed for ${hbConfig.pluginId} (handover falls back to the next natural heartbeat)`,
-          )
-        }
-      })
-    | (false, None) =>
-      log.warn(
-        ~comp="Platform:deployPlugin",
-        "synthetic heartbeat skipped: no EP queue URL in heartbeat config",
-      )
-    }
+    // exactly one plugin per call), but it is written from the
+    // onHeartbeatEpChannelAvailable hook, which core fires from inside the deferred
+    // construct callback — after `P.make()` has returned. Reading it here
+    // synchronously always saw the initial empty config, so the publish was skipped
+    // on every deploy. `pluginOutputs.heartbeat` derives from that same callback's
+    // output, so applying to it is the earliest point the config is populated.
+    let _ = pluginOutputs.heartbeat->Pulumi.Output.apply(_ => {
+      let hbConfig = PluginRuntime_Builder.heartbeatConfigRef.contents
+      switch (Pulumi.Pulumi.isDryRun(), hbConfig.epQueueUrl) {
+      | (true, _) => () // `pulumi preview` — no deploy-time side effects
+      | (false, Some(epQueueUrl)) =>
+        let _ = epQueueUrl->Pulumi.Output.apply(async url => {
+          let queue: Util_SQS_Runtime.resolvedQueue = {id: url, name: "", arn: ""}
+          let publishHeartbeat = queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO)
+          let message: ReventlessCore.Message.commandJson = {
+            id: hbConfig.pluginId,
+            meta: ReventlessCore.Message.generateMeta(
+              ~service=ReventlessInfra.PluginExtensionPointSpec.name,
+              ~user="DeployHeartbeat",
+            ),
+            commandJson: ReventlessInfra.PluginExtensionPointSpec.RedetectPlugin(
+              hbConfig.heartbeatTimeout,
+            )->S.reverseConvertToJsonOrThrow(ReventlessInfra.PluginExtensionPointSpec.commandSchema),
+          }
+          try {
+            await publishHeartbeat([message])
+            log.info(
+              ~comp="Platform:deployPlugin",
+              `synthetic re-detect published for ${hbConfig.pluginId}`,
+            )
+          } catch {
+          | _ =>
+            log.warn(
+              ~comp="Platform:deployPlugin",
+              `synthetic heartbeat failed for ${hbConfig.pluginId} (handover falls back to the next natural heartbeat)`,
+            )
+          }
+        })
+      | (false, None) =>
+        log.warn(
+          ~comp="Platform:deployPlugin",
+          "synthetic heartbeat skipped: no EP queue URL in heartbeat config",
+        )
+      }
+    })
 
     Pulumi.Pulumi.getOutputs()
   }

package/src/Platform.res.mjs

@@ -1315,39 +1315,43 @@ function MakeWithConfig(Config) {
     if (sel !== undefined) {
       PgQueryResolver_Builder$ReventlessAws.provision(domainApi, sel, {});
     }
-    let hbConfig = PluginRuntime_Builder$ReventlessAws.heartbeatConfigRef.contents;
-    let match = IndexJs.isDryRun();
-    let match$1 = hbConfig.epQueueUrl;
-    if (match) {
-      
-    } else if (match$1 !== undefined) {
-      match$1.apply(async url => {
-        let queue = {
-          id: url,
-          name: "",
-          arn: ""
-        };
-        let publishHeartbeat = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
-        let message_id = hbConfig.pluginId;
-        let message_meta = Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, undefined, "DeployHeartbeat", undefined, undefined, undefined, undefined, undefined);
-        let message_commandJson = S.reverseConvertToJsonOrThrow({
-          TAG: "RedetectPlugin",
-          _0: hbConfig.heartbeatTimeout
-        }, PluginExtensionPointSpec$ReventlessInfra.commandSchema);
-        let message = {
-          id: message_id,
-          meta: message_meta,
-          commandJson: message_commandJson
-        };
-        try {
-          return await publishHeartbeat([message]);
-        } catch (exn) {
-          return log.warn("Platform:deployPlugin", undefined, `synthetic heartbeat failed for ` + hbConfig.pluginId + ` (handover falls back to the next natural heartbeat)`);
-        }
-      });
-    } else {
-      log.warn("Platform:deployPlugin", undefined, "synthetic heartbeat skipped: no EP queue URL in heartbeat config");
-    }
+    pluginOutputs.heartbeat.apply(param => {
+      let hbConfig = PluginRuntime_Builder$ReventlessAws.heartbeatConfigRef.contents;
+      let match = IndexJs.isDryRun();
+      let match$1 = hbConfig.epQueueUrl;
+      if (match) {
+        return;
+      } else if (match$1 !== undefined) {
+        match$1.apply(async url => {
+          let queue = {
+            id: url,
+            name: "",
+            arn: ""
+          };
+          let publishHeartbeat = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
+          let message_id = hbConfig.pluginId;
+          let message_meta = Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, undefined, "DeployHeartbeat", undefined, undefined, undefined, undefined, undefined);
+          let message_commandJson = S.reverseConvertToJsonOrThrow({
+            TAG: "RedetectPlugin",
+            _0: hbConfig.heartbeatTimeout
+          }, PluginExtensionPointSpec$ReventlessInfra.commandSchema);
+          let message = {
+            id: message_id,
+            meta: message_meta,
+            commandJson: message_commandJson
+          };
+          try {
+            await publishHeartbeat([message]);
+            return log.info("Platform:deployPlugin", undefined, `synthetic re-detect published for ` + hbConfig.pluginId);
+          } catch (exn) {
+            return log.warn("Platform:deployPlugin", undefined, `synthetic heartbeat failed for ` + hbConfig.pluginId + ` (handover falls back to the next natural heartbeat)`);
+          }
+        });
+        return;
+      } else {
+        return log.warn("Platform:deployPlugin", undefined, "synthetic heartbeat skipped: no EP queue URL in heartbeat config");
+      }
+    });
     return Pulumi$Pulumi.getOutputs();
   };
   return {
@@ -2544,39 +2548,43 @@ function Make($star) {
     if (sel !== undefined) {
       PgQueryResolver_Builder$ReventlessAws.provision(domainApi, sel, {});
     }
-    let hbConfig = PluginRuntime_Builder$ReventlessAws.heartbeatConfigRef.contents;
-    let match = IndexJs.isDryRun();
-    let match$1 = hbConfig.epQueueUrl;
-    if (match) {
-      
-    } else if (match$1 !== undefined) {
-      match$1.apply(async url => {
-        let queue = {
-          id: url,
-          name: "",
-          arn: ""
-        };
-        let publishHeartbeat = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
-        let message_id = hbConfig.pluginId;
-        let message_meta = Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, undefined, "DeployHeartbeat", undefined, undefined, undefined, undefined, undefined);
-        let message_commandJson = S.reverseConvertToJsonOrThrow({
-          TAG: "RedetectPlugin",
-          _0: hbConfig.heartbeatTimeout
-        }, PluginExtensionPointSpec$ReventlessInfra.commandSchema);
-        let message = {
-          id: message_id,
-          meta: message_meta,
-          commandJson: message_commandJson
-        };
-        try {
-          return await publishHeartbeat([message]);
-        } catch (exn) {
-          return log.warn("Platform:deployPlugin", undefined, `synthetic heartbeat failed for ` + hbConfig.pluginId + ` (handover falls back to the next natural heartbeat)`);
-        }
-      });
-    } else {
-      log.warn("Platform:deployPlugin", undefined, "synthetic heartbeat skipped: no EP queue URL in heartbeat config");
-    }
+    pluginOutputs.heartbeat.apply(param => {
+      let hbConfig = PluginRuntime_Builder$ReventlessAws.heartbeatConfigRef.contents;
+      let match = IndexJs.isDryRun();
+      let match$1 = hbConfig.epQueueUrl;
+      if (match) {
+        return;
+      } else if (match$1 !== undefined) {
+        match$1.apply(async url => {
+          let queue = {
+            id: url,
+            name: "",
+            arn: ""
+          };
+          let publishHeartbeat = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
+          let message_id = hbConfig.pluginId;
+          let message_meta = Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, undefined, "DeployHeartbeat", undefined, undefined, undefined, undefined, undefined);
+          let message_commandJson = S.reverseConvertToJsonOrThrow({
+            TAG: "RedetectPlugin",
+            _0: hbConfig.heartbeatTimeout
+          }, PluginExtensionPointSpec$ReventlessInfra.commandSchema);
+          let message = {
+            id: message_id,
+            meta: message_meta,
+            commandJson: message_commandJson
+          };
+          try {
+            await publishHeartbeat([message]);
+            return log.info("Platform:deployPlugin", undefined, `synthetic re-detect published for ` + hbConfig.pluginId);
+          } catch (exn) {
+            return log.warn("Platform:deployPlugin", undefined, `synthetic heartbeat failed for ` + hbConfig.pluginId + ` (handover falls back to the next natural heartbeat)`);
+          }
+        });
+        return;
+      } else {
+        return log.warn("Platform:deployPlugin", undefined, "synthetic heartbeat skipped: no EP queue URL in heartbeat config");
+      }
+    });
     return Pulumi$Pulumi.getOutputs();
   };
   let StateViewSlice = {

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res

@@ -16,6 +16,96 @@
 let str = (item: dict<JSON.t>, key: string): option<string> =>
   item->Dict.get(key)->Option.flatMap(JSON.Decode.string)
 
+// Which list fields each entry collection's members must carry to satisfy the
+// `[T!]!` shape the admin SDL declares, plus the nested member lists one level
+// down (`references` on a command / event / error).
+//
+// This handler serves the persisted structure as raw JSON — nothing on the read
+// path decodes it through `pluginStructureSchema` — so a component written by a
+// deploy that predates one of these fields simply has no key for it. Absent
+// resolves to null against a non-null list, GraphQL propagates that null up the
+// unbroken non-null chain to the root, and the whole query answers `data: null`:
+// ONE plugin still carrying an older structure blackholes every other plugin's
+// components. A plugin whose version never changes (a private, unpublished stack)
+// stays on its old structure indefinitely, so this is not a transient window.
+//
+// `[]` is what an absent array already means on every one of these fields — the
+// structure is re-derived on every build, so it never encodes "cannot say" — which
+// makes filling it in the honest read rather than a guess.
+type healSpec = {lists: array<string>, nested: array<(string, array<string>)>}
+
+let refLists = ["references"]
+
+let writeSideHeal = {
+  lists: ["commands", "linkedViews", "producedEventTypes", "consumedEventTypes", "events", "errors"],
+  nested: [("commands", refLists), ("events", refLists), ("errors", refLists)],
+}
+
+let readSideHeal = {
+  lists: ["consumedEventTypes", "linkedWriteSide", "searchableFields"],
+  nested: [],
+}
+
+let healByCollection: array<(string, healSpec)> = [
+  ("readModels", readSideHeal),
+  ("stateViewSlices", readSideHeal),
+  ("stateChangeSlices", writeSideHeal),
+  ("aggregates", writeSideHeal),
+  ("automationSlices", {lists: ["consumedEventTypes", "producedCommandTypes"], nested: []}),
+  (
+    "outboundTranslationSlices",
+    {lists: ["consumedEventTypes", "inboundCommandTypes"], nested: []},
+  ),
+  ("inboundTranslationSlices", {lists: ["commandTypes"], nested: []}),
+  ("extensions", {lists: ["delegateNames", "eventTypes", "commandTypes"], nested: []}),
+]
+
+// Anything that is not already an array — missing, null, or a scalar written by a
+// structure this handler cannot make sense of — becomes `[]`.
+let fillLists = (obj: dict<JSON.t>, keys: array<string>): unit =>
+  keys->Array.forEach(k =>
+    switch obj->Dict.get(k) {
+    | Some(JSON.Array(_)) => ()
+    | _ => obj->Dict.set(k, JSON.Encode.array([]))
+    }
+  )
+
+let mapMembers = (obj: dict<JSON.t>, key: string, f: dict<JSON.t> => unit): unit =>
+  switch obj->Dict.get(key)->Option.flatMap(JSON.Decode.array) {
+  | None => ()
+  | Some(members) =>
+    obj->Dict.set(
+      key,
+      members
+      ->Array.map(m =>
+        switch m->JSON.Decode.object {
+        | None => m
+        | Some(mo) =>
+          let out = Dict.fromArray(mo->Dict.toArray)
+          f(out)
+          JSON.Encode.object(out)
+        }
+      )
+      ->JSON.Encode.array,
+    )
+  }
+
+let healStructure = (structure: dict<JSON.t>): dict<JSON.t> => {
+  let out = Dict.fromArray(structure->Dict.toArray)
+  // The collections themselves are `[T!]!` too, so an absent one is the same
+  // failure a scale smaller.
+  out->fillLists(healByCollection->Array.map(((collection, _)) => collection))
+  healByCollection->Array.forEach(((collection, spec)) =>
+    out->mapMembers(collection, component => {
+      component->fillLists(spec.lists)
+      spec.nested->Array.forEach(((key, keys)) =>
+        component->mapMembers(key, member => member->fillLists(keys))
+      )
+    })
+  )
+  out
+}
+
 // Mirror ReventlessCore.Platform_ComponentDefinitionsApi.isPublicQueryable on
 // the read path: a component is public unless its visibility is "Internal".
 let isPublicQueryable = (q: JSON.t): bool =>
@@ -26,22 +116,19 @@ let isPublicQueryable = (q: JSON.t): bool =>
 
 // Drop Internal ReadModels / StateViewSlices from a persisted structure. A
 // missing/non-array field defaults to `[]` (mirrors the JS `?? []`).
-let filterStructure = (structure: JSON.t): option<dict<JSON.t>> =>
-  switch structure->JSON.Decode.object {
-  | None => None
-  | Some(obj) =>
-    let out = Dict.fromArray(obj->Dict.toArray)
-    let filterArr = key =>
-      out
-      ->Dict.get(key)
-      ->Option.flatMap(JSON.Decode.array)
-      ->Option.getOr([])
-      ->Array.filter(isPublicQueryable)
-      ->JSON.Encode.array
-    out->Dict.set("readModels", filterArr("readModels"))
-    out->Dict.set("stateViewSlices", filterArr("stateViewSlices"))
-    Some(out)
-  }
+let filterStructure = (structure: dict<JSON.t>): dict<JSON.t> => {
+  let out = Dict.fromArray(structure->Dict.toArray)
+  let filterArr = key =>
+    out
+    ->Dict.get(key)
+    ->Option.flatMap(JSON.Decode.array)
+    ->Option.getOr([])
+    ->Array.filter(isPublicQueryable)
+    ->JSON.Encode.array
+  out->Dict.set("readModels", filterArr("readModels"))
+  out->Dict.set("stateViewSlices", filterArr("stateViewSlices"))
+  out
+}
 
 // `{pluginId: name, ...structure}` — pluginId first so the structure's fields win
 // on the (never-expected) key collision, matching the JS spread. Drops a row with
@@ -51,12 +138,15 @@ let filterStructure = (structure: JSON.t): option<dict<JSON.t>> =>
 // (`Platform_ComponentDefinitions`) gets the public-queryable subset, developer
 // tooling (`Platform_PluginStructures`) gets the structure exactly as persisted,
 // including Internal components and the producer-side `extensionPoints` that the
-// AutoUI entry type does not declare.
+// AutoUI entry type does not declare. Both are healed first — the SDL's non-null
+// lists are the same on either field, so an unhealed structure breaks both.
 let toEntryWith = (~filter: bool, item: dict<JSON.t>, ~name: string): option<JSON.t> => {
   let structure =
     item
     ->Dict.get("structure")
-    ->Option.flatMap(s => filter ? filterStructure(s) : s->JSON.Decode.object)
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.map(healStructure)
+    ->Option.map(s => filter ? filterStructure(s) : s)
   switch structure {
   | None => None
   | Some(structureObj) =>

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs

@@ -12,6 +12,149 @@ function str(item, key) {
   return Stdlib_Option.flatMap(item[key], Stdlib_JSON.Decode.string);
 }
 
+let refLists = ["references"];
+
+let writeSideHeal_lists = [
+  "commands",
+  "linkedViews",
+  "producedEventTypes",
+  "consumedEventTypes",
+  "events",
+  "errors"
+];
+
+let writeSideHeal_nested = [
+  [
+    "commands",
+    refLists
+  ],
+  [
+    "events",
+    refLists
+  ],
+  [
+    "errors",
+    refLists
+  ]
+];
+
+let writeSideHeal = {
+  lists: writeSideHeal_lists,
+  nested: writeSideHeal_nested
+};
+
+let readSideHeal_lists = [
+  "consumedEventTypes",
+  "linkedWriteSide",
+  "searchableFields"
+];
+
+let readSideHeal_nested = [];
+
+let readSideHeal = {
+  lists: readSideHeal_lists,
+  nested: readSideHeal_nested
+};
+
+let healByCollection = [
+  [
+    "readModels",
+    readSideHeal
+  ],
+  [
+    "stateViewSlices",
+    readSideHeal
+  ],
+  [
+    "stateChangeSlices",
+    writeSideHeal
+  ],
+  [
+    "aggregates",
+    writeSideHeal
+  ],
+  [
+    "automationSlices",
+    {
+      lists: [
+        "consumedEventTypes",
+        "producedCommandTypes"
+      ],
+      nested: []
+    }
+  ],
+  [
+    "outboundTranslationSlices",
+    {
+      lists: [
+        "consumedEventTypes",
+        "inboundCommandTypes"
+      ],
+      nested: []
+    }
+  ],
+  [
+    "inboundTranslationSlices",
+    {
+      lists: ["commandTypes"],
+      nested: []
+    }
+  ],
+  [
+    "extensions",
+    {
+      lists: [
+        "delegateNames",
+        "eventTypes",
+        "commandTypes"
+      ],
+      nested: []
+    }
+  ]
+];
+
+function fillLists(obj, keys) {
+  keys.forEach(k => {
+    let match = obj[k];
+    if (Array.isArray(match)) {
+      return;
+    }
+    obj[k] = [];
+  });
+}
+
+function mapMembers(obj, key, f) {
+  let members = Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.array);
+  if (members !== undefined) {
+    obj[key] = members.map(m => {
+      let mo = Stdlib_JSON.Decode.object(m);
+      if (mo === undefined) {
+        return m;
+      }
+      let out = Object.fromEntries(Object.entries(mo));
+      f(out);
+      return out;
+    });
+    return;
+  }
+}
+
+function healStructure(structure) {
+  let out = Object.fromEntries(Object.entries(structure));
+  fillLists(out, healByCollection.map(param => param[0]));
+  healByCollection.forEach(param => {
+    let spec = param[1];
+    mapMembers(out, param[0], component => {
+      fillLists(component, spec.lists);
+      spec.nested.forEach(param => {
+        let keys = param[1];
+        mapMembers(component, param[0], member => fillLists(member, keys));
+      });
+    });
+  });
+  return out;
+}
+
 function isPublicQueryable(q) {
   let match = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(q), o => o["visibility"]), Stdlib_JSON.Decode.string);
   if (match !== undefined) {
@@ -22,11 +165,7 @@ function isPublicQueryable(q) {
 }
 
 function filterStructure(structure) {
-  let obj = Stdlib_JSON.Decode.object(structure);
-  if (obj === undefined) {
-    return;
-  }
-  let out = Object.fromEntries(Object.entries(obj));
+  let out = Object.fromEntries(Object.entries(structure));
   let filterArr = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(out[key], Stdlib_JSON.Decode.array), []).filter(isPublicQueryable);
   out["readModels"] = filterArr("readModels");
   out["stateViewSlices"] = filterArr("stateViewSlices");
@@ -34,11 +173,11 @@ function filterStructure(structure) {
 }
 
 function toEntryWith(filter, item, name) {
-  let structure = Stdlib_Option.flatMap(item["structure"], s => {
+  let structure = Stdlib_Option.map(Stdlib_Option.map(Stdlib_Option.flatMap(item["structure"], Stdlib_JSON.Decode.object), healStructure), s => {
     if (filter) {
       return filterStructure(s);
     } else {
-      return Stdlib_JSON.Decode.object(s);
+      return s;
     }
   });
   if (structure === undefined) {
@@ -111,6 +250,13 @@ async function handler(event) {
 
 export {
   str,
+  refLists,
+  writeSideHeal,
+  readSideHeal,
+  healByCollection,
+  fillLists,
+  mapMembers,
+  healStructure,
   isPublicQueryable,
   filterStructure,
   toEntryWith,

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res

@@ -0,0 +1,114 @@
+// Guards the read-path healing in Platform_ComponentDefinitions_Lambda_Ops.
+//
+// The handler serves a persisted plugin structure as raw JSON — it is never
+// decoded through `pluginStructureSchema` — so a structure written before a
+// required list field existed reaches the resolver without that key. Against the
+// admin SDL's `[T!]!` the missing key resolves to null, GraphQL propagates the
+// null up an unbroken non-null chain, and the entire query answers `data: null`.
+// One plugin on an older structure therefore blackholes every other plugin.
+//
+// A plugin whose version never changes never re-runs the connect handshake, so it
+// keeps its old structure indefinitely — the reason this is worth healing rather
+// than waiting out.
+
+open JestGlobals
+
+let entry = (~filter, structure: JSON.t): option<dict<JSON.t>> =>
+  Platform_ComponentDefinitions_Lambda_Ops.toEntryWith(
+    ~filter,
+    Dict.fromArray([("structure", structure)]),
+    ~name="Ordering",
+  )->Option.flatMap(JSON.Decode.object)
+
+let members = (entry: dict<JSON.t>, collection: string): array<dict<JSON.t>> =>
+  entry
+  ->Dict.get(collection)
+  ->Option.flatMap(JSON.Decode.array)
+  ->Option.getOr([])
+  ->Array.filterMap(JSON.Decode.object)
+
+// A state-change slice as persisted before `errors` (and before `references` on a
+// command) existed: every other required list is present.
+let preErrorsSlice = JSON.parseOrThrow(`{
+  "name": "PlaceOrder",
+  "commands": [{"name": "PlaceOrder", "schema": "{}", "level": "Collection", "mutationField": "placeOrder"}],
+  "linkedViews": [],
+  "producedEventTypes": ["OrderPlaced"],
+  "consumedEventTypes": [],
+  "events": []
+}`)
+
+let preErrorsStructure = Dict.fromArray([
+  ("stateChangeSlices", JSON.Encode.array([preErrorsSlice])),
+])->JSON.Encode.object
+
+describe("toEntryWith heals a structure persisted before a required list existed", () => {
+  testSync("fills the absent list on the component", () => {
+    let slice =
+      entry(~filter=false, preErrorsStructure)
+      ->Option.map(members(_, "stateChangeSlices"))
+      ->Option.flatMap(Array.get(_, 0))
+    expect(slice->Option.flatMap(s => s->Dict.get("errors")))->toEqual(
+      Some(JSON.Encode.array([])),
+    )
+  })
+
+  testSync("fills the absent list one level down, on a command's references", () => {
+    let command =
+      entry(~filter=false, preErrorsStructure)
+      ->Option.map(members(_, "stateChangeSlices"))
+      ->Option.flatMap(Array.get(_, 0))
+      ->Option.flatMap(s => s->Dict.get("commands"))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.flatMap(Array.get(_, 0))
+      ->Option.flatMap(JSON.Decode.object)
+    expect(command->Option.flatMap(c => c->Dict.get("references")))->toEqual(
+      Some(JSON.Encode.array([])),
+    )
+  })
+
+  testSync("fills an absent collection, which is a non-null list of its own", () => {
+    let e = entry(~filter=false, preErrorsStructure)
+    expect(e->Option.flatMap(o => o->Dict.get("aggregates")))->toEqual(
+      Some(JSON.Encode.array([])),
+    )
+  })
+
+  testSync("leaves a present list untouched", () => {
+    let slice =
+      entry(~filter=false, preErrorsStructure)
+      ->Option.map(members(_, "stateChangeSlices"))
+      ->Option.flatMap(Array.get(_, 0))
+    expect(slice->Option.flatMap(s => s->Dict.get("producedEventTypes")))->toEqual(
+      Some(JSON.Encode.array([JSON.Encode.string("OrderPlaced")])),
+    )
+  })
+
+  testSync("heals the filtered field too — both fields share the component types", () => {
+    let slice =
+      entry(~filter=true, preErrorsStructure)
+      ->Option.map(members(_, "stateChangeSlices"))
+      ->Option.flatMap(Array.get(_, 0))
+    expect(slice->Option.flatMap(s => s->Dict.get("errors")))->toEqual(
+      Some(JSON.Encode.array([])),
+    )
+  })
+
+  testSync("still drops Internal read models when filtering", () => {
+    let structure = Dict.fromArray([
+      (
+        "readModels",
+        JSON.Encode.array([
+          JSON.parseOrThrow(`{"name": "Orders", "visibility": "Internal"}`),
+          JSON.parseOrThrow(`{"name": "Products"}`),
+        ]),
+      ),
+    ])->JSON.Encode.object
+    let names =
+      entry(~filter=true, structure)
+      ->Option.map(members(_, "readModels"))
+      ->Option.getOr([])
+      ->Array.filterMap(m => m->Dict.get("name")->Option.flatMap(JSON.Decode.string))
+    expect(names)->toEqual(["Products"])
+  })
+})

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws from "../src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs";
+
+function entry(filter, structure) {
+  return Stdlib_Option.flatMap(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.toEntryWith(filter, Object.fromEntries([[
+      "structure",
+      structure
+    ]]), "Ordering"), Stdlib_JSON.Decode.object);
+}
+
+function members(entry, collection) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(entry[collection], Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.object);
+}
+
+let preErrorsSlice = JSON.parse(`{
+  "name": "PlaceOrder",
+  "commands": [{"name": "PlaceOrder", "schema": "{}", "level": "Collection", "mutationField": "placeOrder"}],
+  "linkedViews": [],
+  "producedEventTypes": ["OrderPlaced"],
+  "consumedEventTypes": [],
+  "events": []
+}`);
+
+let preErrorsStructure = Object.fromEntries([[
+    "stateChangeSlices",
+    [preErrorsSlice]
+  ]]);
+
+globalThis.describe("toEntryWith heals a structure persisted before a required list existed", () => {
+  globalThis.test("fills the absent list on the component", () => {
+    let slice = Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, preErrorsStructure), __x => members(__x, "stateChangeSlices")), __x => __x[0]);
+    globalThis.expect(Stdlib_Option.flatMap(slice, s => s["errors"])).toEqual([]);
+  });
+  globalThis.test("fills the absent list one level down, on a command's references", () => {
+    let command = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, preErrorsStructure), __x => members(__x, "stateChangeSlices")), __x => __x[0]), s => s["commands"]), Stdlib_JSON.Decode.array), __x => __x[0]), Stdlib_JSON.Decode.object);
+    globalThis.expect(Stdlib_Option.flatMap(command, c => c["references"])).toEqual([]);
+  });
+  globalThis.test("fills an absent collection, which is a non-null list of its own", () => {
+    let e = entry(false, preErrorsStructure);
+    globalThis.expect(Stdlib_Option.flatMap(e, o => o["aggregates"])).toEqual([]);
+  });
+  globalThis.test("leaves a present list untouched", () => {
+    let slice = Stdlib_Option.flatMap(Stdlib_Option.map(entry(false, preErrorsStructure), __x => members(__x, "stateChangeSlices")), __x => __x[0]);
+    globalThis.expect(Stdlib_Option.flatMap(slice, s => s["producedEventTypes"])).toEqual(["OrderPlaced"]);
+  });
+  globalThis.test("heals the filtered field too — both fields share the component types", () => {
+    let slice = Stdlib_Option.flatMap(Stdlib_Option.map(entry(true, preErrorsStructure), __x => members(__x, "stateChangeSlices")), __x => __x[0]);
+    globalThis.expect(Stdlib_Option.flatMap(slice, s => s["errors"])).toEqual([]);
+  });
+  globalThis.test("still drops Internal read models when filtering", () => {
+    let structure = Object.fromEntries([[
+        "readModels",
+        [
+          JSON.parse(`{"name": "Orders", "visibility": "Internal"}`),
+          JSON.parse(`{"name": "Products"}`)
+        ]
+      ]]);
+    let names = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.map(entry(true, structure), __x => members(__x, "readModels")), []), m => Stdlib_Option.flatMap(m["name"], Stdlib_JSON.Decode.string));
+    globalThis.expect(names).toEqual(["Products"]);
+  });
+});
+
+export {
+  entry,
+  members,
+  preErrorsSlice,
+  preErrorsStructure,
+}
+/* preErrorsSlice Not a pure module */