@reventlessdev/reventless-core 3.0.0-alpha.150 → 3.0.0-alpha.152

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.152 (2026-07-10)
+
+### Features
+
+* **plugin-lifecycle:** expose command/event/consumed-event metadata on plugin hooks for StateChange/StateView slices ([194abf3](https://github.com/ReventlessDev/reventless-core/commit/194abf30460ae0140a7900d8ca67d671b15deb3a))
+
+
+# 3.0.0-alpha.151 (2026-07-10)
+
+### Bug Fixes
+
+* **plugin-lifecycle:** backfill plugin kind onto existing rows via deploy-time RedetectPlugin ([502dbd6](https://github.com/ReventlessDev/reventless-core/commit/502dbd65d1fdd5b8beae8a7b96df06dcfa32fe3e))
+* **plugin-lifecycle:** make read-model kind nullable so kind-less rows don't null the admin Plugins query ([671c4f6](https://github.com/ReventlessDev/reventless-core/commit/671c4f6cbbdde32a8dced7290fc8aa5b0063536f))
+
+
 # 3.0.0-alpha.150 (2026-07-10)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.150",
+  "version": "3.0.0-alpha.152",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -32,13 +32,13 @@
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.92",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.70"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.93",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.71",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.24"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/plugin/component/Plugin_Builder.res

@@ -398,14 +398,6 @@ module Make = (
         ({name: R.Spec.name, kind: "ReadModel", schema}: Plugin_Helpers.pluginBuiltComponent)
       })
 
-      let mapNames = (d: dict<_>, kind: string) =>
-        d
-        ->Dict.keysToArray
-        ->Array.map(name => {
-          let schema: Plugin_Helpers.pluginDeployedSchema = {}
-          ({Plugin_Helpers.name, kind, schema}: Plugin_Helpers.pluginBuiltComponent)
-        })
-
       // Routing slices (automation / inbound + outbound translation) expose their
       // command/event wiring and routing target on the hook surface, at parity
       // with aggregates and read models — mirroring the metadata Plugin_Structure
@@ -457,15 +449,44 @@ module Make = (
         )
       )
 
+      // StateChange / StateView slices carry no routing target, but they do carry
+      // command / event / consumed-event types. Surface those on the hook at parity
+      // with aggregates, read models, and routing slices — mirroring the metadata
+      // Plugin_Structure records on the static plugin def. Type strings stay
+      // unqualified to match the aggregate/read-model entries already on this same
+      // hook surface (Plugin_Structure additionally prefixes them with the plugin
+      // name).
+      let stateSchemas: Dict.t<Plugin_Helpers.pluginDeployedSchema> = Dict.make()
+      stateChangeSlices->Array.forEach((module(Scs: ReventlessInfra.StateChangeSlice.T)) =>
+        stateSchemas->Dict.set(
+          Scs.Spec.name,
+          {
+            commandTypes: extractTypes(Scs.Spec.commandSchema),
+            eventTypes: extractEventTypes(Scs.Spec.eventSchema->S.castToUnknown),
+            consumedEventTypes: extractEventTypes(Scs.Spec.consumedEventSchema->S.castToUnknown),
+          },
+        )
+      )
+      stateViewSlices->Array.forEach((module(Svs: ReventlessInfra.StateViewSlice.T)) =>
+        stateSchemas->Dict.set(
+          Svs.Spec.name,
+          {consumedEventTypes: extractEventTypes(Svs.Spec.consumedEventSchema->S.castToUnknown)},
+        )
+      )
+
       // Component set still derives from the DCB outputs dict (unchanged
       // membership); enrich + register the schema where a matching spec module
       // was found above, so the deployed hook surfaces it too (the built-hook
       // components carry it inline).
-      let routingComponents = (d: dict<_>, kind: string) =>
+      let enrichedComponents = (
+        d: dict<_>,
+        kind: string,
+        schemas: Dict.t<Plugin_Helpers.pluginDeployedSchema>,
+      ) =>
         d
         ->Dict.keysToArray
         ->Array.map(name => {
-          let schema = routingSchemas->Dict.get(name)->Option.getOr({})
+          let schema = schemas->Dict.get(name)->Option.getOr({})
           Plugin_Helpers.componentSchemaRegistry->Dict.set(name, schema)
           ({Plugin_Helpers.name, kind, schema}: Plugin_Helpers.pluginBuiltComponent)
         })
@@ -473,11 +494,19 @@ module Make = (
       let components = Array.flat([
         aggregateComponents,
         readModelComponents,
-        mapNames(dcbResult.stateChangeSlicesOutputs, "StateChangeSlice"),
-        mapNames(dcbResult.stateViewSlicesOutputs, "StateViewSlice"),
-        routingComponents(dcbResult.automationSlicesOutputs, "AutomationSlice"),
-        routingComponents(dcbResult.outboundTranslationSlicesOutputs, "OutboundTranslationSlice"),
-        routingComponents(dcbResult.inboundTranslationSlicesOutputs, "InboundTranslationSlice"),
+        enrichedComponents(dcbResult.stateChangeSlicesOutputs, "StateChangeSlice", stateSchemas),
+        enrichedComponents(dcbResult.stateViewSlicesOutputs, "StateViewSlice", stateSchemas),
+        enrichedComponents(dcbResult.automationSlicesOutputs, "AutomationSlice", routingSchemas),
+        enrichedComponents(
+          dcbResult.outboundTranslationSlicesOutputs,
+          "OutboundTranslationSlice",
+          routingSchemas,
+        ),
+        enrichedComponents(
+          dcbResult.inboundTranslationSlicesOutputs,
+          "InboundTranslationSlice",
+          routingSchemas,
+        ),
       ])
 
       switch Plugin_Helpers.onPluginBuiltHook.contents {

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -300,11 +300,6 @@ function Make(Spec) {
             schema: schema
           };
         });
-        let mapNames = (d, kind) => Object.keys(d).map(name => ({
-          name: name,
-          kind: kind,
-          schema: {}
-        }));
         let routingSchemas = {};
         automationSlices.forEach(As => {
           let consumedEventTypes = Belt_SetString.toArray(Belt_SetString.fromArray(As.Automation.mappings.flatMap(M => DcbTag$Reventless.extractVariantNames(M.sourceEventSchema))));
@@ -327,8 +322,21 @@ function Make(Spec) {
             targetName: Its.Spec.targetName
           };
         });
-        let routingComponents = (d, kind) => Object.keys(d).map(name => {
-          let schema = Stdlib_Option.getOr(routingSchemas[name], {});
+        let stateSchemas = {};
+        stateChangeSlices.forEach(Scs => {
+          stateSchemas[Scs.Spec.name] = {
+            commandTypes: DcbTag$Reventless.extractAllVariantNames(Scs.Spec.commandSchema),
+            eventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.eventSchema),
+            consumedEventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.consumedEventSchema)
+          };
+        });
+        stateViewSlices.forEach(Svs => {
+          stateSchemas[Svs.Spec.name] = {
+            consumedEventTypes: DcbTag$Reventless.extractVariantNames(Svs.Spec.consumedEventSchema)
+          };
+        });
+        let enrichedComponents = (d, kind, schemas) => Object.keys(d).map(name => {
+          let schema = Stdlib_Option.getOr(schemas[name], {});
           Plugin_Helpers$ReventlessCore.componentSchemaRegistry[name] = schema;
           return {
             name: name,
@@ -339,11 +347,11 @@ function Make(Spec) {
         let components = [
           aggregateComponents,
           readModelComponents,
-          mapNames(dcbResult.stateChangeSlicesOutputs, "StateChangeSlice"),
-          mapNames(dcbResult.stateViewSlicesOutputs, "StateViewSlice"),
-          routingComponents(dcbResult.automationSlicesOutputs, "AutomationSlice"),
-          routingComponents(dcbResult.outboundTranslationSlicesOutputs, "OutboundTranslationSlice"),
-          routingComponents(dcbResult.inboundTranslationSlicesOutputs, "InboundTranslationSlice")
+          enrichedComponents(dcbResult.stateChangeSlicesOutputs, "StateChangeSlice", stateSchemas),
+          enrichedComponents(dcbResult.stateViewSlicesOutputs, "StateViewSlice", stateSchemas),
+          enrichedComponents(dcbResult.automationSlicesOutputs, "AutomationSlice", routingSchemas),
+          enrichedComponents(dcbResult.outboundTranslationSlicesOutputs, "OutboundTranslationSlice", routingSchemas),
+          enrichedComponents(dcbResult.inboundTranslationSlicesOutputs, "InboundTranslationSlice", routingSchemas)
         ].flat();
         let hook = Plugin_Helpers$ReventlessCore.onPluginBuiltHook.contents;
         if (hook !== undefined) {

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -150,6 +150,14 @@ module Make = (Spec: Spec) => {
           // 1 additional minute to allow additional latency
           HandleDirective(directiveHandler, CreateDisconnectSchedule(id, interval + 2)),
         ]
+      | RedetectPlugin(interval) => [
+          // Deploy-time re-detect: drive Redetect (not Heartbeat) so an already-connected
+          // version re-runs the handshake and refreshes its stored definition. Still
+          // re-arm the disconnect schedule exactly like a heartbeat so liveness tracking
+          // continues from the deploy moment.
+          PublishCommand(Plugin.name(id), Delegate.Redetect(Plugin.version(id))),
+          HandleDirective(directiveHandler, CreateDisconnectSchedule(id, interval + 2)),
+        ]
       | ConnectPlugin(pluginDefinition) =>
         // Validate protocol versions declared by the connecting plugin.
         // On mismatch, emit a ReportIncompatibility command so that an

package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs

@@ -183,6 +183,26 @@ function Make(Spec) {
               _0: cmd._0
             }
           }];
+      case "RedetectPlugin" :
+        return [
+          {
+            TAG: "PublishCommand",
+            _0: Plugin$ReventlessCore.name(id),
+            _1: {
+              TAG: "Redetect",
+              _0: Plugin$ReventlessCore.version(id)
+            }
+          },
+          {
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "CreateDisconnectSchedule",
+              _0: id,
+              _1: cmd._0 + 2 | 0
+            }
+          }
+        ];
     }
   };
   let mapOutgoingEvent = (id, event, _meta, _queryEngine) => {

package/src/plugin/lifecycle/PluginBehavior.res

@@ -145,10 +145,24 @@ let decide = (state, command) =>
     | Some({status: Disconnected, definition}) => Ok(connectEvents(state, v, definition)) // reconnect
     | Some({status: Inactive | Retired}) => Ok([]) // not heartbeat-revivable (admin only)
     }
+  | Redetect(v) =>
+    // Deploy-time re-detect: unlike Heartbeat, a *connected* version re-runs the
+    // handshake (VersionDetected → ConnectPlugin → Connect) so the plugin re-answers
+    // with its current definition and Connect below refreshes the stored def. Unknown
+    // and disconnected versions detect exactly as a heartbeat would; archived versions
+    // stay admin-only.
+    switch state.known->Dict.get(v) {
+    | Some({status: Inactive | Retired}) => Ok([]) // archived — not re-detect-revivable
+    | None | Some({status: Connected | Disconnected}) => Ok([VersionDetected(v)])
+    }
   | Connect(def) =>
     let v = def.version
     switch state.known->Dict.get(v) {
-    | Some({status: Connected}) => Ok([]) // idempotent
+    // Idempotent when the definition is unchanged; when a redeploy carries a changed
+    // definition (e.g. a newly added `kind`, updated uiFragments/protocols) re-emit
+    // VersionConnected to overwrite the stored def and re-project the row. The version
+    // is already current, so connectEvents' supersede stays empty — a bare refresh.
+    | Some({status: Connected, definition}) => definition == def ? Ok([]) : Ok([VersionConnected(def)])
     | _ => Ok(connectEvents(state, v, def))
     }
   | Disconnect(v) =>

package/src/plugin/lifecycle/PluginBehavior.res.mjs

@@ -172,55 +172,94 @@ function decide(state, command) {
             _0: []
           };
       }
-    case "Connect" :
-      let def = command._0;
-      let v$1 = def.version;
+    case "Redetect" :
+      let v$1 = command._0;
       let match$1 = state.known[v$1];
-      if (match$1 !== undefined && match$1.status === "Connected") {
+      if (match$1 === undefined) {
         return {
           TAG: "Ok",
-          _0: []
+          _0: [{
+              TAG: "VersionDetected",
+              _0: v$1
+            }]
         };
+      }
+      switch (match$1.status) {
+        case "Connected" :
+        case "Disconnected" :
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "VersionDetected",
+                _0: v$1
+              }]
+          };
+        case "Inactive" :
+        case "Retired" :
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+      }
+    case "Connect" :
+      let def = command._0;
+      let v$2 = def.version;
+      let match$2 = state.known[v$2];
+      if (match$2 !== undefined && match$2.status === "Connected") {
+        if (Primitive_object.equal(match$2.definition, def)) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "VersionConnected",
+                _0: def
+              }]
+          };
+        }
       } else {
         return {
           TAG: "Ok",
-          _0: connectEvents(state, v$1, def)
+          _0: connectEvents(state, v$2, def)
         };
       }
     case "Disconnect" :
