@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/EventMapper/EventMapper_Callback.res

@@ -0,0 +1,323 @@
+module type CounterOps = {
+  let publishJsons: CommandTopic.publishJsons
+  let queryEngine: Reventless.QueryEngine.operations
+}
+
+module type CounterHandler = {
+  let commonEventsHandler: array<JSON.t> => promise<(
+    promise<array<Message.commandJson>>,
+    array<Counter.action>,
+  )>
+  let handleCounterEvents: Counter.jsonEventsHandler
+}
+
+module MakeCounterHandler = (
+  Target: Reventless.EventMapping.Target,
+  Mappings: EventMapper.Mappings with module Target := Target,
+  Ops: CounterOps,
+): CounterHandler => {
+  let target = Target.name
+
+  // Pair each mapping with the variant TAGs it declares via Source.eventSchema.
+  // Used to pre-filter incoming envelopes by TAG before attempting decode —
+  // sibling variants on the same source aggregate that this mapping does not
+  // declare are silently skipped instead of producing decode-failure noise.
+  let mappingsWithTags = Mappings.mappings->Array.map((module(M: Mappings.Mapping)) => (
+    module(M: Mappings.Mapping),
+    Reventless.DcbTag.extractAllVariantNames(M.Source.eventSchema),
+  ))
+
+  // Looks up the event mapping for a given event JSON by matching the source service name
+  // from the event's meta against the registered Mapping modules.
+  let findMapping = (mappingsWithTags, eventJson') => {
+    eventJson'
+    ->JSON.Decode.object
+    ->Option.flatMap(eventObj' => {
+      switch eventObj'
+      ->Dict.get("meta")
+      ->Option.map(metaJson => metaJson->Message.decode(Message.metaSchema)) {
+      | Some(eventMeta) =>
+        let source = eventMeta.service
+        let entry =
+          mappingsWithTags->Array.find(((module(Mapping: Mappings.Mapping), _)) =>
+            Mapping.Source.name == source
+          )
+        switch entry {
+        | None =>
+          EffectLogger.logInfo(~comp="EventMapper", `map: No mapping ${source} -> ${target} found`)->Effect.runSync
+          None
+        | Some((mapping, acceptedTags)) =>
+          module Mapping = unpack(mapping)
+          let source = Mapping.Source.name
+          EffectLogger.logInfo(~comp="EventMapper", `map: found mapping ${source} -> ${target}`)->Effect.runSync
+          Some((eventObj', eventMeta, mapping, acceptedTags))
+        }
+      | None =>
+        EffectLogger.logError(
+          ~comp="EventMapper",
+          `findMapping: Invalid JSON object: ${eventJson'->JSON.stringify}`,
+        )->Effect.runSync
+        None
+      | exception err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp="EventMapper",
+          `findMapping: Couldn't decode meta: ${errMsg}`,
+        )->Effect.runSync
+        None
+      }
+    })
+  }
+
+  type action =
+    | Counter(Counter.action)
+    | Publisher(promise<array<Message.commandJson>>)
+
+  let createCommandJson = (~delay=?, id, meta, command) => {
+    Message.id: id->Target.Id.toString,
+    // Derive a child meta from the source event:
+    // - fresh msgId + time
+    // - causationId = source event's msgId
+    // - service overridden to the target's name (this command is being routed to Target)
+    // - correlationId / ip / user / traceparent / schemaVersion / headers inherited
+    meta: Message.deriveMeta(~parent=meta, ~service=Target.name),
+    commandJson: command->Message.encode(Target.commandSchema),
+    ?delay,
+  }
+
+  // Converts high-level EventMapping actions into concrete Publisher/Counter actions,
+  // stamping each with the event's meta (service name, correlation ID, timestamps).
+  let processMappingActions = (actions, eventMeta) =>
+    actions->Array.map(action =>
+      switch action {
+      | Reventless.EventMapping.Publish(id, command) =>
+        Publisher([createCommandJson(id, eventMeta, command)]->Promise.resolve)
+      | PublishDelayed(id, command, delay) =>
+        Publisher([createCommandJson(~delay, id, eventMeta, command)]->Promise.resolve)
+      | PublishAsync(promise) =>
+        let toCommandJson = async promise =>
+          {await promise}->Array.map(((id, command)) => createCommandJson(id, eventMeta, command))
+        Publisher(promise->toCommandJson)
+      | AddToCounterTarget({counterId, target}) =>
+        Counter(
+          AddToCounterTarget({
+            counterId,
+            target,
+            targetRef: eventMeta.correlationId,
+          }),
+        )
+      | Count(counterId) => Counter(Count({counterId, reference: eventMeta.correlationId, inc: 1}))
+      | CountMulti(counterId, inc) =>
+        Counter(Count({counterId, reference: eventMeta.correlationId, inc}))
+      }
+    )
+
+  // Shared event processing logic used by both Counter and EventCollector handlers.
+  // For each event: finds the mapping, decodes id+event, runs Mapping.map (EventMapping), then splits
+  // the resulting actions into (publisherEntries, counterActions).
+  let commonEventsHandler = async eventsJson' => {
+    let eventsCount = eventsJson'->Array.length
+    let (publisherActions, counterActions) =
+      eventsJson'
+      ->Array.mapWithIndex((eventJson', idx) => {
+        let idx = idx + 1
+        EffectLogger.logInfo(
+          ~comp="EventMapper",
+          `eventsHandler: incoming event ${idx->Int.toString}/${eventsCount->Int.toString}: ${LogFormat.event'JsonToLogMessage(
+              eventJson',
+            )}`,
+        )->Effect.runSync
+        switch findMapping(mappingsWithTags, eventJson') {
+        // TODO: support multiple mappings for the same source
+        | Some((eventObj, eventMeta, mapping, acceptedTags)) =>
+          module Mapping = unpack(mapping)
+          // Pre-filter by TAG: sibling variants from the same source aggregate
+          // that this mapping does not declare are not its concern — skip
+          // silently with no decode attempt. Real decode failures on declared
+          // variants still throw and are logged below.
+          let tag =
+            eventObj
+            ->Dict.get("event")
+            ->Option.map(Message.variantNameOfJson)
+            ->Option.getOr("unknown")
+          if !(acceptedTags->Array.includes(tag)) {
+            None
+          } else {
+            try {
+              let idDecoded =
+                eventObj
+                ->Dict.get("id")
+                ->Option.map(id => id->Message.decode(Mapping.Source.Id.schema))
+              let eventDecoded =
+                eventObj
+                ->Dict.get("event")
+                ->Option.map(event => event->Message.decode(Mapping.Source.eventSchema))
+
+              switch (idDecoded, eventDecoded) {
+              | (Some(eventId), Some(event)) =>
+                Mapping.map(eventId, event, Ops.queryEngine)->processMappingActions(eventMeta)->Some
+              | _ =>
+                EffectLogger.logError(
+                  ~comp="EventMapper",
+                  `map: Invalid event: ${eventJson'->JSON.stringify}`,
+                )->Effect.runSync
+                None
+              }
+            } catch {
+            | err =>
+              let errMsg =
+                err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+              EffectLogger.logError(
+                ~comp="EventMapper",
+                `map: Couldn't decode event: ${eventJson'->JSON.stringify} ${errMsg}`,
+              )->Effect.runSync
+              None
+            }
+          }
+        | None => None
+        }
+      })
+      ->Array.filterMap(entry => entry)
+      ->Array.flat
+      ->Array.partition(resultType =>
+        switch resultType {
+        | Publisher(_) => true
+        | Counter(_) => false
+        }
+      )
+    let publisherEntries =
+      (
+        await publisherActions
+        ->Array.map(action =>
+          switch action {
+          | Publisher(entries) => entries
+          | Counter(_) => JsError.throwWithMessage("Invalid EventMapper action")
+          }
+        )
+        ->Promise.all
+      )
+      ->Array.flat
+      ->Promise.resolve
+    let counterActions = counterActions->Array.map(x =>
+      switch x {
+      | Counter(action) => action
+      | Publisher(_) => JsError.throwWithMessage("Invalid EventMapper action")
+      }
+    )
+    (publisherEntries, counterActions)
+  }
+
+  // Counter stream handler — maps events via commonEventsHandler, rejects counter actions
+  // (counter-to-counter mapping is not allowed), and publishes generated commands.
+  let handleCounterEvents: Counter.jsonEventsHandler = stream =>
+    stream->Stream.runForEach(eventJson' =>
+      Effect.promise(() => commonEventsHandler([eventJson']))
+      ->Effect.tap(((_, countActions)) =>
+        if countActions->Array.length > 0 {
+          EffectLogger.logError(
+            ~comp="EventMapper",
+            "handleCounterEvents: Counter actions are not allowed in Count mapping!",
+          )
+        } else {
+          Effect.succeed()
+        }
+      )
+      ->Effect.flatMap(((publisherEntries, _)) =>
+        Effect.promise(() => publisherEntries)
+        ->Effect.flatMap(entries => Effect.promise(() => Ops.publishJsons(entries)))
+      )
+    )
+}
+
+module type EventCollectorOps = {
+  let publishJsons: CommandTopic.publishJsons
+  let count: Counter.count
+  let addToCounterTarget: Counter.addToCounterTarget
+  let commonEventsHandler: array<JSON.t> => promise<(
+    promise<array<Message.commandJson>>,
+    array<Counter.action>,
+  )>
+}
+
+module type EventCollectorHandler = {
+  let handleJsonEvents: EventCollector.jsonEventsHandler
+}
+
+module MakeEventCollectorHandler = (Ops: EventCollectorOps): EventCollectorHandler => {
+  let countRetrySchedule =
+    Schedule.exponential(Duration.millis(1000))
+    ->Schedule.jittered
+    ->Schedule.intersect(Schedule.recurs(10))
+
+  // Applies counter increments to the QueryDb with retry on failure.
+  let doCount = countItems =>
+    switch countItems->Array.length {
+    | 0 => Effect.succeed()
+    | _ =>
+      Effect.tryPromise(
+        ~catch=e => Util.Error.messageFromUnknown(e, "unknown"),
+        () => Ops.count(countItems),
+      )
+      ->Effect.retry(countRetrySchedule)
+      ->Effect.catchAll(errMsg =>
+        EffectLogger.logError(~comp=__MODULE__, `doCount: count error after retries: ${errMsg}`)
+      )
+    }
+
+  // EventCollector stream handler — maps events via commonEventsHandler, then:
+  //   1. Applies counter increments (with retry)
+  //   2. Registers counter targets
+  //   3. Publishes generated commands to the target aggregate
+  let handleJsonEvents: EventCollector.jsonEventsHandler = stream =>
+    stream->Stream.runForEach(eventJson' =>
+      Effect.promise(() => Ops.commonEventsHandler([eventJson']))
+      ->Effect.flatMap(((publisherEntries, counterActions)) => {
+        let (countActions, addToCounterTargetActions) = counterActions->Array.partition(
+          x =>
+            switch x {
+            | Counter.Count(_) => true
+            | AddToCounterTarget(_) => false
+            },
+        )
+        let countItems = countActions->Array.filterMap(
+          countAction =>
+            switch countAction {
+            | Count(countItem) => Some(countItem)
+            | _ => None
+            },
+        )
+        EffectLogger.logInfo(
+          ~comp="EventMapper",
+          `eventCollectorEventsHandler: countItems: ${countItems
+            ->Array.length
+            ->Int.toString}`,
+        )
+        ->Effect.flatMap(_ => doCount(countItems))
+        ->Effect.flatMap(_ =>
+          EffectLogger.logInfo(
+            ~comp="EventMapper",
+            `eventCollectorEventsHandler: addToCounterTargetActions: ${addToCounterTargetActions
+              ->JSON.stringifyAny
+              ->Option.getOr("[]")}`,
+          )
+        )
+        ->Effect.flatMap(_ =>
+          Effect.all(
+            addToCounterTargetActions->Array.filterMap(x =>
+              switch x {
+              | AddToCounterTarget(counterTarget) =>
+                Some(Effect.promise(() => Ops.addToCounterTarget(counterTarget)))
+              | _ => None
+              }
+            ),
+            {"concurrency": "unbounded"},
+          )->Effect.map(_ => ())
+        )
+        ->Effect.flatMap(_ =>
+          Effect.promise(() => publisherEntries)
+          ->Effect.flatMap(entries => Effect.promise(() => Ops.publishJsons(entries)))
+        )
+      })
+    )
+}

package/src/components/EventMapper/EventMapper_Callback.res.mjs

@@ -0,0 +1,231 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+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 Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+function MakeCounterHandler(Target) {
+  return Mappings => (Ops => {
+    let target = Target.name;
+    let mappingsWithTags = Mappings.mappings.map(M => [
+      M,
+      DcbTag$Reventless.extractAllVariantNames(M.Source.eventSchema)
+    ]);
+    let findMapping = (mappingsWithTags, eventJson$p) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(eventJson$p), eventObj$p => {
+      let eventMeta;
+      try {
+        eventMeta = Stdlib_Option.map(eventObj$p["meta"], metaJson => Message$ReventlessCore.decode(metaJson, Message$ReventlessCore.metaSchema));
+      } 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");
+        Effect$1.runSync(EffectLogger$ReventlessCore.logError("EventMapper", undefined, `findMapping: Couldn't decode meta: ` + errMsg));
+        return;
+      }
+      if (eventMeta !== undefined) {
+        let source = eventMeta.service;
+        let entry = mappingsWithTags.find(param => param[0].Source.name === source);
+        if (entry !== undefined) {
+          let mapping = entry[0];
+          let source$1 = mapping.Source.name;
+          Effect$1.runSync(EffectLogger$ReventlessCore.logInfo("EventMapper", undefined, `map: found mapping ` + source$1 + ` -> ` + target));
+          return [
+            eventObj$p,
+            eventMeta,
+            mapping,
+            entry[1]
+          ];
+        }
+        Effect$1.runSync(EffectLogger$ReventlessCore.logInfo("EventMapper", undefined, `map: No mapping ` + source + ` -> ` + target + ` found`));
+        return;
+      }
+      Effect$1.runSync(EffectLogger$ReventlessCore.logError("EventMapper", undefined, `findMapping: Invalid JSON object: ` + JSON.stringify(eventJson$p)));
+    });
+    let createCommandJson = (delay, id, meta, command) => ({
+      id: Target.Id.toString(id),
+      meta: Message$ReventlessCore.deriveMeta(meta, Target.name),
+      commandJson: Message$ReventlessCore.encode(command, Target.commandSchema),
+      delay: delay
+    });
+    let processMappingActions = (actions, eventMeta) => actions.map(action => {
+      switch (action.TAG) {
+        case "Publish" :
+          return {
+            TAG: "Publisher",
+            _0: Promise.resolve([createCommandJson(undefined, action._0, eventMeta, action._1)])
+          };
+        case "PublishDelayed" :
+          return {
+            TAG: "Publisher",
+            _0: Promise.resolve([createCommandJson(action._2, action._0, eventMeta, action._1)])
+          };
+        case "PublishAsync" :
+          let toCommandJson = async promise => (await promise).map(param => createCommandJson(undefined, param[0], eventMeta, param[1]));
+          return {
+            TAG: "Publisher",
+            _0: toCommandJson(action._0)
+          };
+        case "AddToCounterTarget" :
+          let match = action._0;
+          return {
+            TAG: "Counter",
+            _0: {
+              TAG: "AddToCounterTarget",
+              _0: {
+                counterId: match.counterId,
+                target: match.target,
+                targetRef: eventMeta.correlationId
+              }
+            }
+          };
+        case "Count" :
+          return {
+            TAG: "Counter",
+            _0: {
+              TAG: "Count",
+              _0: {
+                counterId: action._0,
+                reference: eventMeta.correlationId,
+                inc: 1
+              }
+            }
+          };
+        case "CountMulti" :
+          return {
+            TAG: "Counter",
+            _0: {
+              TAG: "Count",
+              _0: {
+                counterId: action._0,
+                reference: eventMeta.correlationId,
+                inc: action._1
+              }
+            }
+          };
+      }
+    });
+    let commonEventsHandler = async eventsJson$p => {
+      let eventsCount = eventsJson$p.length;
+      let match = Stdlib_Array.partition(Stdlib_Array.filterMap(eventsJson$p.map((eventJson$p, idx) => {
+        let idx$1 = idx + 1 | 0;
+        Effect$1.runSync(EffectLogger$ReventlessCore.logInfo("EventMapper", undefined, `eventsHandler: incoming event ` + idx$1.toString() + `/` + eventsCount.toString() + `: ` + LogFormat$ReventlessCore.event$pJsonToLogMessage(eventJson$p)));
+        let match = findMapping(mappingsWithTags, eventJson$p);
+        if (match === undefined) {
+          return;
+        }
+        let mapping = match[2];
+        let eventObj = match[0];
+        let tag = Stdlib_Option.getOr(Stdlib_Option.map(eventObj["event"], Message$ReventlessCore.variantNameOfJson), "unknown");
+        if (!match[3].includes(tag)) {
+          return;
+        }
+        try {
+          let idDecoded = Stdlib_Option.map(eventObj["id"], id => Message$ReventlessCore.decode(id, mapping.Source.Id.schema));
+          let eventDecoded = Stdlib_Option.map(eventObj["event"], event => Message$ReventlessCore.decode(event, mapping.Source.eventSchema));
+          let exit = 0;
+          if (idDecoded !== undefined) {
+            if (eventDecoded !== undefined) {
+              return processMappingActions(mapping.map(Primitive_option.valFromOption(idDecoded), Primitive_option.valFromOption(eventDecoded), Ops.queryEngine), match[1]);
+            }
+            exit = 1;
+          } else {
+            exit = 1;
+          }
+          if (exit === 1) {
+            Effect$1.runSync(EffectLogger$ReventlessCore.logError("EventMapper", undefined, `map: Invalid event: ` + JSON.stringify(eventJson$p)));
+            return;
+          }
+        } 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");
+          Effect$1.runSync(EffectLogger$ReventlessCore.logError("EventMapper", undefined, `map: Couldn't decode event: ` + JSON.stringify(eventJson$p) + ` ` + errMsg));
+          return;
+        }
+      }), entry => entry).flat(), resultType => resultType.TAG !== "Counter");
+      let publisherEntries = Promise.resolve((await Promise.all(match[0].map(action => {
+        if (action.TAG === "Counter") {
+          return Stdlib_JsError.throwWithMessage("Invalid EventMapper action");
+        } else {
+          return action._0;
+        }
+      }))).flat());
+      let counterActions = match[1].map(x => {
+        if (x.TAG === "Counter") {
+          return x._0;
+        } else {
+          return Stdlib_JsError.throwWithMessage("Invalid EventMapper action");
+        }
+      });
+      return [
+        publisherEntries,
+        counterActions
+      ];
+    };
+    let handleCounterEvents = stream => Stream.runForEach(stream, eventJson$p => Effect$1.flatMap(Effect$1.tap(Effect$1.promise(() => commonEventsHandler([eventJson$p])), param => {
+      if (param[1].length !== 0) {
+        return EffectLogger$ReventlessCore.logError("EventMapper", undefined, "handleCounterEvents: Counter actions are not allowed in Count mapping!");
+      } else {
+        return Effect$1.succeed();
+      }
+    }), param => {
+      let publisherEntries = param[0];
+      return Effect$1.flatMap(Effect$1.promise(() => publisherEntries), entries => Effect$1.promise(() => Ops.publishJsons(entries)));
+    }));
+    return {
+      commonEventsHandler: commonEventsHandler,
+      handleCounterEvents: handleCounterEvents
+    };
+  });
+}
+
+function MakeEventCollectorHandler(Ops) {
+  let countRetrySchedule = Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(1000))), Schedule.recurs(10));
+  let handleJsonEvents = stream => Stream.runForEach(stream, eventJson$p => Effect$1.flatMap(Effect$1.promise(() => Ops.commonEventsHandler([eventJson$p])), param => {
+    let publisherEntries = param[0];
+    let match = Stdlib_Array.partition(param[1], x => x.TAG === "Count");
+    let addToCounterTargetActions = match[1];
+    let countItems = Stdlib_Array.filterMap(match[0], countAction => {
+      if (countAction.TAG === "Count") {
+        return countAction._0;
+      }
+    });
+    return Effect$1.flatMap(Effect$1.flatMap(Effect$1.flatMap(Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("EventMapper", undefined, `eventCollectorEventsHandler: countItems: ` + countItems.length.toString()), () => {
+      let match = countItems.length;
+      if (match !== 0) {
+        return Effect$1.catchAll(Effect$1.retry(Effect.tryPromise(e => Util_Error$ReventlessCore.messageFromUnknown(e, "unknown"), () => Ops.count(countItems)), countRetrySchedule), errMsg => EffectLogger$ReventlessCore.logError("EventMapper_Callback-ReventlessCore", undefined, `doCount: count error after retries: ` + errMsg));
+      } else {
+        return Effect$1.succeed();
+      }
+    }), () => EffectLogger$ReventlessCore.logInfo("EventMapper", undefined, `eventCollectorEventsHandler: addToCounterTargetActions: ` + Stdlib_Option.getOr(JSON.stringify(addToCounterTargetActions), "[]"))), () => Effect$1.map(Effect$1.all(Stdlib_Array.filterMap(addToCounterTargetActions, x => {
+      if (x.TAG === "Count") {
+        return;
+      }
+      let counterTarget = x._0;
+      return Primitive_option.some(Effect$1.promise(() => Ops.addToCounterTarget(counterTarget)));
+    }), {
+      concurrency: "unbounded"
+    }), param => {})), () => Effect$1.flatMap(Effect$1.promise(() => publisherEntries), entries => Effect$1.promise(() => Ops.publishJsons(entries))));
+  }));
+  return {
+    handleJsonEvents: handleJsonEvents
+  };
+}
+
+export {
+  MakeCounterHandler,
+  MakeEventCollectorHandler,
+}
+/* Effect Not a pure module */

