@reventlessdev/reventless-core 3.0.0-alpha.250 → 3.0.0-alpha.252

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

@@ -327,12 +327,68 @@ function Make(Spec) {
       }
     ];
   };
+  let publishedEvents = [
+    {
+      name: "UnknownPluginDetected",
+      fromEventTypes: ["VersionDetected"]
+    },
+    {
+      name: "PluginConnected",
+      fromEventTypes: [
+        "VersionConnected",
+        "VersionPromoted"
+      ]
+    },
+    {
+      name: "PluginDisconnected",
+      fromEventTypes: ["VersionDisconnected"]
+    },
+    {
+      name: "PluginDeactivated",
+      fromEventTypes: ["VersionDeactivated"]
+    },
+    {
+      name: "PluginActivated",
+      fromEventTypes: ["VersionActivated"]
+    },
+    {
+      name: "PluginRetired",
+      fromEventTypes: ["VersionRetired"]
+    },
+    {
+      name: "IncompatiblePlugin",
+      fromEventTypes: ["IncompatiblePluginDetected"]
+    }
+  ];
+  let acceptedCommands = [
+    {
+      name: "Heartbeat",
+      toCommandTypes: ["Heartbeat"]
+    },
+    {
+      name: "RedetectPlugin",
+      toCommandTypes: ["Redetect"]
+    },
+    {
+      name: "ConnectPlugin",
+      toCommandTypes: [
+        "Connect",
+        "ReportIncompatibility"
+      ]
+    },
+    {
+      name: "DisconnectPlugin",
+      toCommandTypes: ["Disconnect"]
+    }
+  ];
   let PluginMapping = {
     ExtensionPoint: undefined,
     Delegate: undefined,
     moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
     mapIncomingCommand: mapIncomingCommand,
-    mapOutgoingEvent: mapOutgoingEvent
+    mapOutgoingEvent: mapOutgoingEvent,
+    publishedEvents: publishedEvents,
+    acceptedCommands: acceptedCommands
   };
   let Mapping = ExtensionPointMapping$ReventlessInfra.Make({
     ExtensionPoint: {
@@ -349,11 +405,15 @@ function Make(Spec) {
       errorSchema: PluginSpec$ReventlessCore.errorSchema,
       commandSchema: PluginSpec$ReventlessCore.commandSchema,
       moduleUrl: PluginSpec$ReventlessCore.moduleUrl,
-      commandAuthorization: PluginSpec$ReventlessCore.commandAuthorization
+      commandAuthorization: PluginSpec$ReventlessCore.commandAuthorization,
+      commandTransition: PluginSpec$ReventlessCore.commandTransition,
+      traits: PluginSpec$ReventlessCore.traits
     },
     moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
     mapIncomingCommand: mapIncomingCommand,
-    mapOutgoingEvent: mapOutgoingEvent
+    mapOutgoingEvent: mapOutgoingEvent,
+    publishedEvents: publishedEvents,
+    acceptedCommands: acceptedCommands
   });
   return {
     disconnectScheduleName: disconnectScheduleName,

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

@@ -34,12 +34,27 @@ function mapIncomingCommand(id, cmd, meta) {
   }
 }
 
+let publishedEvents = [];
+
+let acceptedCommands = [
+  {
+    name: "RegisterUiFragment",
+    toCommandTypes: ["RegisterUiFragment"]
+  },
+  {
+    name: "DisconnectPlugin",
+    toCommandTypes: ["DeregisterUiFragment"]
+  }
+];
+
 let UiFragmentMapping = {
   ExtensionPoint: undefined,
   Delegate: undefined,
   moduleUrl: moduleUrl,
   mapIncomingCommand: mapIncomingCommand,
-  mapOutgoingEvent: undefined
+  mapOutgoingEvent: undefined,
+  publishedEvents: publishedEvents,
+  acceptedCommands: acceptedCommands
 };
 
 let Mapping = ExtensionPointMapping$ReventlessInfra.Make({
@@ -57,11 +72,15 @@ let Mapping = ExtensionPointMapping$ReventlessInfra.Make({
     errorSchema: UiFragmentRegistry$ReventlessCore.errorSchema,
     commandSchema: UiFragmentRegistry$ReventlessCore.commandSchema,
     moduleUrl: UiFragmentRegistry$ReventlessCore.moduleUrl,
-    commandAuthorization: UiFragmentRegistry$ReventlessCore.commandAuthorization
+    commandAuthorization: UiFragmentRegistry$ReventlessCore.commandAuthorization,
+    commandTransition: UiFragmentRegistry$ReventlessCore.commandTransition,
+    traits: UiFragmentRegistry$ReventlessCore.traits
   },
   moduleUrl: moduleUrl,
   mapIncomingCommand: mapIncomingCommand,
-  mapOutgoingEvent: undefined
+  mapOutgoingEvent: undefined,
+  publishedEvents: publishedEvents,
+  acceptedCommands: acceptedCommands
 });
 
 let PluginExtensionPointSpec;

package/src/plugin/lifecycle/PluginBehavior.res

@@ -159,19 +159,19 @@ let decide = (state, command) =>
       Ok(Array.concat([VersionDisconnected(definition)], promoteEvents(state, v)))
     | _ => Ok([]) // not connected / unknown → tolerate stray disconnect
     }
-  | Activate(v) =>
-    switch state.known->Dict.get(v) {
+  | Activate({version}) =>
+    switch state.known->Dict.get(version) {
     | Some({status: Inactive | Retired, definition}) =>
       let base = [VersionActivated(definition)]
-      let supersede = if currentAfterConnect(state.known, v) == v {
+      let supersede = if currentAfterConnect(state.known, version) == version {
         switch state.current {
-        | Some(c) if c != v =>
+        | Some(c) if c != version =>
           switch state.known->Dict.get(c) {
           | Some({definition: defC}) => [
               VersionSuperseded({
                 supersededVersion: c,
                 supersededDefinition: defC,
-                newVersion: v,
+                newVersion: version,
                 newDefinition: definition,
               }),
             ]
@@ -187,18 +187,18 @@ let decide = (state, command) =>
     | Some({status: Disconnected}) => Error(IsDisconnected)
     | None => Error(UnknownVersion)
     }
-  | Deactivate(v) =>
-    switch state.known->Dict.get(v) {
+  | Deactivate({version}) =>
+    switch state.known->Dict.get(version) {
     | Some({status: Connected | Disconnected, definition}) =>
-      Ok(Array.concat([VersionDeactivated(definition)], promoteEvents(state, v)))
+      Ok(Array.concat([VersionDeactivated(definition)], promoteEvents(state, version)))
     | Some({status: Inactive | Retired}) => Ok([]) // idempotent / archived no-op
     | None => Error(UnknownVersion)
     }
-  | Retire(v) =>
-    switch state.known->Dict.get(v) {
+  | Retire({version}) =>
+    switch state.known->Dict.get(version) {
     | Some({status: Retired}) => Ok([]) // idempotent
     | Some({definition}) =>
-      Ok(Array.concat([VersionRetired(definition)], promoteEvents(state, v)))
+      Ok(Array.concat([VersionRetired(definition)], promoteEvents(state, version)))
     | None => Error(UnknownVersion)
     }
   | ReportIncompatibility(def) => Ok([IncompatiblePluginDetected(def)])

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

@@ -232,8 +232,8 @@ function decide(state, command) {
         };
       }
     case "Activate" :
-      let v$4 = command._0;
-      let match$4 = state.known[v$4];
+      let version = command.version;
+      let match$4 = state.known[version];
       if (match$4 === undefined) {
         return {
           TAG: "Error",
@@ -261,17 +261,17 @@ function decide(state, command) {
           _0: definition
         }];
       let supersede;
-      if (currentAfterConnect(state.known, v$4) === v$4) {
+      if (currentAfterConnect(state.known, version) === version) {
         let c = state.current;
         if (c !== undefined) {
-          if (c !== v$4) {
+          if (c !== version) {
             let match$5 = state.known[c];
             supersede = match$5 !== undefined ? [{
                   TAG: "VersionSuperseded",
                   _0: {
                     supersededVersion: c,
                     supersededDefinition: match$5.definition,
-                    newVersion: v$4,
+                    newVersion: version,
                     newDefinition: definition
                   }
                 }] : [];
@@ -290,8 +290,8 @@ function decide(state, command) {
       };
       break;
     case "Deactivate" :
-      let v$5 = command._0;
-      let match$6 = state.known[v$5];
+      let version$1 = command.version;
+      let match$6 = state.known[version$1];
       if (match$6 === undefined) {
         return {
           TAG: "Error",
@@ -314,12 +314,12 @@ function decide(state, command) {
         _0: [{
             TAG: "VersionDeactivated",
             _0: match$6.definition
-          }].concat(promoteEvents(state, v$5))
+          }].concat(promoteEvents(state, version$1))
       };
       break;
     case "Retire" :
-      let v$6 = command._0;
-      let match$7 = state.known[v$6];
+      let version$2 = command.version;
+      let match$7 = state.known[version$2];
       if (match$7 !== undefined) {
         if (match$7.status === "Retired") {
           return {
@@ -332,7 +332,7 @@ function decide(state, command) {
             _0: [{
                 TAG: "VersionRetired",
                 _0: match$7.definition
-              }].concat(promoteEvents(state, v$6))
+              }].concat(promoteEvents(state, version$2))
           };
         }
       } else {

package/src/plugin/lifecycle/PluginSpec.res

@@ -34,12 +34,20 @@ type command =
   // Cognito group-gated). `version` selects which known version to act on.
   // The `@transition` edges must agree with `decide` below; `Platform_Admin_Structure`
   // reads them off this schema rather than restating them.
-  | @transition(([Plugins.Inactive, Plugins.Retired]) => Plugins.Connected) Activate(version)
-  | @transition(([Plugins.Connected, Plugins.Disconnected]) => Plugins.Inactive) Deactivate(version)
+  //
+  // Inline records, unlike the `@noApi` commands above, and the difference is the
+  // API. A positional payload publishes its argument as `_0`, which names nothing:
+  // a caller cannot match it against a field it holds, and a coercion failure says
+  // `Variable '_0'` rather than what was missing. These three are the ones a person
+  // calls, so their argument carries its own name.
+  | @transition(([Plugins.Inactive, Plugins.Retired]) => Plugins.Connected)
+  Activate({version: version})
+  | @transition(([Plugins.Connected, Plugins.Disconnected]) => Plugins.Inactive)
+  Deactivate({version: version})
   // Manual admin retirement of a specific version (archive). Distinct from the
   // automatic `Superseded` transition (which is decided, not commanded).
   | @transition(([Plugins.Connected, Plugins.Disconnected, Plugins.Inactive]) => Plugins.Retired)
-  Retire(version)
+  Retire({version: version})
 
 // Carries both the superseded and the superseding version's full definition —
 // a deterministic trigger for version-to-version schema/data migrations

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

@@ -27,15 +27,15 @@ let commandSchema = Sury.union([
   })),
   Sury.$schema(s => ({
     TAG: "Activate",
-    _0: s.m(Plugin$Reventless.versionSchema)
+    version: s.m(Plugin$Reventless.versionSchema)
   })),
   Sury.$schema(s => ({
     TAG: "Deactivate",
-    _0: s.m(Plugin$Reventless.versionSchema)
+    version: s.m(Plugin$Reventless.versionSchema)
   })),
   Sury.$schema(s => ({
     TAG: "Retire",
-    _0: s.m(Plugin$Reventless.versionSchema)
+    version: s.m(Plugin$Reventless.versionSchema)
   }))
 ]);
 
@@ -156,6 +156,12 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
+function commandTransition(param) {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let name = "Plugin";
 
 let Id;
@@ -174,5 +180,7 @@ export {
   commandSchema$3 as commandSchema,
   moduleUrl,
   commandAuthorization,
+  commandTransition,
+  traits,
 }
 /* commandSchema Not a pure module */