@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/DcbEventLog/DcbEventLog_Adapter.res

@@ -0,0 +1,57 @@
+type rawStoredEvent = {
+  eventType: string,
+  data: JSON.t,
+  tags: array<Reventless.DcbTag.tag>,
+  meta: Reventless.Message.meta,
+}
+
+type rawSequencedEvent = {
+  position: Reventless.DcbTag.sequencePosition,
+  eventType: string,
+  data: JSON.t,
+  tags: array<Reventless.DcbTag.tag>,
+  meta: Reventless.Message.meta,
+  recordedAt: string,
+}
+
+type rawReadResult = {
+  events: array<rawSequencedEvent>,
+  headPosition?: Reventless.DcbTag.sequencePosition,
+}
+
+type operations = {
+  read: (
+    ~query: Reventless.DcbTag.query,
+    ~after: Reventless.DcbTag.sequencePosition=?,
+  ) => promise<rawReadResult>,
+  append: (
+    array<rawStoredEvent>,
+    ~condition: Reventless.DcbTag.appendCondition=?,
+  ) => promise<result<Reventless.DcbTag.sequencePosition, string>>,
+  readStream: (
+    ~query: Reventless.DcbTag.query,
+    ~after: Reventless.DcbTag.sequencePosition=?,
+    ~strongConsistency: bool=?,
+  ) => Stream.t<rawSequencedEvent, string, unit>,
+}
+
+type storage = {
+  resources: array<ReventlessInfra.Adapter.resource>,
+  operations: Pulumi.Output.t<operations>,
+}
+
+type storageMaker = (
+  ~name: string,
+  ~indexes: array<string>,
+  ~partitionTag: Reventless.DcbTag.derivedPartitionTag,
+  /** Tag keys declared `@crossPartition` across the produced event schemas.
+      A single-tag decision read of such a key reads every partition carrying it
+      (per-tag GSI) and its consistency fence is bumped by every carrier. Derived
+      once at build time so read-scope = fence-scope per tag. */
+  ~crossPartitionTagKeys: array<string>=?,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => storage
+
+module type Storage = {
+  let make: storageMaker
+}

package/src/components/DcbEventLog/DcbEventLog_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/DcbEventLog/DcbEventLog_Builder.res

@@ -0,0 +1,72 @@
+module Make = (
+  Storage: DcbEventLog_Adapter.Storage,
+  EventTopicPublisher: EventTopic_Adapter.Publisher,
+): DcbEventLog.T => {
+
+  // DcbEventLog uses a generic JSON event topic (no typed event schema needed)
+  module EventTopicSpec = {
+    module Id = Reventless.Id.String
+    let name = "DcbEventLog"
+    @schema
+    type event = JSON.t
+  }
+
+  type component = ReventlessInfra.DcbEventLog.component
+
+  let construct = (indexes, partitionTag, crossPartitionTagKeys, self, name) => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let storage = Storage.make(
+      ~name=name->ComponentType.name(DcbEventLog.componentType),
+      ~indexes,
+      ~partitionTag,
+      ~crossPartitionTagKeys,
+      ~opts,
+    )
+
+    module SpecificEventTopic = EventTopic_Builder.Make(EventTopicSpec, EventTopicPublisher)
+    let eventTopic = SpecificEventTopic.make(
+      ~name,
+      ~storageResources=storage.resources,
+      ~opts=opts->Util.Pulumi.ComponentResourceOptions.ofCustomResourceOptions,
+    )
+
+    self->Component.setOperations(
+      (storage.operations, eventTopic->Component.operations)
+      ->Pulumi.Output.all2
+      ->Pulumi.Output.apply(((storageOps, eventTopicOps)) => {
+        module Ops = DcbEventLog_Operations.Make({
+          let name = name
+          // Must match the key Plugin_Builder uses to register this DcbEventLog's
+          // EventTopic in `allEventTopics` (`name ++ "DcbEventLog"`), so that
+          // ReadModel `Mapping.sourceName` matches `meta.service` at dispatch.
+          let serviceName = name ++ "DcbEventLog"
+          let storage = storageOps
+          let publishJson = eventTopicOps.publishJson
+        })
+
+        let ops: DcbEventLog.operations = {
+          read: Ops.read,
+          append: Ops.append,
+          readStream: Ops.readStream,
+          appendStream: Ops.appendStream,
+        }
+        ops
+      }),
+    )
+
+    let outputs: DcbEventLog.outputs = {
+      resources: storage.resources,
+      eventTopic: eventTopic->Component.outputs,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (~name, ~indexes=[], ~partitionTag, ~crossPartitionTagKeys=[], ~opts=?): component =>
+    Component.make(
+      ~componentType=DcbEventLog.componentType->ComponentType.toString,
+      ~name,
+      ~construct=construct(indexes, partitionTag, crossPartitionTagKeys, ...),
+      ~opts,
+    )
+}

package/src/components/DcbEventLog/DcbEventLog_Builder.res.mjs

@@ -0,0 +1,67 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as DcbEventLog$ReventlessCore from "./DcbEventLog.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "../../util/Util_Pulumi.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventTopic_Builder$ReventlessCore from "../EventTopic/EventTopic_Builder.res.mjs";
+import * as DcbEventLog_Operations$ReventlessCore from "./DcbEventLog_Operations.res.mjs";
+
+function Make(Storage) {
+  return EventTopicPublisher => {
+    let make = (name, indexesOpt, partitionTag, crossPartitionTagKeysOpt, opts) => {
+      let indexes = indexesOpt !== undefined ? indexesOpt : [];
+      let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+      return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(DcbEventLog$ReventlessCore.componentType), name, (extra, extra$1) => {
+        let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts = {
+          parent: opts_parent
+        };
+        let storage = Storage.make(ComponentType$ReventlessCore.name(extra$1, DcbEventLog$ReventlessCore.componentType), indexes, partitionTag, crossPartitionTagKeys, opts);
+        let SpecificEventTopic = EventTopic_Builder$ReventlessCore.Make({
+          Id: Id$Reventless.$$String,
+          name: "DcbEventLog",
+          eventSchema: S.json
+        })(EventTopicPublisher);
+        let eventTopic = SpecificEventTopic.make(extra$1, storage.resources, Util_Pulumi$ReventlessCore.ComponentResourceOptions.ofCustomResourceOptions(opts));
+        Component$ReventlessCore.setOperations(extra, Pulumi.all([
+          storage.operations,
+          Component$ReventlessCore.operations(eventTopic)
+        ]).apply(param => {
+          let serviceName = extra$1 + "DcbEventLog";
+          let publishJson = param[1].publishJson;
+          let Ops = DcbEventLog_Operations$ReventlessCore.Make({
+            name: extra$1,
+            serviceName: serviceName,
+            storage: param[0],
+            publishJson: publishJson
+          });
+          return {
+            read: Ops.read,
+            append: Ops.append,
+            readStream: Ops.readStream,
+            appendStream: Ops.appendStream
+          };
+        }));
+        let outputs_resources = storage.resources;
+        let outputs_eventTopic = Component$ReventlessCore.outputs(eventTopic);
+        let outputs = {
+          resources: outputs_resources,
+          eventTopic: outputs_eventTopic
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+    };
+    return {
+      make: make
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* S Not a pure module */

package/src/components/DcbEventLog/DcbEventLog_Operations.res

@@ -0,0 +1,160 @@
+module type Ops = {
+  let name: string
+  // The `service` value stamped on every published event's meta — and used as the
+  // first arg to publishJson. Must equal the key under which Plugin_Builder
+  // registers this DcbEventLog's EventTopic in `allEventTopics` so that
+  // `Mapping.sourceName` matches at dispatch time. See Plan 03 / Phase 1.5.
+  let serviceName: string
+  let storage: DcbEventLog_Adapter.operations
+  let publishJson: EventTopic.publishJson
+}
+
+module type T = {
+  let read: DcbEventLog.read
+  let append: DcbEventLog.append
+  let readStream: DcbEventLog.readStream
+  let appendStream: DcbEventLog.appendStream
+}
+
+module Make = (Ops: Ops): T => {
+  let name = Ops.name
+  let serviceName = Ops.serviceName
+
+  let publishToEventTopic = async (rawEvents: array<DcbEventLog.rawEvent>) => {
+    // Meta is now carried per-event by `rawEvent.meta` (set by the slice callback
+    // via `Message.deriveMeta(~parent=command.meta, …)` so causationId / correlationId
+    // propagate correctly). The publish-time `generateMeta(~service=serviceName)` is
+    // gone — each event publishes under its own envelope.
+    //
+    // The publishedEvent hook contract still carries a single `meta` per batch
+    // (its callers expect that shape); we use the first event's meta as the
+    // representative envelope for the batch. Hook authors who need per-event
+    // meta should read it off the eventsJson dicts.
+    let representativeMeta = switch rawEvents->Array.get(0) {
+    | Some(re) => re.meta
+    | None => Message.generateMeta(~service=serviceName)
+    }
+
+    let rawEventsJson = rawEvents->Array.map(rawEvent =>
+      Message.combineMessage(
+        rawEvent.eventType,
+        rawEvent.data->JSON.Decode.object->Option.getOr(Dict.make()),
+      )
+    )
+
+    // Run beforePublish hook — if it throws, log the error and publish original events.
+    let finalRawEventsJson = switch EventPublish_Callback.beforePublishHook.contents {
+    | None => rawEventsJson
+    | Some(hook) =>
+      let published: EventPublish_Callback.publishedEvent = {
+        componentName: name,
+        entityId: name,
+        eventCount: rawEventsJson->Array.length,
+        eventsJson: rawEventsJson,
+        meta: representativeMeta,
+      }
+      try {
+        let result = await hook(published)
+        result.eventsJson
+      } catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`DcbEventLog(${name})`,
+          `beforePublishHook error: ${errMsg}`,
+        )->Effect.runSync
+        rawEventsJson
+      }
+    }
+
+    let _ = await Array.zip(rawEvents, finalRawEventsJson)
+    ->Array.map(async ((rawEvent, eventJson)) => {
+      let entityId =
+        rawEvent.tags->Array.get(0)->Option.map(t => t.value)->Option.getOr(name)
+      let eventJson' = Message.composeEventJson'(entityId, rawEvent.meta, eventJson)
+      try await Ops.publishJson(serviceName, rawEvent.meta, eventJson') catch {
+      | JsExn(err) =>
+        let errMsg = err->JsExn.message->Option.getOr("unknown")
+        EffectLogger.logError(~comp=`DcbEventLog(${name})`, `EventTopic.publish Error: ${errMsg}`)->Effect.runSync
+      }
+    })
+    ->Promise.all
+
+    // Run afterPublish hook — fire-and-forget, errors are caught and logged.
+    switch EventPublish_Callback.afterPublishHook.contents {
+    | None => ()
+    | Some(hook) =>
+      try {
+        let published: EventPublish_Callback.publishedEvent = {
+          componentName: name,
+          entityId: name,
+          eventCount: finalRawEventsJson->Array.length,
+          eventsJson: finalRawEventsJson,
+          meta: representativeMeta,
+        }
+        let _ = await hook(published)
+      } catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`DcbEventLog(${name})`,
+          `afterPublishHook error: ${errMsg}`,
+        )->Effect.runSync
+      }
+    }
+  }
+
+  let append: DcbEventLog.append = async (
+    rawEvents,
+    ~condition=?,
+  ) => {
+    // Normalise `meta.service` to the DcbEventLog's serviceName on every event
+    // before BOTH storage append and SNS publish. EventCollector dispatch (via
+    // Plugin_Callback.handleJsonEvents) keys on `meta.service`, and the catalog
+    // plugin's own EC consumes its own DcbEventLog's DDB stream for outgoing EP
+    // routing — so the stored row's service must match the same identity SNS
+    // consumers see (`<plugin>DcbEventLog`), not the original caller's plugin
+    // name. Causation / correlation / tracing / headers carry through unchanged.
+    let normalisedEvents = rawEvents->Array.map(re => {
+      ...re,
+      meta: {...re.meta, service: serviceName},
+    })
+    // Adapter rawStoredEvent is structurally identical to infra rawEvent
+    let adapterEvents: array<DcbEventLog_Adapter.rawStoredEvent> = normalisedEvents->Obj.magic
+    let result = await Ops.storage.append(adapterEvents, ~condition?)
+    switch result {
+    | Ok(position) =>
+      await publishToEventTopic(normalisedEvents)
+      Ok(position)
+    | Error(_) as err => err
+    }
+  }
+
+  let read: DcbEventLog.read = async (
+    ~query,
+    ~after=?,
+  ) => {
+    let rawResult = await Ops.storage.read(~query, ~after?)
+    // Adapter rawSequencedEvent is structurally identical to infra rawSequencedEvent
+    let events: array<DcbEventLog.rawSequencedEvent> = rawResult.events->Obj.magic
+    let result: DcbEventLog.readResult = {
+      events,
+      headPosition: ?rawResult.headPosition,
+    }
+    result
+  }
+
+  let readStream: DcbEventLog.readStream = (~query, ~after=?, ~strongConsistency=?) =>
+    Ops.storage.readStream(~query, ~after?, ~strongConsistency?)->Stream.map(raw => (raw->Obj.magic: DcbEventLog.rawSequencedEvent))
+
+  // Streaming append — collects the stream into an array, then makes a single
+  // storage.append call to preserve atomicity of the condition check.
+  // Does not publish to EventTopic (use case: migration / bulk seeding).
+  let appendStream: DcbEventLog.appendStream = (stream, ~condition=?) =>
+    stream
+    ->Stream.map(rawEvent => (rawEvent->Obj.magic: DcbEventLog_Adapter.rawStoredEvent))
+    ->Stream.runCollect
+    ->Effect.flatMap(rawEvents => Effect.promise(() => Ops.storage.append(rawEvents, ~condition?)))
+}

package/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs

@@ -0,0 +1,121 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.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 from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as EventPublish_Callback$ReventlessCore from "../EventLog/EventPublish_Callback.res.mjs";
+
+function Make(Ops) {
+  let name = Ops.name;
+  let serviceName = Ops.serviceName;
+  let publishToEventTopic = async rawEvents => {
+    let re = rawEvents[0];
+    let representativeMeta = re !== undefined ? re.meta : Message$ReventlessCore.generateMeta(serviceName, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let rawEventsJson = rawEvents.map(rawEvent => Message$ReventlessCore.combineMessage(rawEvent.eventType, Stdlib_Option.getOr(Stdlib_JSON.Decode.object(rawEvent.data), {})));
+    let hook = EventPublish_Callback$ReventlessCore.beforePublishHook.contents;
+    let finalRawEventsJson;
+    if (hook !== undefined) {
+      let published_eventCount = rawEventsJson.length;
+      let published = {
+        componentName: name,
+        entityId: name,
+        eventCount: published_eventCount,
+        eventsJson: rawEventsJson,
+        meta: representativeMeta
+      };
+      try {
+        finalRawEventsJson = (await hook(published)).eventsJson;
+      } 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.runSync(EffectLogger$ReventlessCore.logError(`DcbEventLog(` + name + `)`, undefined, `beforePublishHook error: ` + errMsg));
+        finalRawEventsJson = rawEventsJson;
+      }
+    } else {
+      finalRawEventsJson = rawEventsJson;
+    }
+    await Promise.all(Stdlib_Array.zip(rawEvents, finalRawEventsJson).map(async param => {
+      let rawEvent = param[0];
+      let entityId = Stdlib_Option.getOr(Stdlib_Option.map(rawEvent.tags[0], t => t.value), name);
+      let eventJson$p = Message$ReventlessCore.composeEventJson$p(entityId, rawEvent.meta, param[1]);
+      try {
+        return await Ops.publishJson(serviceName, rawEvent.meta, eventJson$p);
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        if (err.RE_EXN_ID === "JsExn") {
+          let errMsg = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "unknown");
+          return Effect.runSync(EffectLogger$ReventlessCore.logError(`DcbEventLog(` + name + `)`, undefined, `EventTopic.publish Error: ` + errMsg));
+        }
+        throw err;
+      }
+    }));
+    let hook$1 = EventPublish_Callback$ReventlessCore.afterPublishHook.contents;
+    if (hook$1 === undefined) {
+      return;
+    }
+    try {
+      let published_eventCount$1 = finalRawEventsJson.length;
+      let published$1 = {
+        componentName: name,
+        entityId: name,
+        eventCount: published_eventCount$1,
+        eventsJson: finalRawEventsJson,
+        meta: representativeMeta
+      };
+      await hook$1(published$1);
+      return;
+    } 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(`DcbEventLog(` + name + `)`, undefined, `afterPublishHook error: ` + errMsg$1));
+    }
+  };
+  let append = async (rawEvents, condition) => {
+    let normalisedEvents = rawEvents.map(re => {
+      let newrecord = {...re.meta};
+      return {
+        eventType: re.eventType,
+        data: re.data,
+        tags: re.tags,
+        meta: (newrecord.service = serviceName, newrecord)
+      };
+    });
+    let result = await Ops.storage.append(normalisedEvents, condition);
+    if (result.TAG !== "Ok") {
+      return result;
+    }
+    await publishToEventTopic(normalisedEvents);
+    return {
+      TAG: "Ok",
+      _0: result._0
+    };
+  };
+  let read = async (query, after) => {
+    let rawResult = await Ops.storage.read(query, after);
+    let events = rawResult.events;
+    return {
+      events: events,
+      headPosition: rawResult.headPosition
+    };
+  };
+  let readStream = (query, after, strongConsistency) => Stream$1.map(Ops.storage.readStream(query, after, strongConsistency), raw => raw);
+  let appendStream = (stream, condition) => Effect.flatMap(Stream.runCollect(Stream$1.map(stream, rawEvent => rawEvent)), rawEvents => Effect.promise(() => Ops.storage.append(rawEvents, condition)));
+  return {
+    read: read,
+    append: append,
+    readStream: readStream,
+    appendStream: appendStream
+  };
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/components/EventCollector/EventCollector.res

@@ -0,0 +1,34 @@
+let componentType = ComponentType.EventCollector
+
+type enqueueEvent = ReventlessInfra.EventCollector.enqueueEvent
+
+type t
+type outputs = ReventlessInfra.EventCollector.outputs
+type operations = {enqueueEvent: enqueueEvent}
+type component = Component.t<t, outputs, operations>
+
+/** Stream-based internal handler type. All events in a batch arrive as a single Stream. */
+type jsonEventsHandler = Stream.t<JSON.t, string, unit> => Effect.t<unit, string, unit>
+
+module type T = {
+  type callbackEvent
+  type runtimeParts
+
+  let connect: (
+    ~eventTopics: EventTopic.allOutputs,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    ~runtime: Runtime.environment<runtimeParts>,
+    component,
+  ) => unit
+
+  let makeHandler: (
+    ~eventCollector: component,
+    ~jsonEventsHandler: jsonEventsHandler,
+  ) => Pulumi.Output.t<Runtime.effectHandler<callbackEvent, 'context, unit, string>>
+
+  let make: (
+    ~name: string,
+    ~eventTopics: EventTopic.allOutputs,
+    ~opts: Pulumi.ComponentResource.options,
+  ) => component
+}

package/src/components/EventCollector/EventCollector.res.mjs

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

package/src/components/EventCollector/EventCollector_Adapter.res

@@ -0,0 +1,45 @@
+type channel<'callbackEvent, 'context, 'channelParts> = {
+  parts: 'channelParts,
+  resources: array<ReventlessInfra.Adapter.resource>,
+  enqueueEvent: Pulumi.Output.t<EventCollector.enqueueEvent>,
+  handleChannelEvent: EventCollector.jsonEventsHandler => Pulumi.Output.t<
+    Runtime.effectHandler<'callbackEvent, 'context, unit, string>,
+  >,
+}
+
+type channelSpec<'callbackEvent, 'context, 'channelParts> = {
+  channel: channel<'callbackEvent, 'context, 'channelParts>,
+  eventTopics: EventTopic.allOutputs,
+  resources: array<ReventlessInfra.Adapter.resource>,
+}
+
+type connect<'callbackEvent, 'context, 'channelParts, 'runtimeParts> = (
+  ~name: string,
+  ~channelSpecs: array<channelSpec<'callbackEvent, 'context, 'channelParts>>,
+  ~runtime: Runtime.environment<'runtimeParts>,
+  ~opts: Pulumi.ComponentResource.options,
+) => array<ReventlessInfra.Adapter.resource>
+
+type channelMaker<'callbackEvent, 'context, 'channelParts> = (
+  ~name: string,
+  ~eventTopics: EventTopic.allOutputs,
+  ~opts: Pulumi.ComponentResource.options,
+) => channel<'callbackEvent, 'context, 'channelParts>
+
+@set
+external setChannel: (
+  EventCollector.component,
+  channel<'callbackEvent, 'context, 'channelParts>,
+) => unit = "channel"
+@get
+external channel: EventCollector.component => channel<'callbackEvent, 'context, 'channelParts> =
+  "channel"
+
+module type Channel = {
+  type callbackEvent
+  type channelParts
+  type runtimeParts
+
+  let make: channelMaker<callbackEvent, 'context, channelParts>
+  let connect: connect<callbackEvent, 'context, channelParts, runtimeParts>
+}

