@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/lifecycle/PluginBehavior.res

@@ -0,0 +1,250 @@
+@@reventless.behavior(PluginSpec)
+
+open Reventless.Plugin
+
+// Per-version status the aggregate tracks. `Superseded` is NOT here: a version
+// that is live (Connected) but not `current` is "superseded" — that label is
+// derived on the read side (Connected && version != current), so the aggregate
+// stays minimal and `current` is always recomputable as "highest Connected".
+@schema
+type versionStatus =
+  | Connected
+  | Disconnected
+  | Inactive
+  | Retired
+
+@schema
+type knownVersion = {
+  definition: pluginDefinition,
+  status: versionStatus,
+}
+
+// Name-keyed state: every version this plugin name has ever connected, plus the
+// pointer to the currently-active version. `current` is derived (highest
+// Connected) — never compared against wall-clock time, so replay is deterministic.
+@schema
+type state = {
+  current: option<version>,
+  known: dict<knownVersion>,
+}
+
+let initialState = {current: None, known: Dict.make()}
+
+let atomicCounter = None
+
+let uiRegisterEvents = (pluginId, manifest) =>
+  switch manifest {
+  | None => []
+  | Some(manifest) => [(UIFragmentRegistered({pluginId, manifest}): event)]
+  }
+
+let uiDeregisterEvents = (pluginId, manifest) =>
+  switch manifest {
+  | None => []
+  | Some(_) => [(UIFragmentDeregistered({pluginId: pluginId}): event)]
+  }
+
+// Highest version with status Connected, or None.
+let highestConnected = (known: dict<knownVersion>): option<version> =>
+  known
+  ->Dict.toArray
+  ->Array.reduce(None, (acc, (v, kv)) =>
+    switch kv.status {
+    | Connected =>
+      switch acc {
+      | None => Some(v)
+      | Some(cur) => Plugin.compareVersions(v, cur) > 0 ? Some(v) : acc
+      }
+    | Disconnected | Inactive | Retired => acc
+    }
+  )
+
+// Highest Connected version other than `exclude`.
+let highestConnectedExcluding = (known: dict<knownVersion>, exclude: version): option<
+  version,
+> =>
+  known
+  ->Dict.toArray
+  ->Array.reduce(None, (acc, (v, kv)) =>
+    if v == exclude {
+      acc
+    } else {
+      switch kv.status {
+      | Connected =>
+        switch acc {
+        | None => Some(v)
+        | Some(cur) => Plugin.compareVersions(v, cur) > 0 ? Some(v) : acc
+        }
+      | Disconnected | Inactive | Retired => acc
+      }
+    }
+  )
+
+// Which version is current after `v` becomes Connected.
+let currentAfterConnect = (known, v) =>
+  switch highestConnectedExcluding(known, v) {
+  | None => v
+  | Some(h) => Plugin.compareVersions(v, h) >= 0 ? v : h
+  }
+
+// Events emitted when `v` (with `def`) becomes Connected: the VersionConnected +
+// UI register, plus a VersionSuperseded record when `v` takes over from a
+// different current version.
+let connectEvents = (state: state, v: version, def: pluginDefinition): array<event> => {
+  let base = Array.concat([VersionConnected(def)], uiRegisterEvents(def.id, def.uiFragments))
+  let supersede = if currentAfterConnect(state.known, v) == v {
+    switch state.current {
+    | Some(c) if c != v =>
+      switch state.known->Dict.get(c) {
+      | Some({definition: defC}) => [
+          VersionSuperseded({
+            supersededVersion: c,
+            supersededDefinition: defC,
+            newVersion: v,
+            newDefinition: def,
+          }),
+        ]
+      | None => []
+      }
+    | _ => []
+    }
+  } else {
+    []
+  }
+  Array.concat(base, supersede)
+}
+
+// VersionPromoted record when the current version `v` leaves Connected and a
+// lower still-Connected version is promoted (rollback). Empty otherwise.
+let promoteEvents = (state: state, v: version): array<event> =>
+  if state.current == Some(v) {
+    switch highestConnectedExcluding(state.known, v) {
+    | Some(w) =>
+      switch state.known->Dict.get(w) {
+      | Some({definition: defW}) => [VersionPromoted(defW)]
+      | None => []
+      }
+    | None => []
+    }
+  } else {
+    []
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | Heartbeat(v) =>
+    switch state.known->Dict.get(v) {
+    | None => Ok([VersionDetected(v)]) // unknown version → trigger the connect handshake
+    | Some({status: Connected}) => Ok([]) // keep-alive
+    | Some({status: Disconnected, definition}) => Ok(connectEvents(state, v, definition)) // reconnect
+    | Some({status: Inactive | Retired}) => Ok([]) // not heartbeat-revivable (admin only)
+    }
+  | Connect(def) =>
+    let v = def.version
+    switch state.known->Dict.get(v) {
+    | Some({status: Connected}) => Ok([]) // idempotent
+    | _ => Ok(connectEvents(state, v, def))
+    }
+  | Disconnect(v) =>
+    switch state.known->Dict.get(v) {
+    | Some({status: Connected, definition}) =>
+      Ok(
+        Array.concat(
+          Array.concat(
+            [VersionDisconnected(definition)],
+            uiDeregisterEvents(definition.id, definition.uiFragments),
+          ),
+          promoteEvents(state, v),
+        ),
+      )
+    | _ => Ok([]) // not connected / unknown → tolerate stray disconnect
+    }
+  | Activate(v) =>
+    switch state.known->Dict.get(v) {
+    | Some({status: Inactive | Retired, definition}) =>
+      let base = Array.concat(
+        [VersionActivated(definition)],
+        uiRegisterEvents(definition.id, definition.uiFragments),
+      )
+      let supersede = if currentAfterConnect(state.known, v) == v {
+        switch state.current {
+        | Some(c) if c != v =>
+          switch state.known->Dict.get(c) {
+          | Some({definition: defC}) => [
+              VersionSuperseded({
+                supersededVersion: c,
+                supersededDefinition: defC,
+                newVersion: v,
+                newDefinition: definition,
+              }),
+            ]
+          | None => []
+          }
+        | _ => []
+        }
+      } else {
+        []
+      }
+      Ok(Array.concat(base, supersede))
+    | Some({status: Connected}) => Ok([]) // idempotent
+    | Some({status: Disconnected}) => Error(IsDisconnected)
+    | None => Error(UnknownVersion)
+    }
+  | Deactivate(v) =>
+    switch state.known->Dict.get(v) {
+    | Some({status: Connected | Disconnected, definition}) =>
+      Ok(
+        Array.concat(
+          Array.concat(
+            [VersionDeactivated(definition)],
+            uiDeregisterEvents(definition.id, definition.uiFragments),
+          ),
+          promoteEvents(state, v),
+        ),
+      )
+    | Some({status: Inactive | Retired}) => Ok([]) // idempotent / archived no-op
+    | None => Error(UnknownVersion)
+    }
+  | Retire(v) =>
+    switch state.known->Dict.get(v) {
+    | Some({status: Retired}) => Ok([]) // idempotent
+    | Some({definition}) =>
+      Ok(
+        Array.concat(
+          Array.concat(
+            [VersionRetired(definition)],
+            uiDeregisterEvents(definition.id, definition.uiFragments),
+          ),
+          promoteEvents(state, v),
+        ),
+      )
+    | None => Error(UnknownVersion)
+    }
+  | ReportIncompatibility(def) => Ok([IncompatiblePluginDetected(def)])
+  }
+
+// Apply one event. `current` is recomputed (highest Connected) after every
+// status change — VersionSuperseded / VersionPromoted are informational records
+// for the history view and carry no state change beyond what the preceding
+// VersionConnected / VersionDisconnected already applied.
+let evolve = (state: state, event) => {
+  let setStatus = (v, status, definition) => {
+    let known = state.known->Dict.copy
+    known->Dict.set(v, {definition, status})
+    {current: highestConnected(known), known}
+  }
+  switch event {
+  | VersionConnected(def) => setStatus(def.version, Connected, def)
+  | VersionActivated(def) => setStatus(def.version, Connected, def)
+  | VersionDisconnected(def) => setStatus(def.version, Disconnected, def)
+  | VersionDeactivated(def) => setStatus(def.version, Inactive, def)
+  | VersionRetired(def) => setStatus(def.version, Retired, def)
+  | VersionDetected(_)
+  | VersionSuperseded(_)
+  | VersionPromoted(_)
+  | IncompatiblePluginDetected(_)
+  | UIFragmentRegistered(_)
+  | UIFragmentUpdated(_)
+  | UIFragmentDeregistered(_) => state
+  }
+}

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