package/src/components/EventTopic/EventTopic.res

@@ -0,0 +1,69 @@
+let log = Logger.fromEnv()
+
+let componentType = ComponentType.EventTopic
+
+type outputs = ReventlessInfra.EventTopic.outputs
+type allOutputs = ReventlessInfra.EventTopic.allOutputs
+
+type t
+
+type publish<'id, 'event> = array<Message.event'<'id, 'event>> => promise<unit>
+type publishJson = ReventlessInfra.EventTopic.publishJson
+type publishJsonStream = ReventlessInfra.EventTopic.publishJsonStream
+
+exception NotPublishedToPublisher(exn)
+
+module type T = {
+  module Spec: ReventlessInfra.EventTopic.T
+
+  type publish = publish<Spec.Id.t, Spec.event>
+  type operations = {
+    publish: publish,
+    publishJson: publishJson,
+    publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream,
+  }
+  type component = Component.t<t, outputs, operations>
+
+  let make: (
+    ~name: string,
+    ~storageResources: array<ReventlessInfra.Adapter.resource>,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.EventTopic.resolvedOutputs> =>
+  outputs.resources
+  ->Adapter.resourcesToInterop
+  ->Pulumi.Output.apply(resources => {
+    let resolved: ReventlessInterop.EventTopic.resolvedOutputs = {resources: resources}
+    resolved
+  })
+let allOutputsToResources = allOutputs =>
+  allOutputs
+  ->Dict.valuesToArray
+  ->Array.map((eventTopic: outputs) => eventTopic.resources)
+  ->Array.flat
+
+let filter = (allEventTopics: allOutputs, sourceNames) =>
+  sourceNames
+  ->Belt.Set.String.toArray
+  ->Array.filterMap(sourceName =>
+    allEventTopics->Dict.get(sourceName)->Option.map(eventTopic => (sourceName, eventTopic))
+  )
+  ->Dict.fromArray
+
+let log = (eventTopics, description) => {
+  let _ =
+    eventTopics
+    ->Dict.mapValues((eventTopic: outputs) => eventTopic.resources->Array.getUnsafe(0))
+    ->Dict.toArray
+    ->Array.map(((name, {service})) =>
+      service->Pulumi.Output.apply(service => `${name}(${service})`)
+    )
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(topics =>
+      log.info(~comp="EventTopic", `${description}: ${topics->Array.joinUnsafe(", ")}`)
+    )
+}

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

@@ -0,0 +1,50 @@
+// 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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let NotPublishedToPublisher = /* @__PURE__ */Primitive_exceptions.create("EventTopic-ReventlessCore.NotPublishedToPublisher");
+
+function toResolvedOutputs(outputs) {
+  return Adapter$ReventlessCore.resourcesToInterop(outputs.resources).apply(resources => ({
+    resources: resources
+  }));
+}
+
+function allOutputsToResources(allOutputs) {
+  return Object.values(allOutputs).map(eventTopic => eventTopic.resources).flat();
+}
+
+function filter(allEventTopics, sourceNames) {
+  return Object.fromEntries(Stdlib_Array.filterMap(Belt_SetString.toArray(sourceNames), sourceName => Stdlib_Option.map(allEventTopics[sourceName], eventTopic => [
+    sourceName,
+    eventTopic
+  ])));
+}
+
+function log$1(eventTopics, description) {
+  Pulumi.all(Object.entries(Stdlib_Dict.mapValues(eventTopics, eventTopic => eventTopic.resources[0])).map(param => {
+    let name = param[0];
+    return param[1].service.apply(service => name + `(` + service + `)`);
+  })).apply(topics => log.info("EventTopic", undefined, description + `: ` + topics.join(", ")));
+}
+
+let componentType = "EventTopic";
+
+export {
+  componentType,
+  NotPublishedToPublisher,
+  toResolvedOutputs,
+  allOutputsToResources,
+  filter,
+  log$1 as log,
+}
+/* log Not a pure module */

package/src/components/EventTopic/EventTopic_Adapter.res

@@ -0,0 +1,15 @@
+type publisher = {
+  resources: array<ReventlessInfra.Adapter.resource>,
+  publishJson: Pulumi.Output.t<EventTopic.publishJson>,
+  publishJsonStream: Pulumi.Output.t<ReventlessInfra.EventTopic.publishJsonStream>,
+}
+
+type publisherMaker = (
+  ~name: string,
+  ~storageResources: array<ReventlessInfra.Adapter.resource>,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => publisher
+
+module type Publisher = {
+  let make: publisherMaker
+}