@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/EventTopic/EventTopic_Adapter.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/EventTopic/EventTopic_Builder.res

@@ -0,0 +1,53 @@
+module Make = (Spec: ReventlessInfra.EventTopic.T, Publisher: EventTopic_Adapter.Publisher): (
+  EventTopic.T with module Spec = Spec
+) => {
+  module Spec = Spec
+
+  type publish = EventTopic.publish<Spec.Id.t, Spec.event>
+  type operations = {
+    publish: publish,
+    publishJson: EventTopic.publishJson,
+    publishJsonStream: EventTopic.publishJsonStream,
+  }
+
+  type component = Component.t<EventTopic.t, EventTopic.outputs, operations>
+
+  let construct = (~storageResources, self, name) => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let publisher = Publisher.make(
+      ~name=name->ComponentType.name(EventTopic.componentType),
+      ~storageResources,
+      ~opts,
+    )
+
+    self->Component.setOperations(
+      (publisher.publishJson, publisher.publishJsonStream)
+      ->Pulumi.Output.all2
+      ->Pulumi.Output.apply(((publishJson, publishJsonStream)) => {
+        module Operations = EventTopic_Operations.Make(
+          Spec,
+          {
+            let publishJson = publishJson
+          },
+        )
+        {
+          publishJson,
+          publish: Operations.publish,
+          publishJsonStream: publishJsonStream,
+        }
+      }),
+    )
+
+    let outputs: EventTopic.outputs = {resources: publisher.resources}
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (~name, ~storageResources, ~opts=?): component =>
+    Component.make(
+      ~componentType=EventTopic.componentType->ComponentType.toString,
+      ~name,
+      ~construct=construct(~storageResources, ...),
+      ~opts,
+    )
+}

package/src/components/EventTopic/EventTopic_Builder.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as EventTopic$ReventlessCore from "./EventTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventTopic_Operations$ReventlessCore from "./EventTopic_Operations.res.mjs";
+
+function Make(Spec) {
+  return Publisher => {
+    let make = (name, storageResources, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(EventTopic$ReventlessCore.componentType), name, (extra, extra$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+      let opts = {
+        parent: opts_parent
+      };
+      let publisher = Publisher.make(ComponentType$ReventlessCore.name(extra$1, EventTopic$ReventlessCore.componentType), storageResources, opts);
+      Component$ReventlessCore.setOperations(extra, Pulumi.all([
+        publisher.publishJson,
+        publisher.publishJsonStream
+      ]).apply(param => {
+        let publishJson = param[0];
+        let Operations = EventTopic_Operations$ReventlessCore.Make(Spec)({
+          publishJson: publishJson
+        });
+        return {
+          publish: Operations.publish,
+          publishJson: publishJson,
+          publishJsonStream: param[1]
+        };
+      }));
+      let outputs = {
+        resources: publisher.resources
+      };
+      return Component$ReventlessCore.setOutputs(extra, outputs);
+    }, opts);
+    return {
+      Spec: Spec,
+      make: make
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/EventTopic/EventTopic_Operations.res

@@ -0,0 +1,37 @@
+module type Ops = {
+  let publishJson: EventTopic.publishJson
+}
+
+module Make = (Spec: ReventlessInfra.EventTopic.T, Ops: Ops) => {
+  let comp = `EventTopic(${Spec.name})`
+
+  let publish = async events' => {
+    let eventCount = events'->Array.length
+    await events'
+    ->Array.mapWithIndex(async (event', idx) => {
+      let eventJson' = event'->Message.encodeEvent'(Spec.Id.schema, Spec.eventSchema)
+
+      let id = event'.id
+      let idx = idx + 1
+
+      let idxStr = `${idx->Int.toString}/${eventCount->Int.toString}`
+      switch await Ops.publishJson(id->Spec.Id.toString, event'.meta, eventJson') {
+      | exception e =>
+        EffectLogger.logError(
+          ~comp,
+          ~detail=eventJson',
+          `publish failed ${idxStr}: ${LogFormat.eventDetail(eventJson')}`,
+        )->Effect.runSync
+        throw(e)
+      | _ =>
+        EffectLogger.logInfo(
+          ~comp,
+          ~detail=eventJson',
+          `published event ${idxStr}: ${LogFormat.eventDetail(eventJson')}`,
+        )->Effect.runSync
+      }
+    })
+    ->Promise.all
+    ->Util.Promise.toUnit
+  }
+}

package/src/components/EventTopic/EventTopic_Operations.res.mjs

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+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";
+
+function Make(Spec) {
+  return Ops => {
+    let comp = `EventTopic(` + Spec.name + `)`;
+    let publish = async events$p => {
+      let eventCount = events$p.length;
+      return await Util_Promise$ReventlessCore.toUnit(Promise.all(events$p.map(async (event$p, idx) => {
+        let eventJson$p = Message$ReventlessCore.encodeEvent$p(event$p, Spec.Id.schema, Spec.eventSchema);
+        let id = event$p.id;
+        let idx$1 = idx + 1 | 0;
+        let idxStr = idx$1.toString() + `/` + eventCount.toString();
+        let val;
+        try {
+          val = await Ops.publishJson(Spec.Id.toString(id), event$p.meta, eventJson$p);
+        } catch (e) {
+          Effect.runSync(EffectLogger$ReventlessCore.logError(comp, eventJson$p, `publish failed ` + idxStr + `: ` + LogFormat$ReventlessCore.eventDetail(eventJson$p)));
+          throw e;
+        }
+        return Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, eventJson$p, `published event ` + idxStr + `: ` + LogFormat$ReventlessCore.eventDetail(eventJson$p)));
+      })));
+    };
+    return {
+      comp: comp,
+      publish: publish
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/components/Extension/Extension.res

@@ -0,0 +1,32 @@
+let componentType = ComponentType.Extension
+
+type outputs = ReventlessInfra.Extension.outputs
+type t
+
+type jsonEventsHandler = (JSON.t, Reventless.Plugin.pluginDefinition) => promise<unit>
+type operations = {incomingJsonEventsHandler: jsonEventsHandler, outgoingJsonEventsHandler: jsonEventsHandler}
+type component = Component.t<t, outputs, operations>
+
+module type T = {
+  type operations = operations
+  type component = component
+
+  let make: (
+    ~publishToPluginExtensionPoint: CommandTopic.publishJsons,
+    ~publishToAggregates: dict<CommandTopic.publishJsons>,
+    ~readModelNamesForSourceName: dict<array<string>>,
+    ~publishToReadModels: dict<EventCollector.enqueueEvent>,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~opts: option<Pulumi.ComponentResource.options>,
+  ) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+}
+
+module type Mappings = {
+  module Spec: ReventlessInfra.ExtensionMapping.Spec
+  module type Mapping = ReventlessInfra.ExtensionMapping.T with module ExtensionPoint := Spec
+  let name: string
+  let moduleUrl: string
+  let mappings: array<module(Mapping)>
+}

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

@@ -0,0 +1,9 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let componentType = "Extension";
+
+export {
+  componentType,
+}
+/* No side effect */

package/src/components/Extension/Extension_Builder.res

@@ -0,0 +1,82 @@
+module Make = (
+  Spec: ReventlessInfra.ExtensionMapping.Spec,
+  Mappings: Extension.Mappings with module Spec := Spec,
+): Extension.T => {
+  type operations = Extension.operations
+  type component = Extension.component
+
+  let construct = (
+    ~publishToPluginExtensionPoint: CommandTopic.publishJsons,
+    ~publishToAggregates: dict<CommandTopic.publishJsons>,
+    ~readModelNamesForSourceName: dict<array<string>>,
+    ~publishToReadModels: dict<EventCollector.enqueueEvent>,
+    ~queryEngine,
+    self,
+    name,
+  ) => {
+    module Operations = Extension_Operations.Make(
+      Spec,
+      Mappings,
+      {
+        let publishToAggregates = publishToAggregates
+        let publishToPluginExtensionPoint = publishToPluginExtensionPoint
+        let readModelNamesForSourceName = readModelNamesForSourceName
+        let publishToReadModels = publishToReadModels
+        let queryEngine = queryEngine
+      },
+    )
+    let operations: Extension.operations = {
+      incomingJsonEventsHandler: Operations.incomingJsonEventsHandler,
+      outgoingJsonEventsHandler: Operations.outgoingJsonEventsHandler,
+    }
+
+    self->Component.setOperations(operations->Pulumi.Output.make)
+    let extOutputs: Extension.outputs = {
+      name,
+      extensionPointName: Spec.name,
+      // `aggregateNames` lists the Delegate command-topic targets this
+      // extension publishes to — used by PluginRuntime_Builder to compile
+      // the per-extension publishToAggregates dict in HANDLER_CONFIG. An
+      // extension publishes commands from EITHER mapIncomingEvent (incoming
+      // EP event → PublishAggregateCommand / PublishStateChangeSliceCommand)
+      // OR mapOutgoingEvent (outgoing local event → cross-plugin command),
+      // so include Delegate.name whenever a real Delegate exists. Filtering
+      // on mapOutgoingEvent alone leaves incoming-only extensions (like
+      // ordering's Products_Extension that turns ProductBecameAvailable
+      // into SyncCatalogProduct.SyncNewProduct) with `aggregateNames: []`,
+      // which crashes the runtime with "Option.getOrThrow called for None"
+      // at the publishToAggregates lookup.
+      aggregateNames: Mappings.mappings->Array.filterMap((module(Mapping)) =>
+        Mapping.delegateName == ReventlessInfra.ExtensionMapping.NoDelegate.name
+          ? None
+          : Some(Mapping.delegateName)
+      ),
+    }
+    self->Component.setOutputs(extOutputs)
+  }
+
+  let make = (
+    ~publishToPluginExtensionPoint,
+    ~publishToAggregates,
+    ~readModelNamesForSourceName,
+    ~publishToReadModels,
+    ~queryEngine,
+    ~opts,
+  ) =>
+    Component.make(
+      ~componentType=Extension.componentType->ComponentType.toString,
+      ~name=Spec.name ++ ("." ++ Mappings.name),
+      ~construct=construct(
+        ~publishToPluginExtensionPoint,
+        ~publishToAggregates,
+        ~readModelNamesForSourceName,
+        ~publishToReadModels,
+        ~queryEngine,
+        ...
+      ),
+      ~opts,
+    )
+
+  let outputs = Component.outputs
+  let operations = Component.operations
+}

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

@@ -0,0 +1,57 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as Extension$ReventlessCore from "./Extension.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
+import * as Extension_Operations$ReventlessCore from "./Extension_Operations.res.mjs";
+
+function Make(Spec) {
+  return Mappings => {
+    let make = (publishToPluginExtensionPoint, publishToAggregates, readModelNamesForSourceName, publishToReadModels, queryEngine, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Extension$ReventlessCore.componentType), Spec.name + ("." + Mappings.name), (extra, extra$1) => {
+      let Operations = Extension_Operations$ReventlessCore.Make(Spec)({
+        name: Mappings.name,
+        mappings: Mappings.mappings
+      })({
+        publishToAggregates: publishToAggregates,
+        publishToPluginExtensionPoint: publishToPluginExtensionPoint,
+        readModelNamesForSourceName: readModelNamesForSourceName,
+        publishToReadModels: publishToReadModels,
+        queryEngine: queryEngine
+      });
+      let operations_incomingJsonEventsHandler = Operations.incomingJsonEventsHandler;
+      let operations_outgoingJsonEventsHandler = Operations.outgoingJsonEventsHandler;
+      let operations = {
+        incomingJsonEventsHandler: operations_incomingJsonEventsHandler,
+        outgoingJsonEventsHandler: operations_outgoingJsonEventsHandler
+      };
+      Component$ReventlessCore.setOperations(extra, Pulumi.output(operations));
+      let extOutputs_extensionPointName = Spec.name;
+      let extOutputs_aggregateNames = Stdlib_Array.filterMap(Mappings.mappings, Mapping => {
+        if (Mapping.delegateName === ExtensionMapping$ReventlessInfra.NoDelegate.name) {
+          return;
+        } else {
+          return Mapping.delegateName;
+        }
+      });
+      let extOutputs = {
+        name: extra$1,
+        extensionPointName: extOutputs_extensionPointName,
+        aggregateNames: extOutputs_aggregateNames
+      };
+      return Component$ReventlessCore.setOutputs(extra, extOutputs);
+    }, opts);
+    return {
+      make: make,
+      outputs: Component$ReventlessCore.outputs,
+      operations: Component$ReventlessCore.operations
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/Extension/Extension_Operations.res

@@ -0,0 +1,203 @@
+module PluginExtensionPointSpec = ReventlessInfra.PluginExtensionPointSpec
+module ExtensionMapping = ReventlessInfra.ExtensionMapping
+
+module type Mappings = {
+  module Spec: ReventlessInfra.ExtensionMapping.Spec
+  module type Mapping = ExtensionMapping.T with module ExtensionPoint := Spec
+  let name: string
+  let mappings: array<module(Mapping)>
+}
+
+module type Ops = {
+  let publishToAggregates: dict<CommandTopic.publishJsons>
+  let publishToPluginExtensionPoint: CommandTopic.publishJsons
+  let readModelNamesForSourceName: dict<array<string>>
+  let publishToReadModels: dict<EventCollector.enqueueEvent>
+  let queryEngine: Reventless.QueryEngine.operations
+}
+
+module type T = {
+  let incomingJsonEventsHandler: Extension.jsonEventsHandler
+  let outgoingJsonEventsHandler: Extension.jsonEventsHandler
+}
+
+module Make = (
+  MappingSpec: ReventlessInfra.ExtensionMapping.Spec,
+  Mappings: Mappings with module Spec := MappingSpec,
+  Ops: Ops,
+): T => {
+  let comp = `Extension(${MappingSpec.name}.${Mappings.name})`
+
+  let findOutgoingMapping = (delegateNameOpt, mappings) =>
+    delegateNameOpt->Option.flatMap(delegateName =>
+      mappings->Array.find((module(Mapping: Mappings.Mapping)) =>
+        Mapping.delegateName == delegateName
+      )
+    ) // TODO: handle multiple mappings for same Target name
+
+  let mapIncomingEvent = (
+    event': Message.event'<string, MappingSpec.event>,
+    pluginDef,
+    queryEngine,
+  ) =>
+    Mappings.mappings
+    ->Array.map((module(Mapping: Mappings.Mapping)) =>
+      Mapping.mapIncomingEvent(event', pluginDef, queryEngine)
+    )
+    ->Array.flat
+
+  let mapOutgoingEvent = (eventJson', pluginDef) =>
+    switch eventJson'->Message.serviceNameOfMsg->findOutgoingMapping(Mappings.mappings) {
+    | Some(module(Mapping)) =>
+      switch Mapping.mapOutgoingEvent {
+      | Some(mapOutgoingEvent) => mapOutgoingEvent(eventJson', pluginDef)
+      | None =>
+        EffectLogger.logError(
+          ~comp,
+          "mapOutgoingEvent: shouldn't be called, because Plugin EventCollector shouldn't subscribe to EventLog stream not having mapOutgoingEvent() !",
+        )->Effect.runSync
+        []
+      }
+    | None =>
+      JsError.throwWithMessage(
+        "ExtensionPoint.Mapping: Missing mapping for " ++ eventJson'->JSON.stringify,
+      )
+    }
+
+  let publishAggregateCommand = async (aggregateName, cmdJson: Message.commandJson) => {
+    EffectLogger.logInfo(
+      ~comp,
+      `EP→${aggregateName}: ${cmdJson.commandJson->Message.variantNameOfJson->LogFormat.bold}(${cmdJson.id})`,
+    )->Effect.runSync
+    let pub = Ops.publishToAggregates->Dict.get(aggregateName)->Option.getOrThrow
+    try await pub([cmdJson]) catch {
+    | err =>
+      let errMsg = err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      EffectLogger.logError(
+        ~comp,
+        `Error on publish command to aggregate ${aggregateName}: ${errMsg}`,
+      )->Effect.runSync
+    }
+  }
+
+  let publishPluginExtensionPointCommand = async cmdJson =>
+    try await Ops.publishToPluginExtensionPoint([cmdJson]) catch {
+    | err =>
+      let errMsg = err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      EffectLogger.logError(
+        ~comp,
+        `Error on publish command to Plugin ExtensionPoint: ${errMsg}`,
+      )->Effect.runSync
+    }
+
+  let forwardCommand = (extensionPointName, commandJson: Message.commandJson) => {
+    let command: PluginExtensionPointSpec.command = ForwardCommand({
+      extensionPointName,
+      id: commandJson.id,
+      command: commandJson->Message.toMessageBody,
+    })
+    publishPluginExtensionPointCommand({
+      Message.id: "",
+      // ForwardCommand wraps the original command — derive meta so this hop carries
+      // causation (causationId = original command's msgId) and inherits the rest.
+      meta: Message.deriveMeta(~parent=commandJson.meta),
+      commandJson: command->Message.encode(PluginExtensionPointSpec.commandSchema),
+    })
+  }
+
+  let handleDirective = async handler =>
+    try await handler() catch {
+    | err =>
+      let errMsg = err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      EffectLogger.logError(~comp, `Error on handling directive: ${errMsg}`)->Effect.runSync
+    }
+
+  let applyIncomingCommandAction = async action =>
+    await (
+      switch action {
+      | ExtensionMapping.AbstractPublishAggregateCommand(aggregateName, commandJson) =>
+        publishAggregateCommand(aggregateName, commandJson)
+      | AbstractPublishAggregateCommandAsync(promise) => {
+          let (aggregateName, commandJson) = await promise
+          publishAggregateCommand(aggregateName, commandJson)
+        }
+      | AbstractPublishAggregateCommandsAsync(promise) =>
+        let publish = async promise => {
+          await promise
+          ->Util.Promise.mapOk(arr =>
+            arr
+            ->Array.map(((aggregateName, commandJson)) =>
+              publishAggregateCommand(aggregateName, commandJson)
+            )
+            ->Promise.all
+          )
+          ->Util.Promise.toUnit
+        }
+        promise->publish
+      | AbstractPublishPluginExtensionPointCommand(commandJson) =>
+        publishPluginExtensionPointCommand(commandJson)
+      | AbstractPublishExtensionPointCommand(extensionPointName, commandJson) =>
+        forwardCommand(extensionPointName, commandJson)
+      | AbstractHandleDirective(handler) => handler->handleDirective
+      }
+    )
+
+  let applyOutgoingCommandAction = async action =>
+    switch action {
+    | ExtensionMapping.AbstractPublishPluginExtensionPointCommand(commandJson) =>
+      publishPluginExtensionPointCommand(commandJson)
+    | AbstractPublishExtensionPointCommand(extensionPointName, commandJson) =>
+      forwardCommand(extensionPointName, commandJson)
+    | AbstractHandleDirective(handler) => handler->handleDirective
+    }
+
+  let incomingJsonEventsHandler = async (eventJson', pluginDef) => {
+    EffectLogger.logInfo(~comp=comp, `incoming EP event: ${LogFormat.eventSummary(eventJson')}`)->Effect.runSync
+    switch eventJson'->Message.decodeEvent'(
+      Reventless.Id.StringPure.schema,
+      MappingSpec.eventSchema,
+    ) {
+    | event' =>
+      let commandActions = mapIncomingEvent(event', pluginDef, Ops.queryEngine)
+      let apply = async commandActions => {
+        await commandActions
+        ->Array.map(applyIncomingCommandAction)
+        ->Promise.all
+        ->Util.Promise.toUnit
+      }
+      await commandActions->apply
+
+      switch Ops.readModelNamesForSourceName
+      ->Dict.get(event'.meta.service)
+      ->Option.map(readModelNames =>
+        readModelNames
+        ->Array.filterMap(readModelName =>
+          Ops.publishToReadModels
+          ->Dict.get(readModelName)
+          ->Option.map(enqueueEvent => enqueueEvent(0, event'.id, eventJson'->JSON.stringify))
+        ) // FIXME Error handling
+        ->Promise.all
+      ) {
+      | Some(p) =>
+        let _ = await p
+      | None => ()
+      }
+
+    | exception err =>
+      let errMsg = err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      EffectLogger.logError(
+        ~comp,
+        `Could not decode event': ${eventJson'->JSON.stringify} ${errMsg}`,
+      )->Effect.runSync
+    }
+  }
+
+  let outgoingJsonEventsHandler = (eventJson', pluginDef) => {
+    EffectLogger.logInfo(~comp=comp, `outgoing delegate event: ${LogFormat.eventSummary(eventJson')}`)->Effect.runSync
+    let commandActions = mapOutgoingEvent(eventJson', pluginDef)
+    commandActions
+    ->Array.map(applyOutgoingCommandAction)
+    ->Promise.all
+    ->Util.Promise.toUnit
+  }
+}