@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Extension/Extension_Operations.res.mjs

@@ -0,0 +1,154 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.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";
+import * as Util_Promise$ReventlessCore from "../../util/Util_Promise.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+
+function Make(MappingSpec) {
+  return Mappings => (Ops => {
+    let comp = `Extension(` + MappingSpec.name + `.` + Mappings.name + `)`;
+    let findOutgoingMapping = (delegateNameOpt, mappings) => Stdlib_Option.flatMap(delegateNameOpt, delegateName => mappings.find(Mapping => Mapping.delegateName === delegateName));
+    let mapIncomingEvent = (event$p, pluginDef, queryEngine) => Mappings.mappings.map(Mapping => Mapping.mapIncomingEvent(event$p, pluginDef, queryEngine)).flat();
+    let mapOutgoingEvent = (eventJson$p, pluginDef) => {
+      let Mapping = findOutgoingMapping(Message$ReventlessCore.serviceNameOfMsg(eventJson$p), Mappings.mappings);
+      if (Mapping === undefined) {
+        return Stdlib_JsError.throwWithMessage("ExtensionPoint.Mapping: Missing mapping for " + JSON.stringify(eventJson$p));
+      }
+      let mapOutgoingEvent$1 = Mapping.mapOutgoingEvent;
+      if (mapOutgoingEvent$1 !== undefined) {
+        return mapOutgoingEvent$1(eventJson$p, pluginDef);
+      } else {
+        Effect.runSync(EffectLogger$ReventlessCore.logError(comp, undefined, "mapOutgoingEvent: shouldn't be called, because Plugin EventCollector shouldn't subscribe to EventLog stream not having mapOutgoingEvent() !"));
+        return [];
+      }
+    };
+    let publishAggregateCommand = async (aggregateName, cmdJson) => {
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `EP→` + aggregateName + `: ` + LogFormat$ReventlessCore.bold(Message$ReventlessCore.variantNameOfJson(cmdJson.commandJson)) + `(` + cmdJson.id + `)`));
+      let pub = Stdlib_Option.getOrThrow(Ops.publishToAggregates[aggregateName], undefined);
+      try {
+        return await pub([cmdJson]);
+      } 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(comp, undefined, `Error on publish command to aggregate ` + aggregateName + `: ` + errMsg));
+      }
+    };
+    let publishPluginExtensionPointCommand = async cmdJson => {
+      try {
+        return await Ops.publishToPluginExtensionPoint([cmdJson]);
+      } 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(comp, undefined, `Error on publish command to Plugin ExtensionPoint: ` + errMsg));
+      }
+    };
+    let forwardCommand = (extensionPointName, commandJson) => {
+      let command = {
+        TAG: "ForwardCommand",
+        _0: {
+          extensionPointName: extensionPointName,
+          id: commandJson.id,
+          command: Message$ReventlessCore.toMessageBody(commandJson)
+        }
+      };
+      return publishPluginExtensionPointCommand({
+        id: "",
+        meta: Message$ReventlessCore.deriveMeta(commandJson.meta, undefined),
+        commandJson: Message$ReventlessCore.encode(command, PluginExtensionPointSpec$ReventlessInfra.commandSchema)
+      });
+    };
+    let handleDirective = async handler => {
+      try {
+        return await handler();
+      } 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(comp, undefined, `Error on handling directive: ` + errMsg));
+      }
+    };
+    let applyIncomingCommandAction = async action => {
+      let tmp;
+      switch (action.TAG) {
+        case "AbstractPublishAggregateCommand" :
+          tmp = publishAggregateCommand(action._0, action._1);
+          break;
+        case "AbstractPublishAggregateCommandAsync" :
+          let match = await action._0;
+          tmp = publishAggregateCommand(match[0], match[1]);
+          break;
+        case "AbstractPublishAggregateCommandsAsync" :
+          let publish = async promise => await Util_Promise$ReventlessCore.toUnit(Util_Promise$ReventlessCore.mapOk(promise, arr => Promise.all(arr.map(param => publishAggregateCommand(param[0], param[1])))));
+          tmp = publish(action._0);
+          break;
+        case "AbstractPublishPluginExtensionPointCommand" :
+          tmp = publishPluginExtensionPointCommand(action._0);
+          break;
+        case "AbstractPublishExtensionPointCommand" :
+          tmp = forwardCommand(action._0, action._1);
+          break;
+        case "AbstractHandleDirective" :
+          tmp = handleDirective(action._0);
+          break;
+      }
+      return await tmp;
+    };
+    let applyOutgoingCommandAction = async action => {
+      switch (action.TAG) {
+        case "AbstractPublishPluginExtensionPointCommand" :
+          return publishPluginExtensionPointCommand(action._0);
+        case "AbstractPublishExtensionPointCommand" :
+          return forwardCommand(action._0, action._1);
+        case "AbstractHandleDirective" :
+          return handleDirective(action._0);
+      }
+    };
+    let incomingJsonEventsHandler = async (eventJson$p, pluginDef) => {
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `incoming EP event: ` + LogFormat$ReventlessCore.eventSummary(eventJson$p)));
+      let event$p;
+      try {
+        event$p = Message$ReventlessCore.decodeEvent$p(eventJson$p, Id$Reventless.StringPure.schema, MappingSpec.eventSchema);
+      } 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(comp, undefined, `Could not decode event': ` + JSON.stringify(eventJson$p) + ` ` + errMsg));
+      }
+      let commandActions = mapIncomingEvent(event$p, pluginDef, Ops.queryEngine);
+      let apply = async commandActions => await Util_Promise$ReventlessCore.toUnit(Promise.all(commandActions.map(applyIncomingCommandAction)));
+      await apply(commandActions);
+      let p = Stdlib_Option.map(Ops.readModelNamesForSourceName[event$p.meta.service], readModelNames => Promise.all(Stdlib_Array.filterMap(readModelNames, readModelName => Stdlib_Option.map(Ops.publishToReadModels[readModelName], enqueueEvent => enqueueEvent(0, event$p.id, JSON.stringify(eventJson$p))))));
+      if (p !== undefined) {
+        await p;
+        return;
+      }
+    };
+    let outgoingJsonEventsHandler = (eventJson$p, pluginDef) => {
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `outgoing delegate event: ` + LogFormat$ReventlessCore.eventSummary(eventJson$p)));
+      let commandActions = mapOutgoingEvent(eventJson$p, pluginDef);
+      return Util_Promise$ReventlessCore.toUnit(Promise.all(commandActions.map(applyOutgoingCommandAction)));
+    };
+    return {
+      incomingJsonEventsHandler: incomingJsonEventsHandler,
+      outgoingJsonEventsHandler: outgoingJsonEventsHandler
+    };
+  });
+}
+
+let PluginExtensionPointSpec;
+
+let ExtensionMapping;
+
+export {
+  PluginExtensionPointSpec,
+  ExtensionMapping,
+  Make,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/components/ExtensionPoint/ExtensionPoint.res

@@ -0,0 +1,49 @@
+let componentType = ComponentType.ExtensionPoint
+
+type outputs = ReventlessInfra.ExtensionPoint.outputs
+type t
+type component<'operations> = Component.t<t, outputs, 'operations>
+
+type jsonEventsHandler = (JSON.t, Reventless.Plugin.pluginDefinition) => promise<unit>
+type operations = {outgoingJsonEventsHandler: jsonEventsHandler}
+
+module type T = {
+  type operations = operations
+  type component = component<operations>
+
+  let make: (
+    ~aggregateResources: dict<array<ReventlessInfra.Adapter.resource>>,
+    ~publishToAggregates: dict<CommandTopic.publishJsons>,
+    ~scheduler: Scheduler.operations,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+    ~opts: option<Pulumi.ComponentResource.options>,
+  ) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+}
+
+module type Mappings = {
+  module Spec: ReventlessInfra.ExtensionPointMapping.Spec
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T with module ExtensionPoint := Spec
+  let name: string
+  let moduleUrl: string
+  let mappings: array<module(Mapping)>
+}
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.ExtensionPoint.resolvedOutputs> =>
+  (
+    outputs.commandTopic->Pulumi.Output.flatMap(CommandTopic.toResolvedOutputs),
+    outputs.eventTopic->Pulumi.Output.flatMap(EventTopic.toResolvedOutputs),
+  )
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((commandTopic, eventTopic)) => {
+    let resolved: ReventlessInterop.ExtensionPoint.resolvedOutputs = {
+      name: outputs.name,
+      commandTopic,
+      eventTopic,
+    }
+    resolved
+  })