@@ -0,0 +1,391 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Plugin$ReventlessCore from "../component/Plugin.res.mjs";
+
+let versionStatusSchema = S.union([
+  S.literal("Connected"),
+  S.literal("Disconnected"),
+  S.literal("Inactive"),
+  S.literal("Retired")
+]);
+
+let knownVersionSchema = S.schema(s => ({
+  definition: s.m(Plugin$Reventless.pluginDefinitionSchema),
+  status: s.m(versionStatusSchema)
+}));
+
+let stateSchema = S.schema(s => ({
+  current: s.m(S.option(Plugin$Reventless.versionSchema)),
+  known: s.m(S.dict(knownVersionSchema))
+}));
+
+let initialState_known = {};
+
+let initialState = {
+  current: undefined,
+  known: initialState_known
+};
+
+function uiRegisterEvents(pluginId, manifest) {
+  if (manifest !== undefined) {
+    return [{
+        TAG: "UIFragmentRegistered",
+        _0: {
+          pluginId: pluginId,
+          manifest: manifest
+        }
+      }];
+  } else {
+    return [];
+  }
+}
+
+function uiDeregisterEvents(pluginId, manifest) {
+  if (manifest !== undefined) {
+    return [{
+        TAG: "UIFragmentDeregistered",
+        _0: {
+          pluginId: pluginId
+        }
+      }];
+  } else {
+    return [];
+  }
+}
+
+function highestConnected(known) {
+  return Stdlib_Array.reduce(Object.entries(known), undefined, (acc, param) => {
+    let v = param[0];
+    let match = param[1].status;
+    if (match === "Connected" && !(acc !== undefined && Plugin$ReventlessCore.compareVersions(v, acc) <= 0)) {
+      return v;
+    } else {
+      return acc;
+    }
+  });
+}
+
+function highestConnectedExcluding(known, exclude) {
+  return Stdlib_Array.reduce(Object.entries(known), undefined, (acc, param) => {
+    let v = param[0];
+    if (v === exclude) {
+      return acc;
+    }
+    let match = param[1].status;
+    if (match === "Connected" && !(acc !== undefined && Plugin$ReventlessCore.compareVersions(v, acc) <= 0)) {
+      return v;
+    } else {
+      return acc;
+    }
+  });
+}
+
+function currentAfterConnect(known, v) {
+  let h = highestConnectedExcluding(known, v);
+  if (h !== undefined && Plugin$ReventlessCore.compareVersions(v, h) < 0) {
+    return h;
+  } else {
+    return v;
+  }
+}
+
+function connectEvents(state, v, def) {
+  let base = [{
+      TAG: "VersionConnected",
+      _0: def
+    }].concat(uiRegisterEvents(def.id, def.uiFragments));
+  let supersede;
+  if (currentAfterConnect(state.known, v) === v) {
+    let c = state.current;
+    if (c !== undefined) {
+      if (c !== v) {
+        let match = state.known[c];
+        supersede = match !== undefined ? [{
+              TAG: "VersionSuperseded",
+              _0: {
+                supersededVersion: c,
+                supersededDefinition: match.definition,
+                newVersion: v,
+                newDefinition: def
+              }
+            }] : [];
+      } else {
+        supersede = [];
+      }
+    } else {
+      supersede = [];
+    }
+  } else {
+    supersede = [];
+  }
+  return base.concat(supersede);
+}
+
+function promoteEvents(state, v) {
+  if (!Primitive_object.equal(state.current, v)) {
+    return [];
+  }
+  let w = highestConnectedExcluding(state.known, v);
+  if (w === undefined) {
+    return [];
+  }
+  let match = state.known[w];
+  if (match !== undefined) {
+    return [{
+        TAG: "VersionPromoted",
+        _0: match.definition
+      }];
+  } else {
+    return [];
+  }
+}
+
+function decide(state, command) {
+  switch (command.TAG) {
+    case "Heartbeat" :
+      let v = command._0;
+      let match = state.known[v];
+      if (match === undefined) {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "VersionDetected",
+              _0: v
+            }]
+        };
+      }
+      switch (match.status) {
+        case "Disconnected" :
+          return {
+            TAG: "Ok",
+            _0: connectEvents(state, v, match.definition)
+          };
+        case "Connected" :
+        case "Inactive" :
+        case "Retired" :
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+      }
+    case "Connect" :
+      let def = command._0;
+      let v$1 = def.version;
+      let match$1 = state.known[v$1];
+      if (match$1 !== undefined && match$1.status === "Connected") {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: connectEvents(state, v$1, def)
+        };
+      }
+    case "Disconnect" :
+      let v$2 = command._0;
+      let match$2 = state.known[v$2];
+      if (match$2 === undefined) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      if (match$2.status !== "Connected") {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      let definition = match$2.definition;
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "VersionDisconnected",
+            _0: definition
+          }].concat(uiDeregisterEvents(definition.id, definition.uiFragments)).concat(promoteEvents(state, v$2))
+      };
+    case "Activate" :
+      let v$3 = command._0;
+      let match$3 = state.known[v$3];
+      if (match$3 === undefined) {
+        return {
+          TAG: "Error",
+          _0: "UnknownVersion"
+        };
+      }
+      let definition$1 = match$3.definition;
+      switch (match$3.status) {
+        case "Connected" :
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        case "Disconnected" :
+          return {
+            TAG: "Error",
+            _0: "IsDisconnected"
+          };
+        case "Inactive" :
+        case "Retired" :
+          break;
+      }
+      let base = [{
+          TAG: "VersionActivated",
+          _0: definition$1
+        }].concat(uiRegisterEvents(definition$1.id, definition$1.uiFragments));
+      let supersede;
+      if (currentAfterConnect(state.known, v$3) === v$3) {
+        let c = state.current;
+        if (c !== undefined) {
+          if (c !== v$3) {
+            let match$4 = state.known[c];
+            supersede = match$4 !== undefined ? [{
+                  TAG: "VersionSuperseded",
+                  _0: {
+                    supersededVersion: c,
+                    supersededDefinition: match$4.definition,
+                    newVersion: v$3,
+                    newDefinition: definition$1
+                  }
+                }] : [];
+          } else {
+            supersede = [];
+          }
+        } else {
+          supersede = [];
+        }
+      } else {
+        supersede = [];
+      }
+      return {
+        TAG: "Ok",
+        _0: base.concat(supersede)
+      };
+      break;
+    case "Deactivate" :
+      let v$4 = command._0;
+      let match$5 = state.known[v$4];
+      if (match$5 === undefined) {
+        return {
+          TAG: "Error",
+          _0: "UnknownVersion"
+        };
+      }
+      let definition$2 = match$5.definition;
+      switch (match$5.status) {
+        case "Connected" :
+        case "Disconnected" :
+          break;
+        case "Inactive" :
+        case "Retired" :
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+      }
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "VersionDeactivated",
+            _0: definition$2
+          }].concat(uiDeregisterEvents(definition$2.id, definition$2.uiFragments)).concat(promoteEvents(state, v$4))
+      };
+      break;
+    case "ReportIncompatibility" :
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "IncompatiblePluginDetected",
+            _0: command._0
+          }]
+      };
+    case "Retire" :
+      let v$5 = command._0;
+      let match$6 = state.known[v$5];
+      if (match$6 === undefined) {
+        return {
+          TAG: "Error",
+          _0: "UnknownVersion"
+        };
+      }
+      let definition$3 = match$6.definition;
+      if (match$6.status === "Retired") {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "VersionRetired",
+              _0: definition$3
+            }].concat(uiDeregisterEvents(definition$3.id, definition$3.uiFragments)).concat(promoteEvents(state, v$5))
+        };
+      }
+  }
+}
+
+function evolve(state, event) {
+  let setStatus = (v, status, definition) => {
+    let known = Object.assign({}, state.known);
+    known[v] = {
+      definition: definition,
+      status: status
+    };
+    return {
+      current: highestConnected(known),
+      known: known
+    };
+  };
+  switch (event.TAG) {
+    case "VersionDisconnected" :
+      let def = event._0;
+      return setStatus(def.version, "Disconnected", def);
+    case "VersionConnected" :
+    case "VersionActivated" :
+      break;
+    case "VersionDeactivated" :
+      let def$1 = event._0;
+      return setStatus(def$1.version, "Inactive", def$1);
+    case "VersionRetired" :
+      let def$2 = event._0;
+      return setStatus(def$2.version, "Retired", def$2);
+    default:
+      return state;
+  }
+  let def$3 = event._0;
+  return setStatus(def$3.version, "Connected", def$3);
+}
+
+let Spec;
+
+let atomicCounter;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
+
+export {
+  Spec,
+  versionStatusSchema,
+  knownVersionSchema,
+  stateSchema,
+  initialState,
+  atomicCounter,
+  uiRegisterEvents,
+  uiDeregisterEvents,
+  highestConnected,
+  highestConnectedExcluding,
+  currentAfterConnect,
+  connectEvents,
+  promoteEvents,
+  decide,
+  evolve,
+  moduleUrl,
+}
+/* versionStatusSchema Not a pure module */