@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/component/Plugin_BuiltHook.res

@@ -0,0 +1,141 @@
+// Runtime-safe plugin hook registry — no Pulumi imports.
+//
+// Contains only plain-data types and mutable callback refs that are safe
+// to import from Lambda handlers. Plugin_Helpers re-exports everything
+// here for backward compatibility.
+//
+// Separated from Plugin_Helpers because Plugin_Helpers imports Pulumi
+// for deploy-time Output serialization, which makes it unusable at runtime.
+
+// ---------------------------------------------------------------------------
+// Plugin classification types — optional metadata consumers can attach to
+// describe a plugin's role and origin.
+// ---------------------------------------------------------------------------
+
+/** Classifies the business role of a plugin. Absent defaults to Domain. */
+type pluginKind =
+  | Domain
+  | PlatformInfrastructure
+  | Commercial
+  | Marketplace
+
+/** Classifies the architectural style of a plugin's domain model. */
+type architectureType =
+  | Aggregate
+  | Dcb
+  | Hybrid
+  | SdkService
+  | Mcp
+  | Mixed
+
+// ---------------------------------------------------------------------------
+// Field-level schema types — used by SchemaWalker to expose the structural
+// shape of command, event, and state types at deploy time.
+// ---------------------------------------------------------------------------
+
+/** A single field extracted from a sury object schema. */
+type fieldSchema = {
+  name: string,
+  /** Human-readable type: "string", "float", "bool", "int", "array", "object", "option", "union", "unknown" */
+  typeDescription: string,
+  /** true = required field (field: T); false = optional (field?: T) */
+  isRequired: bool,
+}
+
+/** One constructor in a variant type. */
+type constructorSchema = {
+  name: string,
+  fields: array<fieldSchema>,
+}
+
+/** Schema for one named type (a command, event, or state type). */
+type typeSchema = {
+  typeName: string,
+  /** "record" | "variant" | "unknown" */
+  kind: string,
+  fields: array<fieldSchema>,
+  constructors?: array<constructorSchema>,
+  /** SHA256 of sorted "name:typeDescription:isRequired" tuples — stable shape fingerprint. */
+  structuralHash: string,
+}
+
+// ---------------------------------------------------------------------------
+// Shared schema type — used by both pluginBuiltComponent and
+// pluginDeployedComponent to describe per-component schema details.
+// ---------------------------------------------------------------------------
+type pluginDeployedSchema = {
+  commandTypes?: array<string>,
+  eventTypes?: array<string>,
+  errorTypes?: array<string>,
+  stateType?: string,
+  sourceNames?: array<string>,
+  queryFields?: array<string>,
+  consumedEventTypes?: array<string>,
+  producedCommandTypes?: array<string>,
+  /** For routing slices (automation / inbound + outbound translation): the name
+   of the writable component this slice routes its commands to. */
+  targetName?: string,
+  sharedBy?: array<string>,
+  extensionPointName?: string,
+  providerPlugin?: string,
+  subscriberPlugins?: array<string>,
+  /** Field-level schema per command type (one entry per variant constructor). */
+  commandSchemas?: array<typeSchema>,
+  /** Field-level schema per event type (one entry per variant constructor). */
+  eventSchemas?: array<typeSchema>,
+  /** Field-level schema for the state type. */
+  stateSchema?: typeSchema,
+}
+
+// ---------------------------------------------------------------------------
+// Plugin-built hook — fires synchronously after plugin construction with a
+// plain-data summary of the plugin's components.
+// ---------------------------------------------------------------------------
+type pluginBuiltComponent = {
+  name: string,
+  kind: string,
+  schema: pluginDeployedSchema,
+}
+
+type pluginBuiltInfo = {
+  name: string,
+  version: string,
+  kind?: pluginKind,
+  displayName?: string,
+  vendor?: string,
+  architectureType?: architectureType,
+  components: array<pluginBuiltComponent>,
+}
+
+// Registry for component schemas — populated during Plugin_Builder.construct,
+// read by exportPluginOutputs to populate pluginDeployedComponent.schema.
+let componentSchemaRegistry: dict<pluginDeployedSchema> = Dict.make()
+
+// Optional metadata consumers register before platform construction to
+// attach classification info to pluginBuiltInfo / pluginDeployedInfo.
+type pluginMetadata = {
+  kind?: pluginKind,
+  displayName?: string,
+  vendor?: string,
+  architectureType?: architectureType,
+}
+
+let pluginMetadataRegistry: ref<option<pluginMetadata>> = ref(None)
+
+let registerPluginMetadata = (metadata: pluginMetadata) => {
+  pluginMetadataRegistry.contents = Some(metadata)
+}
+
+let clearPluginMetadata = () => {
+  pluginMetadataRegistry.contents = None
+}
+
+let onPluginBuiltHook: ref<option<pluginBuiltInfo => unit>> = ref(None)
+
+let registerOnPluginBuilt = (hook: pluginBuiltInfo => unit) => {
+  onPluginBuiltHook.contents = Some(hook)
+}
+
+let clearOnPluginBuilt = () => {
+  onPluginBuiltHook.contents = None
+}

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

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let componentSchemaRegistry = {};
+
+let pluginMetadataRegistry = {
+  contents: undefined
+};
+
+function registerPluginMetadata(metadata) {
+  pluginMetadataRegistry.contents = metadata;
+}
+
+function clearPluginMetadata() {
+  pluginMetadataRegistry.contents = undefined;
+}
+
+let onPluginBuiltHook = {
+  contents: undefined
+};
+
+function registerOnPluginBuilt(hook) {
+  onPluginBuiltHook.contents = hook;
+}
+
+function clearOnPluginBuilt() {
+  onPluginBuiltHook.contents = undefined;
+}
+
+export {
+  componentSchemaRegistry,
+  pluginMetadataRegistry,
+  registerPluginMetadata,
+  clearPluginMetadata,
+  onPluginBuiltHook,
+  registerOnPluginBuilt,
+  clearOnPluginBuilt,
+}
+/* No side effect */