package/src/components/ExtensionPoint/ExtensionPoint.res.mjs

@@ -0,0 +1,25 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
+import * as CommandTopic$ReventlessCore from "../CommandTopic/CommandTopic.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  return Pulumi.all([
+    Output$Pulumi.flatMap(outputs.commandTopic, CommandTopic$ReventlessCore.toResolvedOutputs),
+    Output$Pulumi.flatMap(outputs.eventTopic, EventTopic$ReventlessCore.toResolvedOutputs)
+  ]).apply(param => ({
+    name: outputs.name,
+    commandTopic: param[0],
+    eventTopic: param[1]
+  }));
+}
+
+let componentType = "ExtensionPoint";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* Output-Pulumi Not a pure module */

package/src/components/ExtensionPoint/ExtensionPoint_Builder.res

@@ -0,0 +1,163 @@
+module Make = (
+  Spec: ReventlessInfra.ExtensionPointMapping.Spec,
+  Mappings: ExtensionPoint.Mappings with module Spec := Spec,
+  RuntimeEnvironment: Runtime.Environment,
+  CommandTopicChannel: CommandTopic_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventTopicAdapter: EventTopic_Adapter.Publisher,
+  ExtensionPointRuntimeBuilder: ExtensionPointRuntime_Builder.T
+    with module CommandTopicChannel := CommandTopicChannel,
+): ExtensionPoint.T => {
+  module Spec = Spec
+
+  type operations = ExtensionPoint.operations
+  type component = ExtensionPoint.component<operations>
+
+  module SpecWithId: Reventless.ExtensionPoint.Spec
+    with type command = Spec.command
+    and type event = Spec.event
+    and type directive = Spec.directive = {
+    include Spec
+    module Id = Reventless.Id.String
+  }
+
+  let filterAggregateResources = (aggregateResources, aggregateNames) =>
+    aggregateResources
+    ->Dict.toArray
+    ->Array.filter(((name, _)) =>
+      aggregateNames->Array.some(aggregateName => aggregateName == name)
+    )
+    ->Array.map(((_, resources)) => resources)
+    ->Array.flat
+
+  let construct = (
+    ~aggregateResources,
+    ~publishToAggregates,
+    ~scheduler: Scheduler.operations,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+    self,
+    name,
+  ) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let childName = name->String.replace(".", "")->ComponentType.name(ExtensionPoint.componentType)
+
+    module SpecificCommandTopic = CommandTopic_Builder.Make(SpecWithId, CommandTopicChannel)
+    let commandTopic = SpecificCommandTopic.make(~name=childName, ~opts)
+
+    let aggregateNames =
+      Mappings.mappings->Array.filterMap((module(Mapping)) =>
+        Mapping.mapOutgoingEvent->Option.map(_ => Mapping.delegateName)
+      )
+
+    let commandTopicResources =
+      (commandTopic->CommandTopic_Adapter.channel).resources->Adapter.resourcesToResolvedOutput
+
+    let (commandTopic, eventTopic, outgoingJsonEventsHandler) =
+      commandTopicResources
+      ->Pulumi.Output.flatMap(commandTopicResources => {
+        module ExtensionPointCallback = ExtensionPoint_Callback.Make(
+          {
+            let publishToAggregates = publishToAggregates
+            let commandTopicResources = commandTopicResources
+            let scheduler = scheduler
+            let queryEngine = queryEngine
+            let resourceNaming = resourceNaming
+          },
+          Spec,
+          Mappings,
+        )
+        let handler = SpecificCommandTopic.makeHandler(
+          ~commandTopic,
+          ~commandsHandler=ExtensionPointCallback.handleIncomingCommands,
+        )
+        let resources = aggregateResources->filterAggregateResources(aggregateNames)
+
+        // Each adapter chooses what string the EP runtime should treat as the
+        // publish address for a target aggregate; by convention we expose the
+        // first command-topic resource's `id`. The in-memory ExtensionPoint
+        // runtime builder ignores this dict, so including every aggregate
+        // (not just mapping targets) and the empty fallback are both harmless.
+        let publishToAggregatesQueueUrls =
+          aggregateResources->Dict.mapValues(resources =>
+            switch resources->Array.get(0) {
+            | Some(r: ReventlessInfra.Adapter.resource) => r.id
+            | None => Pulumi.Output.make("")
+            }
+          )
+
+        commandTopic->ExtensionPointRuntimeBuilder.forCommandTopic(
+          ~handler,
+          ~connect=SpecificCommandTopic.connect(commandTopic, ~resources, ...),
+          ~specModulePath=Spec.moduleUrl,
+          ~mappingsModulePath=Mappings.moduleUrl,
+          ~publishToAggregatesQueueUrls,
+        )
+
+        module SpecificEventTopic = EventTopic_Builder.Make(SpecWithId, EventTopicAdapter)
+        let eventTopic = SpecificEventTopic.make(~name=childName, ~storageResources=[], ~opts)
+
+        eventTopic
+        ->Component.operations
+        ->Pulumi.Output.apply(({publishJson: publishToEventTopic}) => {
+          module Ops = ExtensionPoint_Operations.Make(
+            Spec,
+            Mappings,
+            {
+              let publishToEventTopic = publishToEventTopic
+              let commandTopicResources = commandTopicResources
+              let scheduler = scheduler
+              let queryEngine = queryEngine
+              let resourceNaming = resourceNaming
+            },
+          )
+
+          (commandTopic, eventTopic, Ops.outgoingJsonEventsHandler)
+        })
+      })
+      ->Pulumi.Output.unzip3
+
+    self->Component.setOperations(
+      outgoingJsonEventsHandler->Pulumi.Output.apply(outgoingJsonEventsHandler =>
+        ({outgoingJsonEventsHandler: outgoingJsonEventsHandler}: ExtensionPoint.operations)
+      ),
+    )
+
+    let epOutputs: ExtensionPoint.outputs = {
+      name,
+      aggregateNames,
+      commandTopic: commandTopic->Pulumi.Output.apply(commandTopic =>
+        commandTopic->Component.outputs
+      ),
+      eventTopic: eventTopic->Pulumi.Output.apply(eventTopic => eventTopic->Component.outputs),
+      specModule: Spec.moduleUrl,
+      mappingsModule: Mappings.moduleUrl,
+    }
+    self->Component.setOutputs(epOutputs)
+  }
+
+  let make = (
+    ~aggregateResources,
+    ~publishToAggregates,
+    ~scheduler,
+    ~queryEngine,
+    ~resourceNaming,
+    ~opts,
+  ) =>
+    Component.make(
+      ~componentType=ExtensionPoint.componentType->ComponentType.toString,
+      ~name=Spec.name,
+      ~construct=construct(
+        ~aggregateResources,
+        ~publishToAggregates,
+        ~scheduler,
+        ~queryEngine,
+        ~resourceNaming,
+        ...
+      ),
+      ~opts,
+    )
+
+  let outputs = Component.outputs
+  let operations = Component.operations
+}

package/src/components/ExtensionPoint/ExtensionPoint_Builder.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as ExtensionPoint$ReventlessCore from "./ExtensionPoint.res.mjs";
+import * as EventTopic_Builder$ReventlessCore from "../EventTopic/EventTopic_Builder.res.mjs";
+import * as CommandTopic_Builder$ReventlessCore from "../CommandTopic/CommandTopic_Builder.res.mjs";
+import * as ExtensionPoint_Callback$ReventlessCore from "./ExtensionPoint_Callback.res.mjs";
+import * as ExtensionPoint_Operations$ReventlessCore from "./ExtensionPoint_Operations.res.mjs";
+
+function Make(Spec) {
+  return Mappings => (RuntimeEnvironment => (CommandTopicChannel => (EventTopicAdapter => (ExtensionPointRuntimeBuilder => {
+    let name = Spec.name;
+    let commandSchema = Spec.commandSchema;
+    let eventSchema = Spec.eventSchema;
+    let filterAggregateResources = (aggregateResources, aggregateNames) => Object.entries(aggregateResources).filter(param => {
+      let name = param[0];
+      return aggregateNames.some(aggregateName => aggregateName === name);
+    }).map(param => param[1]).flat();
+    let make = (aggregateResources, publishToAggregates, scheduler, queryEngine, resourceNaming, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(ExtensionPoint$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+      let opts = {
+        parent: opts_parent
+      };
+      let childName = ComponentType$ReventlessCore.name(extra$1.replace(".", ""), ExtensionPoint$ReventlessCore.componentType);
+      let SpecificCommandTopic = CommandTopic_Builder$ReventlessCore.Make({
+        Id: Id$Reventless.$$String,
+        name: name,
+        commandSchema: commandSchema
+      })(CommandTopicChannel);
+      let commandTopic = SpecificCommandTopic.make(childName, opts);
+      let aggregateNames = Stdlib_Array.filterMap(Mappings.mappings, Mapping => Stdlib_Option.map(Mapping.mapOutgoingEvent, param => Mapping.delegateName));
+      let commandTopicResources = Adapter$ReventlessCore.resourcesToResolvedOutput(commandTopic.channel.resources);
+      let match = Output$Pulumi.unzip3(Output$Pulumi.flatMap(commandTopicResources, commandTopicResources => {
+        let ExtensionPointCallback = ExtensionPoint_Callback$ReventlessCore.Make({
+          publishToAggregates: publishToAggregates,
+          commandTopicResources: commandTopicResources,
+          scheduler: scheduler,
+          queryEngine: queryEngine,
+          resourceNaming: resourceNaming
+        })(Spec)({
+          mappings: Mappings.mappings
+        });
+        let handler = SpecificCommandTopic.makeHandler(commandTopic, ExtensionPointCallback.handleIncomingCommands);
+        let resources = filterAggregateResources(aggregateResources, aggregateNames);
+        let publishToAggregatesQueueUrls = Stdlib_Dict.mapValues(aggregateResources, resources => {
+          let r = resources[0];
+          if (r !== undefined) {
+            return r.id;
+          } else {
+            return Pulumi.output("");
+          }
+        });
+        ExtensionPointRuntimeBuilder.forCommandTopic(handler, none => SpecificCommandTopic.connect(none, resources, commandTopic), undefined, undefined, Spec.moduleUrl, Mappings.moduleUrl, publishToAggregatesQueueUrls, commandTopic);
+        let SpecificEventTopic = EventTopic_Builder$ReventlessCore.Make({
+          Id: Id$Reventless.$$String,
+          name: name,
+          eventSchema: eventSchema
+        })(EventTopicAdapter);
+        let eventTopic = SpecificEventTopic.make(childName, [], opts);
+        return Component$ReventlessCore.operations(eventTopic).apply(param => {
+          let Ops = ExtensionPoint_Operations$ReventlessCore.Make(Spec)({
+            mappings: Mappings.mappings
+          })({
+            publishToEventTopic: param.publishJson,
+            commandTopicResources: commandTopicResources,
+            scheduler: scheduler,
+            queryEngine: queryEngine,
+            resourceNaming: resourceNaming
+          });
+          return [
+            commandTopic,
+            eventTopic,
+            Ops.outgoingJsonEventsHandler
+          ];
+        });
+      }));
+      Component$ReventlessCore.setOperations(extra, match[2].apply(outgoingJsonEventsHandler => ({
+        outgoingJsonEventsHandler: outgoingJsonEventsHandler
+      })));
+      let epOutputs_commandTopic = match[0].apply(Component$ReventlessCore.outputs);
+      let epOutputs_eventTopic = match[1].apply(Component$ReventlessCore.outputs);
+      let epOutputs_specModule = Spec.moduleUrl;
+      let epOutputs_mappingsModule = Mappings.moduleUrl;
+      let epOutputs = {
+        name: extra$1,
+        aggregateNames: aggregateNames,
+        commandTopic: epOutputs_commandTopic,
+        eventTopic: epOutputs_eventTopic,
+        specModule: epOutputs_specModule,
+        mappingsModule: epOutputs_mappingsModule
+      };
+      return Component$ReventlessCore.setOutputs(extra, epOutputs);
+    }, opts);
+    return {
+      make: make,
+      outputs: Component$ReventlessCore.outputs,
+      operations: Component$ReventlessCore.operations
+    };
+  }))));
+}
+
+export {
+  Make,
+}
+/* Id-Reventless Not a pure module */

package/src/components/ExtensionPoint/ExtensionPoint_Callback.res

@@ -0,0 +1,110 @@
+module type Mappings = {
+  module Spec: ReventlessInfra.ExtensionPointMapping.Spec
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T with module ExtensionPoint := Spec
+  let mappings: array<module(Mapping)>
+}
+
+module type Spec = {
+  let publishToAggregates: dict<CommandTopic.publishJsons>
+  let commandTopicResources: array<Adapter.resolvedResource>
+  let scheduler: Scheduler.operations
+  let queryEngine: Reventless.QueryEngine.operations
+  let resourceNaming: ReventlessInfra.ResourceNaming.operations
+}
+
+module type T = {
+  module MappingSpec: ReventlessInfra.ExtensionPointMapping.Spec
+  let handleIncomingCommands: CommandTopic.commandsHandler<
+    Message.command'<Reventless.Id.String.t, MappingSpec.command>,
+  >
+}
+
+module Make = (
+  Spec: Spec,
+  MappingSpec: ReventlessInfra.ExtensionPointMapping.Spec,
+  Mappings: Mappings with module Spec := MappingSpec,
+): (T with module MappingSpec = MappingSpec) => {
+  module MappingSpec = MappingSpec
+
+  // Runs all registered Mapping modules against the incoming commands, collecting
+  // the resulting command actions (publish-to-aggregate or async call).
+  let mapIncomingCommands = (topicItems, mappings, scheduler, queryEngine, resourceNaming, queue) =>
+    mappings
+    ->Array.map((module(Mapping: Mappings.Mapping)) =>
+      Mapping.mapIncomingCommands(
+        topicItems,
+        ScheduleOps.create(~scheduler, ~channelResources=queue, ~resourceNaming),
+        ScheduleOps.delete(~scheduler, ~channelResources=queue, ~resourceNaming),
+        queryEngine,
+      )
+    )
+    ->Array.flat
+
+  // Executes a single command action: either publishes a command JSON to the target
+  // aggregate's CommandTopic, or calls an async handler. Errors are logged and returned
+  // as Error(reference) without failing the overall batch.
+  let applyCommandAction = action =>
+    switch action {
+    | ReventlessInfra.ExtensionPointMapping.AbstractPublishCommand(
+        aggregateName,
+        reference,
+        cmdJson,
+      ) =>
+      Effect.trySync(
+        ~catch=err => {
+          let errMsg = Util.Error.messageFromUnknown(err, "unknown")
+          (Error(reference), `ExtensionPoint: Error on publish command: ${errMsg}`)
+        },
+        () => {
+          let result =
+            Spec.publishToAggregates
+            ->Dict.get(aggregateName)
+            ->Option.map((publishJsons: CommandTopic.publishJsons) => publishJsons([cmdJson]))
+            ->Option.mapOr(
+              () =>
+                JsError.throwWithMessage(
+                  `ExtensionPoint.applyCommandAction: Aggregate ${aggregateName} doesn't exist`,
+                ),
+              x => {() => x},
+            )
+          let _ = result()
+          Ok(reference)
+        },
+      )
+      ->Effect.catchAll(((errorResult, errMsg)) =>
+        EffectLogger.logError(~comp="ExtensionPoint", errMsg)->Effect.map(_ => errorResult)
+      )
+    | AbstractHandleDirective(reference, handler) =>
+      Effect.tryPromise(
+        ~catch=err => {
+          let errMsg = Util.Error.messageFromUnknown(err, "unknown")
+          (Error(reference), `ExtensionPoint: Error on handling directive: ${errMsg}`)
+        },
+        () => handler(),
+      )
+      ->Effect.map(_ => Ok(reference))
+      ->Effect.catchAll(((errorResult, errMsg)) =>
+        EffectLogger.logError(~comp="ExtensionPoint", errMsg)->Effect.map(_ => errorResult)
+      )
+    }
+
+  // CommandTopic handler — collects all incoming commands, maps them through the
+  // extension point mappings, then applies each resulting action concurrently.
+  let handleIncomingCommands = stream =>
+    stream
+    ->Stream.runCollect
+    ->Effect.flatMap(topicItems => {
+      let commandActions =
+        topicItems->mapIncomingCommands(
+          Mappings.mappings,
+          Spec.scheduler,
+          Spec.queryEngine,
+          Spec.resourceNaming,
+          Spec.commandTopicResources,
+        )
+      Effect.all(
+        commandActions->Array.map(applyCommandAction),
+        {"concurrency": "unbounded"},
+      )
+    })
+}