-      let v$2 = command._0;
-      let match$2 = state.known[v$2];
-      if (match$2 === undefined) {
+      let v$3 = command._0;
+      let match$3 = state.known[v$3];
+      if (match$3 === undefined) {
         return {
           TAG: "Ok",
           _0: []
         };
       }
-      if (match$2.status !== "Connected") {
+      if (match$3.status !== "Connected") {
         return {
           TAG: "Ok",
           _0: []
         };
       }
-      let definition = match$2.definition;
+      let definition = match$3.definition;
       return {
         TAG: "Ok",
         _0: [{
             TAG: "VersionDisconnected",
             _0: definition
-          }].concat(uiDeregisterEvents(definition.id, definition.uiFragments)).concat(promoteEvents(state, v$2))
+          }].concat(uiDeregisterEvents(definition.id, definition.uiFragments)).concat(promoteEvents(state, v$3))
       };
     case "Activate" :
-      let v$3 = command._0;
-      let match$3 = state.known[v$3];
-      if (match$3 === undefined) {
+      let v$4 = command._0;
+      let match$4 = state.known[v$4];
+      if (match$4 === undefined) {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$1 = match$3.definition;
-      switch (match$3.status) {
+      let definition$1 = match$4.definition;
+      switch (match$4.status) {
         case "Connected" :
           return {
             TAG: "Ok",
@@ -240,17 +279,17 @@ function decide(state, command) {
           _0: definition$1
         }].concat(uiRegisterEvents(definition$1.id, definition$1.uiFragments));
       let supersede;
-      if (currentAfterConnect(state.known, v$3) === v$3) {
+      if (currentAfterConnect(state.known, v$4) === v$4) {
         let c = state.current;
         if (c !== undefined) {
-          if (c !== v$3) {
-            let match$4 = state.known[c];
-            supersede = match$4 !== undefined ? [{
+          if (c !== v$4) {
+            let match$5 = state.known[c];
+            supersede = match$5 !== undefined ? [{
                   TAG: "VersionSuperseded",
                   _0: {
                     supersededVersion: c,
-                    supersededDefinition: match$4.definition,
-                    newVersion: v$3,
+                    supersededDefinition: match$5.definition,
+                    newVersion: v$4,
                     newDefinition: definition$1
                   }
                 }] : [];
@@ -269,16 +308,16 @@ function decide(state, command) {
       };
       break;
     case "Deactivate" :
-      let v$4 = command._0;
-      let match$5 = state.known[v$4];
-      if (match$5 === undefined) {
+      let v$5 = command._0;
+      let match$6 = state.known[v$5];
+      if (match$6 === undefined) {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$2 = match$5.definition;
-      switch (match$5.status) {
+      let definition$2 = match$6.definition;
+      switch (match$6.status) {
         case "Connected" :
         case "Disconnected" :
           break;
@@ -294,7 +333,7 @@ function decide(state, command) {
         _0: [{
             TAG: "VersionDeactivated",
             _0: definition$2
-          }].concat(uiDeregisterEvents(definition$2.id, definition$2.uiFragments)).concat(promoteEvents(state, v$4))
+          }].concat(uiDeregisterEvents(definition$2.id, definition$2.uiFragments)).concat(promoteEvents(state, v$5))
       };
       break;
     case "ReportIncompatibility" :
@@ -306,16 +345,16 @@ function decide(state, command) {
           }]
       };
     case "Retire" :
-      let v$5 = command._0;
-      let match$6 = state.known[v$5];
-      if (match$6 === undefined) {
+      let v$6 = command._0;
+      let match$7 = state.known[v$6];
+      if (match$7 === undefined) {
         return {
           TAG: "Error",
           _0: "UnknownVersion"
         };
       }
-      let definition$3 = match$6.definition;
-      if (match$6.status === "Retired") {
+      let definition$3 = match$7.definition;
+      if (match$7.status === "Retired") {
         return {
           TAG: "Ok",
           _0: []
@@ -326,7 +365,7 @@ function decide(state, command) {
           _0: [{
               TAG: "VersionRetired",
               _0: definition$3
-            }].concat(uiDeregisterEvents(definition$3.id, definition$3.uiFragments)).concat(promoteEvents(state, v$5))
+            }].concat(uiDeregisterEvents(definition$3.id, definition$3.uiFragments)).concat(promoteEvents(state, v$6))
         };
       }
   }

package/src/plugin/lifecycle/PluginSpec.res

@@ -10,6 +10,10 @@ open Reventless.Plugin
 @schema
 type command =
   | @noApi Heartbeat(version)
+  // Deploy-time re-detect (from RedetectPlugin). Forces the connect handshake to
+  // re-run for an already-connected version so its definition is refreshed on the
+  // row — unlike Heartbeat, which no-ops a connected keep-alive.
+  | @noApi Redetect(version)
   | @noApi Connect(pluginDefinition)
   | @noApi Disconnect(version)
   // Admin lifecycle commands — API-exposed (auto-derived admin mutations,

package/src/plugin/lifecycle/PluginSpec.res.mjs

@@ -9,6 +9,10 @@ let commandSchema = S.union([
     TAG: "Heartbeat",
     _0: s.m(Plugin$Reventless.versionSchema)
   })),
+  S.schema(s => ({
+    TAG: "Redetect",
+    _0: s.m(Plugin$Reventless.versionSchema)
+  })),
   S.schema(s => ({
     TAG: "Connect",
     _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
@@ -117,6 +121,7 @@ let errorSchema = S.union([
 
 let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
   "Heartbeat",
+  "Redetect",
   "Connect",
   "Disconnect",
   "ReportIncompatibility"

package/src/plugin/lifecycle/PluginsProjection.res

@@ -58,7 +58,10 @@ let displayState = (
     uiFragments: def.uiFragments,
     structure: def.structure,
     dcbEventLog: def.dcbEventLog,
-    kind: def.kind,
+    // A freshly projected row always knows its kind (the definition carries it as a
+    // mandatory field). `option` here is purely for rows persisted before `kind`
+    // existed — see PluginsReadModelSpec.state.kind.
+    kind: Some(def.kind),
     // The current version is never listed among the "other" connected versions.
     otherConnectedVersions: otherConnectedVersions->Util.without(def.version),
   }

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -44,7 +44,16 @@ type state = {
   // correctly server-side rather than filtering a page client-side.
   // @groupBy tags this field as the list view's section key (emitted as
   // `x-reventless-group-by`); AutoUI sections the admin Plugins view by kind.
-  @scan @groupBy kind: Reventless.Plugin.pluginKind,
+  //
+  // **Nullable on purpose.** Rows projected before `kind` existed carry no `kind`
+  // attribute, and the deploy-time RedetectPlugin backfill only stamps a row on the
+  // owning plugin's next deploy. A non-null `PluginKind!` would make GraphQL null the
+  // entire `Platform_Plugins` query the moment a single kind-less row is returned
+  // (existing rows, a newly-connecting plugin before it's stamped, or an internal
+  // bookkeeping row). Optional here → nullable `Platform_PluginKind` in the SDL, so a
+  // blank kind degrades to a missing group (AutoListView's trailing group) instead of
+  // taking down the whole list. Backfill then upgrades blanks to real kinds.
+  @scan @groupBy kind: option<Reventless.Plugin.pluginKind>,
   // Other versions of this name that are currently **Connected** — excludes this
   // row's own `version` (whose status is the `status` field above). Lets the
   // projection recompute which version is current (highest Connected) during a
@@ -69,7 +78,7 @@ type queryResult = {
   uiFragments: option<Reventless.Plugin.uiFragmentManifest>,
   structure: option<Reventless.Plugin.pluginStructure>,
   dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
-  kind: Reventless.Plugin.pluginKind,
+  kind: option<Reventless.Plugin.pluginKind>,
 }
 
 

package/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs

@@ -28,7 +28,7 @@ let stateSchema = S.schema(s => ({
   uiFragments: s.m(Plugin$Reventless.uiFragmentManifestOptionSchema),
   structure: s.m(Plugin$Reventless.pluginStructureOptionSchema),
   dcbEventLog: s.m(Plugin$Reventless.dcbEventLogOptionSchema),
-  kind: s.m(Plugin$Reventless.pluginKindSchema),
+  kind: s.m(S.option(Plugin$Reventless.pluginKindSchema)),
   otherConnectedVersions: s.m(S.array(Plugin$Reventless.versionSchema))
 }));