package/src/components/EventCollector/EventCollector_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/EventCollector/EventCollector_Builder.res

@@ -0,0 +1,91 @@
+/**
+ * Build a handler from a stream-aware, schema-decoded handler.
+ * Each incoming JSON event is decoded via `schema`; decode errors become Effect failures.
+ * Use this when writing handlers that want to consume a typed `Stream.t<'event>` directly.
+ */
+let makeStreamHandler = (
+  ~eventCollector: EventCollector.component,
+  ~schema: S.t<'event>,
+  ~jsonEventsHandler: Stream.t<'event, string, unit> => Effect.t<unit, string, unit>,
+) => {
+  let jsonHandler: EventCollector.jsonEventsHandler = stream =>
+    stream
+    ->Stream.mapEffect(json =>
+      Effect.trySync(~catch=_exn => "decode error", () => json->S.parseOrThrow(schema))
+    )
+    ->jsonEventsHandler
+
+  let channel: EventCollector_Adapter.channel<_, _, _> = eventCollector->EventCollector_Adapter.channel
+  channel.handleChannelEvent(jsonHandler)
+}
+
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  Channel: EventCollector_Adapter.Channel with type runtimeParts = RuntimeEnvironment.parts,
+): (
+  EventCollector.T
+    with type callbackEvent = Channel.callbackEvent
+    and type runtimeParts = RuntimeEnvironment.parts
+) => {
+  type callbackEvent = Channel.callbackEvent
+  type runtimeParts = RuntimeEnvironment.parts
+
+  let construct = (~eventTopics, self, name) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let name = name->ComponentType.name(EventCollector.componentType)
+
+    let channel = Channel.make(~name, ~eventTopics, ~opts)
+    self->EventCollector_Adapter.setChannel(channel)
+
+    self->Component.setOperations(
+      channel.enqueueEvent->Pulumi.Output.apply(enqueueEvent => {
+        let ops: EventCollector.operations = {enqueueEvent: enqueueEvent}
+        ops
+      }),
+    )
+
+    let outputs: EventCollector.outputs = {
+      name,
+      resources: channel.resources,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let connect = (~eventTopics, ~resources, ~runtime, eventCollector) => {
+    let eventCollectorResource = eventCollector->Component.toPulumiResource
+    let name =
+      eventCollectorResource.name
+      ->Option.getOr("Unnamed")
+      ->ComponentType.name(EventCollector.componentType)
+
+    let _connectResources = Channel.connect(
+      ~name,
+      ~channelSpecs=[
+        {channel: eventCollector->EventCollector_Adapter.channel, eventTopics, resources},
+      ],
+      ~runtime,
+      ~opts={Pulumi.ComponentResource.parent: eventCollectorResource},
+    )
+
+    // let _ = eventCollector->Component.setOutputs({
+    //   EventCollector.name,
+    //   resources: channel.resources->Array.concat(connectResources),
+    // })
+  }
+
+  let makeHandler = (
+    ~eventCollector: EventCollector.component,
+    ~jsonEventsHandler: EventCollector.jsonEventsHandler,
+  ) => {
+    let channel = eventCollector->EventCollector_Adapter.channel
+    channel.handleChannelEvent(jsonEventsHandler)
+  }
+
+  let make = (~name, ~eventTopics, ~opts): EventCollector.component =>
+    Component.make(
+      ~componentType=EventCollector.componentType->ComponentType.toString,
+      ~name,
+      ~construct=construct(~eventTopics, ...),
+      ~opts=Some(opts),
+    )
+}