package/src/plugin/component/Plugin_Callback.res

@@ -0,0 +1,98 @@
+type jsonEventsHandler = (JSON.t, Reventless.Plugin.pluginDefinition) => promise<unit>
+type jsonEventsHandlersByService = dict<array<jsonEventsHandler>>
+
+module type Spec = {
+  let pluginDefinition: Reventless.Plugin.pluginDefinition
+  let incomingConnectExtensionEventHandlers: jsonEventsHandlersByService
+  let outgoingExtensionPointEventHandlers: jsonEventsHandlersByService
+  let outgoingExtensionEventHandlers: jsonEventsHandlersByService
+  let incomingExtensionEventHandlers: jsonEventsHandlersByService
+}
+
+module type T = {
+  let handleJsonEvents: EventCollector.jsonEventsHandler
+}
+
+module Make = (Spec: Spec): T => {
+  let warnedServices = ref(Belt.Set.String.empty)
+
+  let knownServiceNames = () =>
+    [
+      Spec.incomingConnectExtensionEventHandlers,
+      Spec.outgoingExtensionPointEventHandlers,
+      Spec.outgoingExtensionEventHandlers,
+      Spec.incomingExtensionEventHandlers,
+    ]
+    ->Array.flatMap(d => d->Dict.keysToArray)
+    ->Belt.Set.String.fromArray
+    ->Belt.Set.String.toArray
+
+  // A plugin's own DCB EventLog feeds Plugin_Callback through the shared
+  // EventCollector, but the events terminate at intra-plugin SVS/RM consumers
+  // via a different path. When no outgoing EP/Extension wants them here, that
+  // is normal — silence the warning rather than misleadingly suggesting a
+  // Delegate.name mismatch.
+  let ownDcbEventLogServiceName = `${Spec.pluginDefinition.name}DcbEventLog`
+
+  let warnUnmatchedServiceOnce = (~id, ~serviceName) =>
+    if (
+      serviceName == ownDcbEventLogServiceName ||
+        warnedServices.contents->Belt.Set.String.has(serviceName)
+    ) {
+      Effect.succeed()
+    } else {
+      warnedServices := warnedServices.contents->Belt.Set.String.add(serviceName)
+      let known = knownServiceNames()->Array.join(", ")
+      EffectLogger.logWarn(
+        ~comp=`Plugin(${id})`,
+        `incoming event has service="${serviceName}" but no handler is registered for it — known services: [${known}]. Likely cause: an ExtensionPointMapping/Extension Delegate.name does not match the source's serviceName (DCB sources use "<plugin>DcbEventLog").`,
+      )
+    }
+
+  let handleEventEffect = (eventJson', jsonEventsHandlersByService) =>
+    eventJson'
+    ->Message.serviceNameOfMsg
+    ->Option.flatMap(serviceName => jsonEventsHandlersByService->Dict.get(serviceName))
+    ->Option.mapOr(Effect.succeed(), jsonEventsHandlers =>
+      Effect.all(
+        jsonEventsHandlers->Array.map(jsonEventsHandler =>
+          Effect.promise(() => jsonEventsHandler(eventJson', Spec.pluginDefinition))
+        ),
+        {"concurrency": "unbounded"},
+      )->Effect.map(_ => ())
+    )
+
+  let handleJsonEvents: EventCollector.jsonEventsHandler = stream =>
+    stream
+    ->Stream.mapEffect(eventJson' => {
+      let id = Spec.pluginDefinition.id
+      eventJson'
+      ->Message.serviceNameOfMsg
+      ->Option.mapOr(Effect.succeed(), serviceName => {
+        let isHandled =
+          Spec.incomingConnectExtensionEventHandlers->Dict.get(serviceName)->Option.isSome ||
+          Spec.outgoingExtensionPointEventHandlers->Dict.get(serviceName)->Option.isSome ||
+          Spec.outgoingExtensionEventHandlers->Dict.get(serviceName)->Option.isSome ||
+          Spec.incomingExtensionEventHandlers->Dict.get(serviceName)->Option.isSome
+        if isHandled {
+          EffectLogger.logInfo(~comp=`Plugin(${id})`, `incoming event: ${LogFormat.eventSummary(eventJson')}`)
+          ->Effect.zipRight(
+            handleEventEffect(eventJson', Spec.incomingConnectExtensionEventHandlers)
+            ->Effect.zipRight(
+              Effect.all(
+                [
+                  handleEventEffect(eventJson', Spec.outgoingExtensionPointEventHandlers),
+                  handleEventEffect(eventJson', Spec.outgoingExtensionEventHandlers),
+                  handleEventEffect(eventJson', Spec.incomingExtensionEventHandlers),
+                ],
+                {"concurrency": "unbounded"},
+              )->Effect.map(_ => ())
+            )
+          )
+        } else {
+          warnUnmatchedServiceOnce(~id, ~serviceName)
+        }
+      })
+    })
+    ->Stream.runDrain
+}

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

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+function Make(Spec) {
+  let warnedServices = {
+    contents: undefined
+  };
+  let knownServiceNames = () => Belt_SetString.toArray(Belt_SetString.fromArray([
+    Spec.incomingConnectExtensionEventHandlers,
+    Spec.outgoingExtensionPointEventHandlers,
+    Spec.outgoingExtensionEventHandlers,
+    Spec.incomingExtensionEventHandlers
+  ].flatMap(d => Object.keys(d))));
+  let ownDcbEventLogServiceName = Spec.pluginDefinition.name + `DcbEventLog`;
+  let handleEventEffect = (eventJson$p, jsonEventsHandlersByService) => Stdlib_Option.mapOr(Stdlib_Option.flatMap(Message$ReventlessCore.serviceNameOfMsg(eventJson$p), serviceName => jsonEventsHandlersByService[serviceName]), Effect.succeed(), jsonEventsHandlers => Effect.map(Effect.all(jsonEventsHandlers.map(jsonEventsHandler => Effect.promise(() => jsonEventsHandler(eventJson$p, Spec.pluginDefinition))), {
+    concurrency: "unbounded"
+  }), param => {}));
+  let handleJsonEvents = stream => Stream.runDrain(Stream.mapEffect(stream, eventJson$p => {
+    let id = Spec.pluginDefinition.id;
+    return Stdlib_Option.mapOr(Message$ReventlessCore.serviceNameOfMsg(eventJson$p), Effect.succeed(), serviceName => {
+      let isHandled = Stdlib_Option.isSome(Spec.incomingConnectExtensionEventHandlers[serviceName]) || Stdlib_Option.isSome(Spec.outgoingExtensionPointEventHandlers[serviceName]) || Stdlib_Option.isSome(Spec.outgoingExtensionEventHandlers[serviceName]) || Stdlib_Option.isSome(Spec.incomingExtensionEventHandlers[serviceName]);
+      if (isHandled) {
+        return Effect.zipRight(EffectLogger$ReventlessCore.logInfo(`Plugin(` + id + `)`, undefined, `incoming event: ` + LogFormat$ReventlessCore.eventSummary(eventJson$p)), Effect.zipRight(handleEventEffect(eventJson$p, Spec.incomingConnectExtensionEventHandlers), Effect.map(Effect.all([
+          handleEventEffect(eventJson$p, Spec.outgoingExtensionPointEventHandlers),
+          handleEventEffect(eventJson$p, Spec.outgoingExtensionEventHandlers),
+          handleEventEffect(eventJson$p, Spec.incomingExtensionEventHandlers)
+        ], {
+          concurrency: "unbounded"
+        }), param => {})));
+      } else {
+        if (serviceName === ownDcbEventLogServiceName || Belt_SetString.has(warnedServices.contents, serviceName)) {
+          return Effect.succeed();
+        }
+        warnedServices.contents = Belt_SetString.add(warnedServices.contents, serviceName);
+        let known = knownServiceNames().join(", ");
+        return EffectLogger$ReventlessCore.logWarn(`Plugin(` + id + `)`, undefined, `incoming event has service="` + serviceName + `" but no handler is registered for it — known services: [` + known + `]. Likely cause: an ExtensionPointMapping/Extension Delegate.name does not match the source's serviceName (DCB sources use "<plugin>DcbEventLog").`);
+      }
+    });
+  }));
+  return {
+    handleJsonEvents: handleJsonEvents
+  };
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */