@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -0,0 +1,231 @@
+@@reventless.spec
+
+open ReventlessInfra.ExtensionPointMapping
+open Reventless.Plugin
+
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+
+module type Spec = {
+  let runtimeOps: PluginRuntimeOperations.operations
+  let environment: string
+  let updateApiSchema: option<Reventless.QueryEngine.operations => promise<unit>>
+  // Admin-mediated cross-plugin SNS subscription management. Invoked from the
+  // DoConnectPlugin / DoDisconnectPlugin directives — the connecting plugin's
+  // pluginDefinition is the only argument the admin needs because peer state
+  // is read from the Plugin RM at call time. None on the deploy-time EP
+  // Lambda (which only handles incoming commands like Heartbeat). Some only
+  // on the admin EventCollector entry point.
+  let manageSubscriptions: option<
+    (Reventless.Plugin.pluginDefinition, [#connect | #disconnect]) => promise<unit>,
+  >
+}
+
+module Make = (Spec: Spec) => {
+  let forwardCommand = async (
+    _id,
+    command,
+    extensionPointName,
+    queryEngine: Reventless.QueryEngine.operations,
+  ) =>
+    switch await queryEngine.scan(
+      ~readModelName=PluginSpec.name,
+      ~filterConfigs=[
+        ("extensionPointNames", Contains, String(extensionPointName)),
+        ("status", Contains, String("Connected")),
+      ],
+      ~limit=1000,
+    ) {
+    | jsons =>
+      switch jsons {
+      | [] =>
+        EffectLogger.logWarn(
+          ~comp="Core.Plugin",
+          `ForwardCommand: Couldn't find Plugin with ExtensionPoint ${extensionPointName}`,
+        )->Effect.runSync
+      | plugins =>
+        let plugin = plugins->Array.getUnsafe(0)
+        switch plugin->Message.decode(PluginsReadModelSpec.stateSchema) {
+        | plugin =>
+          let extensionPoint =
+            plugin.extensionPoints->Array.find(extensionPoint =>
+              extensionPoint.name == extensionPointName
+            )
+          switch extensionPoint {
+          | Some(extensionPoint) =>
+            switch await Spec.runtimeOps.messagePublish.sendMessageToChannel(
+              ~channelId=extensionPoint.commandTopic,
+              ~messageBody=command,
+            ) {
+            | _ =>
+              EffectLogger.logInfo(
+                ~comp="Core.Plugin",
+                `ForwardCommand: published command to ${plugin.name} ${extensionPoint.commandTopic}`,
+              )->Effect.runSync
+            | exception err =>
+              let errMsg =
+                err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+              EffectLogger.logError(
+                ~comp="Core.Plugin",
+                `ForwardCommand: Error on publish command: ${errMsg}`,
+              )->Effect.runSync
+            }
+
+          | None =>
+            EffectLogger.logWarn(
+              ~comp="Core.Plugin",
+              `ForwardCommand: Couldn't find ExtensionPoint ${extensionPointName} in ${plugin.name}`,
+            )->Effect.runSync
+          }
+        | exception err =>
+          let errMsg =
+            err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+          EffectLogger.logError(~comp="Core.Plugin", `ForwardCommand: Couldn't decode Plugin: ${errMsg}`)->Effect.runSync
+        }
+      }
+    }
+
+  let directiveHandler = async (
+    createSchedule: Reventless.Schedule.create,
+    deleteSchedule: Reventless.Schedule.delete,
+    queryEngine: Reventless.QueryEngine.operations,
+    directive,
+  ) =>
+    switch directive {
+    | PluginExtensionPointSpec.CreateDisconnectSchedule(id, timeout) =>
+      await createSchedule({
+        name: Spec.environment ++ ("-" ++ id),
+        rate: timeout->ScheduleOps.minutesFromNow,
+        payload: {
+          Message.id,
+          meta: Message.generateMeta(~service="Core.Plugin", ~user="Scheduler"),
+          command: PluginExtensionPointSpec.DisconnectPlugin,
+        }
+        ->Message.encodeCommand'(S.string, PluginExtensionPointSpec.commandSchema)
+        ->JSON.stringify,
+      })
+    | DeleteDisconnectSchedule(id) => await deleteSchedule(id)
+    | ForwardCommand({id, command, extensionPointName}) =>
+      await forwardCommand(id, command, extensionPointName, queryEngine)
+    | DoConnectPlugin(pluginDef) =>
+      switch Spec.manageSubscriptions {
+      | Some(fn) => await fn(pluginDef, #connect)
+      | None => ()
+      }
+      switch Spec.updateApiSchema {
+      | Some(fn) => await fn(queryEngine)
+      | None => ()
+      }
+    | DoDisconnectPlugin(pluginDef) =>
+      switch Spec.manageSubscriptions {
+      | Some(fn) => await fn(pluginDef, #disconnect)
+      | None => ()
+      }
+      switch Spec.updateApiSchema {
+      | Some(fn) => await fn(queryEngine)
+      | None => ()
+      }
+    }
+
+  module PluginMapping = {
+    module ExtensionPoint = PluginExtensionPointSpec
+    module Delegate = PluginSpec
+
+    // Unused by ExtensionPointMapping.Make (it reads name/Delegate/map* only);
+    // present solely to satisfy the input module type. The actually-consumed
+    // dynamic-import specifier is the file-level `moduleUrl` (@@reventless.spec
+    // injected, move-safe) referenced from Plugin_Helpers.
+    let moduleUrl = PluginExtensionPointSpec.moduleUrl
+
+    // The Plugin aggregate is keyed by plugin **name**; the EP transport id is
+    // `name@version` (Approach 1). Translate at this boundary: route Delegate
+    // commands to `Plugin.name(id)` and carry the version (from the id) in the
+    // command. The EP keeps its per-version disconnect schedule keyed by the
+    // full `id` — liveness stays scheduler-driven, the aggregate never reads time.
+    let mapIncomingCommand = (id, cmd, _meta: Message.meta) =>
+      switch cmd {
+      | PluginExtensionPointSpec.Heartbeat(interval) => [
+          PublishCommand(Plugin.name(id), Delegate.Heartbeat(Plugin.version(id))),
+          // Re-create timeout (+2 minute to avoid toggling)
+          // 1 minute because Schedules can only be created by minute
+          // 1 additional minute to allow additional latency
+          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
+        // IncompatiblePlugin event is recorded; the connection still proceeds.
+        let protocolErrors =
+          pluginDefinition.extensionProtocols->Array.flatMap(proto =>
+            ReventlessInterop.Compat.validateProtocol(
+              ~host=ReventlessInterop.CompatMatrix.corePlugin,
+              ~extensionPointName=proto.extensionPointName,
+              ~commandVersion=proto.commandVersion,
+              ~eventVersion=proto.eventVersion,
+            )
+          )
+        let reportAction = if protocolErrors->Array.length > 0 {
+          EffectLogger.logWarn(
+            ~comp="Core.Plugin",
+            `Protocol version mismatch for plugin ${pluginDefinition.id}: ${protocolErrors
+              ->JSON.stringifyAny
+              ->Option.getOr("[]")}`,
+          )->Effect.runSync
+          [PublishCommand(Plugin.name(id), Delegate.ReportIncompatibility(pluginDefinition))]
+        } else {
+          []
+        }
+        Array.concat(
+          [PublishCommand(Plugin.name(id), Delegate.Connect(pluginDefinition))],
+          reportAction,
+        )
+      | DisconnectPlugin => [
+          PublishCommand(Plugin.name(id), Delegate.Disconnect(Plugin.version(id))),
+          HandleDirective(directiveHandler, DeleteDisconnectSchedule(id)),
+        ]
+      | ForwardCommand(forwardCommand) => [HandleDirective(directiveHandler, ForwardCommand(forwardCommand))]
+      }
+
+    let mapOutgoingEvent = Some(
+      (id, event, _meta, _queryEngine) =>
+        switch event {
+        // `id` is the Plugin aggregate id (= name). VersionDetected re-builds the
+        // `name@version` id so the matching version's ConnectExtension (which keys
+        // on its own pluginDefinition.id) answers the handshake. Events carrying a
+        // definition publish with `def.id` (= name@version), preserving the prior
+        // cross-plugin wire id.
+        | Delegate.VersionDetected(version) => [
+            PublishEvent(Plugin.makeId(id, version), PluginExtensionPointSpec.UnknownPluginDetected),
+          ]
+        | VersionConnected(pluginDefinition)
+        | VersionPromoted(pluginDefinition) => [
+            PublishEvent(pluginDefinition.id, PluginConnected(pluginDefinition)),
+            HandleDirective(directiveHandler, DoConnectPlugin(pluginDefinition)),
+          ]
+        // Supersession shares the name-keyed infra with the new current version
+        // (whose VersionConnected already re-stitched the schema); no EP action.
+        | VersionSuperseded(_) => []
+        | VersionDisconnected(pluginDefinition) => [
+            PublishEvent(pluginDefinition.id, PluginDisconnected(pluginDefinition)),
+            HandleDirective(directiveHandler, DoDisconnectPlugin(pluginDefinition)),
+          ]
+        | VersionDeactivated(pluginDefinition) => [
+            PublishEvent(pluginDefinition.id, PluginDeactivated(pluginDefinition)),
+            HandleDirective(directiveHandler, DoDisconnectPlugin(pluginDefinition)),
+          ]
+        | VersionActivated(pluginDefinition) => [
+            PublishEvent(pluginDefinition.id, PluginActivated(pluginDefinition)),
+          ]
+        | VersionRetired(pluginDefinition) => [
+            PublishEvent(pluginDefinition.id, PluginRetired(pluginDefinition)),
+            HandleDirective(directiveHandler, DoDisconnectPlugin(pluginDefinition)),
+          ]
+        | IncompatiblePluginDetected(pluginDefinition) => [
+            PublishEvent(pluginDefinition.id, IncompatiblePlugin(pluginDefinition)),
+          ]
+        | UIFragmentRegistered(_) | UIFragmentUpdated(_) | UIFragmentDeregistered(_) => []
+        },
+    )
+  }
+
+  module Mapping = ReventlessInfra.ExtensionPointMapping.Make(PluginMapping)
+}

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

@@ -0,0 +1,353 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Plugin$ReventlessCore from "../component/Plugin.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as Compat$ReventlessInterop from "@reventlessdev/reventless-interop/src/Compat.res.mjs";
+import * as PluginSpec$ReventlessCore from "../lifecycle/PluginSpec.res.mjs";
+import * as ScheduleOps$ReventlessCore from "../../util/ScheduleOps.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as CompatMatrix$ReventlessInterop from "@reventlessdev/reventless-interop/src/protocol/CompatMatrix.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "../lifecycle/PluginsReadModelSpec.res.mjs";
+import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+
+function Make(Spec) {
+  let forwardCommand = async (_id, command, extensionPointName, queryEngine) => {
+    let jsons = await queryEngine.scan(PluginSpec$ReventlessCore.name, [
+      [
+        "extensionPointNames",
+        "Contains",
+        {
+          TAG: "String",
+          _0: extensionPointName
+        }
+      ],
+      [
+        "status",
+        "Contains",
+        {
+          TAG: "String",
+          _0: "Connected"
+        }
+      ]
+    ], 1000);
+    if (jsons.length === 0) {
+      return Effect.runSync(EffectLogger$ReventlessCore.logWarn("Core.Plugin", undefined, `ForwardCommand: Couldn't find Plugin with ExtensionPoint ` + extensionPointName));
+    }
+    let plugin = jsons[0];
+    let exit = 0;
+    let plugin$1;
+    try {
+      plugin$1 = Message$ReventlessCore.decode(plugin, PluginsReadModelSpec$ReventlessCore.stateSchema);
+      exit = 1;
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+      return Effect.runSync(EffectLogger$ReventlessCore.logError("Core.Plugin", undefined, `ForwardCommand: Couldn't decode Plugin: ` + errMsg));
+    }
+    if (exit === 1) {
+      let extensionPoint = plugin$1.extensionPoints.find(extensionPoint => extensionPoint.name === extensionPointName);
+      if (extensionPoint === undefined) {
+        return Effect.runSync(EffectLogger$ReventlessCore.logWarn("Core.Plugin", undefined, `ForwardCommand: Couldn't find ExtensionPoint ` + extensionPointName + ` in ` + plugin$1.name));
+      }
+      let exit$1 = 0;
+      let val;
+      try {
+        val = await Spec.runtimeOps.messagePublish.sendMessageToChannel(extensionPoint.commandTopic, command);
+        exit$1 = 2;
+      } catch (raw_err$1) {
+        let err$1 = Primitive_exceptions.internalToException(raw_err$1);
+        let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err$1), Stdlib_JsExn.message), "unknown");
+        return Effect.runSync(EffectLogger$ReventlessCore.logError("Core.Plugin", undefined, `ForwardCommand: Error on publish command: ` + errMsg$1));
+      }
+      if (exit$1 === 2) {
+        return Effect.runSync(EffectLogger$ReventlessCore.logInfo("Core.Plugin", undefined, `ForwardCommand: published command to ` + plugin$1.name + ` ` + extensionPoint.commandTopic));
+      }
+    }
+  };
+  let directiveHandler = async (createSchedule, deleteSchedule, queryEngine, directive) => {
+    switch (directive.TAG) {
+      case "CreateDisconnectSchedule" :
+        let id = directive._0;
+        return await createSchedule({
+          name: Spec.environment + ("-" + id),
+          rate: ScheduleOps$ReventlessCore.minutesFromNow(directive._1),
+          payload: JSON.stringify(Message$ReventlessCore.encodeCommand$p({
+            id: id,
+            meta: Message$ReventlessCore.generateMeta("Core.Plugin", undefined, "Scheduler", undefined, undefined, undefined, undefined, undefined),
+            command: "DisconnectPlugin"
+          }, S.string, PluginExtensionPointSpec$ReventlessInfra.commandSchema))
+        });
+      case "DeleteDisconnectSchedule" :
+        return await deleteSchedule(directive._0);
+      case "DoConnectPlugin" :
+        let fn = Spec.manageSubscriptions;
+        if (fn !== undefined) {
+          await fn(directive._0, "connect");
+        }
+        let fn$1 = Spec.updateApiSchema;
+        if (fn$1 !== undefined) {
+          return await fn$1(queryEngine);
+        } else {
+          return;
+        }
+      case "DoDisconnectPlugin" :
+        let fn$2 = Spec.manageSubscriptions;
+        if (fn$2 !== undefined) {
+          await fn$2(directive._0, "disconnect");
+        }
+        let fn$3 = Spec.updateApiSchema;
+        if (fn$3 !== undefined) {
+          return await fn$3(queryEngine);
+        } else {
+          return;
+        }
+      case "ForwardCommand" :
+        let match = directive._0;
+        return await forwardCommand(match.id, match.command, match.extensionPointName, queryEngine);
+    }
+  };
+  let mapIncomingCommand = (id, cmd, _meta) => {
+    if (typeof cmd !== "object") {
+      return [
+        {
+          TAG: "PublishCommand",
+          _0: Plugin$ReventlessCore.name(id),
+          _1: {
+            TAG: "Disconnect",
+            _0: Plugin$ReventlessCore.version(id)
+          }
+        },
+        {
+          TAG: "HandleDirective",
+          _0: directiveHandler,
+          _1: {
+            TAG: "DeleteDisconnectSchedule",
+            _0: id
+          }
+        }
+      ];
+    }
+    switch (cmd.TAG) {
+      case "Heartbeat" :
+        return [
+          {
+            TAG: "PublishCommand",
+            _0: Plugin$ReventlessCore.name(id),
+            _1: {
+              TAG: "Heartbeat",
+              _0: Plugin$ReventlessCore.version(id)
+            }
+          },
+          {
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "CreateDisconnectSchedule",
+              _0: id,
+              _1: cmd._0 + 2 | 0
+            }
+          }
+        ];
+      case "ConnectPlugin" :
+        let pluginDefinition = cmd._0;
+        let protocolErrors = pluginDefinition.extensionProtocols.flatMap(proto => Compat$ReventlessInterop.validateProtocol(CompatMatrix$ReventlessInterop.corePlugin, proto.extensionPointName, proto.commandVersion, proto.eventVersion));
+        let reportAction = protocolErrors.length !== 0 ? (Effect.runSync(EffectLogger$ReventlessCore.logWarn("Core.Plugin", undefined, `Protocol version mismatch for plugin ` + pluginDefinition.id + `: ` + Stdlib_Option.getOr(JSON.stringify(protocolErrors), "[]"))), [{
+              TAG: "PublishCommand",
+              _0: Plugin$ReventlessCore.name(id),
+              _1: {
+                TAG: "ReportIncompatibility",
+                _0: pluginDefinition
+              }
+            }]) : [];
+        return [{
+            TAG: "PublishCommand",
+            _0: Plugin$ReventlessCore.name(id),
+            _1: {
+              TAG: "Connect",
+              _0: pluginDefinition
+            }
+          }].concat(reportAction);
+      case "ForwardCommand" :
+        return [{
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "ForwardCommand",
+              _0: cmd._0
+            }
+          }];
+    }
+  };
+  let mapOutgoingEvent = (id, event, _meta, _queryEngine) => {
+    switch (event.TAG) {
+      case "VersionDetected" :
+        return [{
+            TAG: "PublishEvent",
+            _0: Plugin$ReventlessCore.makeId(id, event._0),
+            _1: "UnknownPluginDetected"
+          }];
+      case "VersionConnected" :
+      case "VersionPromoted" :
+        break;
+      case "VersionDisconnected" :
+        let pluginDefinition = event._0;
+        return [
+          {
+            TAG: "PublishEvent",
+            _0: pluginDefinition.id,
+            _1: {
+              TAG: "PluginDisconnected",
+              _0: pluginDefinition
+            }
+          },
+          {
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "DoDisconnectPlugin",
+              _0: pluginDefinition
+            }
+          }
+        ];
+      case "VersionActivated" :
+        let pluginDefinition$1 = event._0;
+        return [{
+            TAG: "PublishEvent",
+            _0: pluginDefinition$1.id,
+            _1: {
+              TAG: "PluginActivated",
+              _0: pluginDefinition$1
+            }
+          }];
+      case "VersionDeactivated" :
+        let pluginDefinition$2 = event._0;
+        return [
+          {
+            TAG: "PublishEvent",
+            _0: pluginDefinition$2.id,
+            _1: {
+              TAG: "PluginDeactivated",
+              _0: pluginDefinition$2
+            }
+          },
+          {
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "DoDisconnectPlugin",
+              _0: pluginDefinition$2
+            }
+          }
+        ];
+      case "VersionRetired" :
+        let pluginDefinition$3 = event._0;
+        return [
+          {
+            TAG: "PublishEvent",
+            _0: pluginDefinition$3.id,
+            _1: {
+              TAG: "PluginRetired",
+              _0: pluginDefinition$3
+            }
+          },
+          {
+            TAG: "HandleDirective",
+            _0: directiveHandler,
+            _1: {
+              TAG: "DoDisconnectPlugin",
+              _0: pluginDefinition$3
+            }
+          }
+        ];
+      case "IncompatiblePluginDetected" :
+        let pluginDefinition$4 = event._0;
+        return [{
+            TAG: "PublishEvent",
+            _0: pluginDefinition$4.id,
+            _1: {
+              TAG: "IncompatiblePlugin",
+              _0: pluginDefinition$4
+            }
+          }];
+      default:
+        return [];
+    }
+    let pluginDefinition$5 = event._0;
+    return [
+      {
+        TAG: "PublishEvent",
+        _0: pluginDefinition$5.id,
+        _1: {
+          TAG: "PluginConnected",
+          _0: pluginDefinition$5
+        }
+      },
+      {
+        TAG: "HandleDirective",
+        _0: directiveHandler,
+        _1: {
+          TAG: "DoConnectPlugin",
+          _0: pluginDefinition$5
+        }
+      }
+    ];
+  };
+  let PluginMapping = {
+    ExtensionPoint: undefined,
+    Delegate: undefined,
+    moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+    mapIncomingCommand: mapIncomingCommand,
+    mapOutgoingEvent: mapOutgoingEvent
+  };
+  let Mapping = ExtensionPointMapping$ReventlessInfra.Make({
+    ExtensionPoint: {
+      name: PluginExtensionPointSpec$ReventlessInfra.name,
+      moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+      commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema,
+      eventSchema: PluginExtensionPointSpec$ReventlessInfra.eventSchema,
+      directiveSchema: PluginExtensionPointSpec$ReventlessInfra.directiveSchema
+    },
+    Delegate: {
+      Id: Id$Reventless.$$String,
+      name: PluginSpec$ReventlessCore.name,
+      eventSchema: PluginSpec$ReventlessCore.eventSchema,
+      errorSchema: PluginSpec$ReventlessCore.errorSchema,
+      commandSchema: PluginSpec$ReventlessCore.commandSchema,
+      moduleUrl: PluginSpec$ReventlessCore.moduleUrl,
+      commandAuthorization: PluginSpec$ReventlessCore.commandAuthorization
+    },
+    moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+    mapIncomingCommand: mapIncomingCommand,
+    mapOutgoingEvent: mapOutgoingEvent
+  });
+  return {
+    forwardCommand: forwardCommand,
+    directiveHandler: directiveHandler,
+    PluginMapping: PluginMapping,
+    Mapping: Mapping
+  };
+}
+
+let name = "PluginExtensionPoint";
+
+let Id;
+
+let PluginExtensionPointSpec;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs";
+
+export {
+  name,
+  Id,
+  PluginExtensionPointSpec,
+  Make,
+  moduleUrl,
+}
+/* S Not a pure module */