@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/ReadModel/ReadModel.res

@@ -0,0 +1,42 @@
+let componentType = ComponentType.ReadModel
+
+type t
+type outputs = ReventlessInfra.ReadModel.outputs
+type operations = ReventlessInfra.ReadModel.operations
+type component = Component.t<t, outputs, operations>
+
+module type T = {
+  module Spec: Reventless.ReadModel.Spec
+  module EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+
+  type api
+  type role
+  type component = Component.t<t, outputs, operations>
+  let make: (
+    ~api: api,
+    ~apiRole: role,
+    ~allEventTopics: EventTopic.allOutputs,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+  let sourceNames: array<string>
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+  let finish: unit => unit
+}
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.ReadModel.resolvedOutputs> =>
+  outputs.queryDb.resources
+  ->Adapter.resourcesToInterop
+  ->Pulumi.Output.apply(queryDbResources => {
+    let resolved: ReventlessInterop.ReadModel.resolvedOutputs = {
+      name: outputs.name,
+      queryDb: {resources: queryDbResources},
+      sourceNames: outputs.sourceNames,
+    }
+    resolved
+  })
+
+let allQueryDbs = allReadModels =>
+  Dict.mapValues(allReadModels, (readModel: outputs) => readModel.queryDb)

package/src/components/ReadModel/ReadModel.res.mjs

@@ -0,0 +1,27 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  return Adapter$ReventlessCore.resourcesToInterop(outputs.queryDb.resources).apply(queryDbResources => ({
+    name: outputs.name,
+    queryDb: {
+      resources: queryDbResources
+    },
+    sourceNames: outputs.sourceNames
+  }));
+}
+
+function allQueryDbs(allReadModels) {
+  return Stdlib_Dict.mapValues(allReadModels, readModel => readModel.queryDb);
+}
+
+let componentType = "ReadModel";
+
+export {
+  componentType,
+  toResolvedOutputs,
+  allQueryDbs,
+}
+/* Adapter-ReventlessCore Not a pure module */

package/src/components/ReadModel/ReadModel_Builder.res

@@ -0,0 +1,155 @@
+module Make = (
+  Spec: Reventless.ReadModel.Spec,
+  Mappings: Reventless.Projection.Mappings with module Target := Spec,
+  RuntimeEnvironment: Runtime.Environment,
+  QueryDbStorage: QueryDb_Adapter.Storage,
+  QueryDbResolvers: QueryDb_Adapter.Resolvers
+    with type api = QueryDbStorage.api
+    and type role = QueryDbStorage.role,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+    with module EventCollectorChannel = EventCollectorChannel,
+): (
+  ReadModel.T
+    with module Spec = Spec
+    and type api = QueryDbStorage.api
+    and type role = QueryDbStorage.role
+) => {
+  module Spec = Spec
+  module EventCollectorRuntimeBuilder = EventCollectorRuntimeBuilder
+
+  let sourceNames =
+    Mappings.mappings
+    ->Array.map((module(Mapping: Mappings.Mapping)) => Mapping.sourceName)
+    ->Belt.Set.String.fromArray
+    ->Belt.Set.String.toArray
+
+  type api = QueryDbStorage.api
+  type role = QueryDbStorage.role
+  type component = ReadModel.component
+  type projectionOperations = QueryDb.operations<string, Spec.state> // TODO: should we really use this "mixed" type?
+
+  let construct = (
+    ~api: QueryDbStorage.api,
+    ~apiRole: QueryDbStorage.role,
+    ~allEventTopics,
+    self,
+    name,
+  ) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let name = name->ComponentType.name(ReadModel.componentType)
+
+    module SpecificQueryDb = QueryDb_Builder.Make(Spec, QueryDbStorage, QueryDbResolvers)
+    let queryDb = SpecificQueryDb.make(~api, ~apiRole, ~opts)
+
+    let toProjectionOperations: SpecificQueryDb.operations => projectionOperations = ({
+      load,
+      loadStream,
+      save,
+      saveBatch,
+      count,
+      delete,
+      deleteBatch,
+    }) => {
+      load: id => load(id->Spec.Id.makeFromString),
+      loadStream: id => loadStream(id->Spec.Id.makeFromString),
+      save: (id, state, saveMode, ttl) => save(id->Spec.Id.makeFromString, state, saveMode, ttl),
+      saveBatch: batch =>
+        saveBatch(batch->Array.map(((id, state, ttl)) => (id->Spec.Id.makeFromString, state, ttl))),
+      count: (id, fieldName, inc) => count(id->Spec.Id.makeFromString, fieldName, inc),
+      delete: (id, subId) => delete(id->Spec.Id.makeFromString, subId),
+      deleteBatch: ids =>
+        deleteBatch(ids->Array.map(((id, sort)) => (id->Spec.Id.makeFromString, sort))),
+    }
+
+    let sourceNames =
+      Mappings.mappings
+      ->Array.map((module(Mapping: Mappings.Mapping)) => Mapping.sourceName)
+      ->Belt.Set.String.fromArray
+
+    // Fail-fast: every Mapping.sourceName must resolve to a topic in allEventTopics,
+    // otherwise EventTopic.filter silently drops it and the projection runs on no events.
+    // Catches both Aggregate-name typos and DCB-source-name typos (e.g. "FooDcb" instead
+    // of "FooDcbEventLog"). See Plan 03 / Phase 2.
+    sourceNames
+    ->Belt.Set.String.toArray
+    ->Array.forEach(sourceName =>
+      if !(allEventTopics->Dict.has(sourceName)) {
+        let availableNames =
+          allEventTopics->Dict.keysToArray->Array.toSorted(String.compare)->Array.join(", ")
+        JsError.throwWithMessage(
+          `ReadModel "${Spec.name}" has a Mapping with sourceName "${sourceName}", ` ++
+          `but no EventTopic with that key exists in allEventTopics. ` ++
+          `Available source names: [${availableNames}]. ` ++
+          `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB ` ++
+          `source name (typically "<pluginName>DcbEventLog").`,
+        )
+      }
+    )
+
+    module SpecificEventCollector = EventCollector_Builder.Make(
+      RuntimeEnvironment,
+      EventCollectorChannel,
+    )
+    let eventCollector =
+      queryDb
+      ->Component.operations
+      ->Pulumi.Output.apply(operations => {
+        let eventTopics = allEventTopics->EventTopic.filter(sourceNames)
+        let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+
+        module Callback = ReadModel_Callback.Make(
+          Spec,
+          Mappings,
+          {
+            module ReadModelSpec = Spec
+            let operations = operations->toProjectionOperations
+          },
+        )
+        let handler = SpecificEventCollector.makeHandler(
+          ~eventCollector,
+          ~jsonEventsHandler=Callback.handleJsonEvents,
+        )
+        let resources = (queryDb->Component.outputs).resources
+
+        eventCollector->EventCollectorRuntimeBuilder.forEventCollector(
+          ~handler,
+          ~eventTopics,
+          ~resources,
+        )
+
+        eventCollector
+      })
+
+    self->Component.setOperations(
+      eventCollector
+      ->Pulumi.Output.flatMap(eventCollector => eventCollector->Component.operations)
+      ->Pulumi.Output.apply(({enqueueEvent}) => enqueueEvent),
+    )
+    let rmOutputs: ReadModel.outputs = {
+      name,
+      queryDb: queryDb->Component.outputs,
+      eventCollector: eventCollector->Component.wrappedOutputs,
+      sourceNames: sourceNames->Belt.Set.String.toArray,
+    }
+    self->Component.setOutputs(rmOutputs)
+  }
+
+  let make = (
+    ~api: QueryDbStorage.api,
+    ~apiRole: QueryDbStorage.role,
+    ~allEventTopics,
+    ~opts=?,
+  ): ReadModel.component =>
+    Component.make(
+      ~componentType=ReadModel.componentType->ComponentType.toString,
+      ~name=Spec.name,
+      ~construct=construct(~api, ~apiRole, ~allEventTopics, ...),
+      ~opts,
+    )
+
+  let outputs = Component.outputs
+  let operations = Component.operations
+  let finish = () => EventCollectorRuntimeBuilder.finish()
+}

package/src/components/ReadModel/ReadModel_Builder.res.mjs

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ReadModel$ReventlessCore from "./ReadModel.res.mjs";
+import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "../QueryDb/QueryDb_Builder.res.mjs";
+import * as ReadModel_Callback$ReventlessCore from "./ReadModel_Callback.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventCollector_Builder.res.mjs";
+
+function Make(Spec) {
+  return Mappings => (RuntimeEnvironment => (QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => {
+    let sourceNames = Belt_SetString.toArray(Belt_SetString.fromArray(Mappings.mappings.map(Mapping => Mapping.sourceName)));
+    let make = (api, apiRole, allEventTopics, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(ReadModel$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+      let opts = {
+        parent: opts_parent
+      };
+      let name = ComponentType$ReventlessCore.name(extra$1, ReadModel$ReventlessCore.componentType);
+      let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make(Spec)(QueryDbStorage)(QueryDbResolvers);
+      let queryDb = SpecificQueryDb.make(api, apiRole, undefined, opts);
+      let toProjectionOperations = param => {
+        let deleteBatch = param.deleteBatch;
+        let $$delete = param.delete;
+        let count = param.count;
+        let saveBatch = param.saveBatch;
+        let save = param.save;
+        let loadStream = param.loadStream;
+        let load = param.load;
+        return {
+          load: id => load(Spec.Id.makeFromString(id)),
+          loadStream: id => loadStream(Spec.Id.makeFromString(id)),
+          save: (id, state, saveMode, ttl) => save(Spec.Id.makeFromString(id), state, saveMode, ttl),
+          saveBatch: batch => saveBatch(batch.map(param => [
+            Spec.Id.makeFromString(param[0]),
+            param[1],
+            param[2]
+          ])),
+          count: (id, fieldName, inc) => count(Spec.Id.makeFromString(id), fieldName, inc),
+          delete: (id, subId) => $$delete(Spec.Id.makeFromString(id), subId),
+          deleteBatch: ids => deleteBatch(ids.map(param => [
+            Spec.Id.makeFromString(param[0]),
+            param[1]
+          ]))
+        };
+      };
+      let sourceNames = Belt_SetString.fromArray(Mappings.mappings.map(Mapping => Mapping.sourceName));
+      Belt_SetString.toArray(sourceNames).forEach(sourceName => {
+        if (sourceName in allEventTopics) {
+          return;
+        }
+        let availableNames = Object.keys(allEventTopics).toSorted(Primitive_string.compare).join(", ");
+        Stdlib_JsError.throwWithMessage(`ReadModel "` + Spec.name + `" has a Mapping with sourceName "` + sourceName + `", but no EventTopic with that key exists in allEventTopics. ` + (`Available source names: [` + availableNames + `]. `) + `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB source name (typically "<pluginName>DcbEventLog").`);
+      });
+      let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+      let eventCollector = Component$ReventlessCore.operations(queryDb).apply(operations => {
+        let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, sourceNames);
+        let eventCollector = SpecificEventCollector.make(name, eventTopics, opts);
+        let operations$1 = toProjectionOperations(operations);
+        let Callback = ReadModel_Callback$ReventlessCore.Make(Spec)(Mappings)({
+          ReadModelSpec: Spec,
+          operations: operations$1
+        });
+        let handler = SpecificEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+        let resources = Component$ReventlessCore.outputs(queryDb).resources;
+        EventCollectorRuntimeBuilder.forEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
+        return eventCollector;
+      });
+      Component$ReventlessCore.setOperations(extra, Output$Pulumi.flatMap(eventCollector, Component$ReventlessCore.operations).apply(param => param.enqueueEvent));
+      let rmOutputs_queryDb = Component$ReventlessCore.outputs(queryDb);
+      let rmOutputs_eventCollector = Component$ReventlessCore.wrappedOutputs(eventCollector);
+      let rmOutputs_sourceNames = Belt_SetString.toArray(sourceNames);
+      let rmOutputs = {
+        name: name,
+        queryDb: rmOutputs_queryDb,
+        eventCollector: rmOutputs_eventCollector,
+        sourceNames: rmOutputs_sourceNames
+      };
+      return Component$ReventlessCore.setOutputs(extra, rmOutputs);
+    }, opts);
+    let finish = () => EventCollectorRuntimeBuilder.finish();
+    return {
+      Spec: Spec,
+      EventCollectorRuntimeBuilder: EventCollectorRuntimeBuilder,
+      make: make,
+      sourceNames: sourceNames,
+      outputs: Component$ReventlessCore.outputs,
+      operations: Component$ReventlessCore.operations,
+      finish: finish
+    };
+  })))));
+}
+
+export {
+  Make,
+}
+/* Output-Pulumi Not a pure module */

package/src/components/ReadModel/ReadModel_Callback.res

@@ -0,0 +1,48 @@
+module type Spec = {
+  module ReadModelSpec: Reventless.ReadModel.Spec
+  let operations: QueryDb.operations<string, ReadModelSpec.state>
+}
+
+module Make = (
+  ReadModelSpec: Reventless.ReadModel.Spec,
+  Mappings: Reventless.Projection.Mappings with module Target := ReadModelSpec,
+  Spec: Spec with module ReadModelSpec = ReadModelSpec,
+) => {
+  module EventProjector = ProjectionMapper.Make(ReadModelSpec, Mappings)
+
+  let comp = `ReadModel(${ReadModelSpec.name})`
+
+  let handleJsonEvents: EventCollector.jsonEventsHandler = stream =>
+    stream
+    ->Stream.runCollect
+    ->Effect.flatMap(events => {
+      let total = events->Array.length->Int.toString
+      events
+      ->Array.mapWithIndex((json, idx) => {
+        let context = json->Message.decode(Reventless.Message.contextSchema)
+        let sourceName = context.meta.service
+        let actions = json->EventProjector.map(~sourceName=Some(sourceName))
+        let actionsStr = LogFormat.actionNames(actions)
+        let idxStr = (idx + 1)->Int.toString
+        EffectLogger.logInfo(
+          ~comp,
+          ~detail=json,
+          `handling event ${idxStr}/${total} from ${sourceName}: ${LogFormat.eventDetail(
+              json,
+            )} actions:${actionsStr}`,
+        )->Effect.runSync
+        actions
+      })
+      ->Array.flat
+      ->Array.reduce(Effect.succeed(), (acc, action) =>
+        acc->Effect.flatMap(
+          _ => {
+            let action = Projection.rewriteAction(action, ReadModelSpec.stateSchema)
+            Effect.promise(
+              () => Projection.handleAction(action, Spec.operations, ReadModelSpec.subIdConfig),
+            )->Effect.map(_ => ())
+          },
+        )
+      )
+    })
+}

package/src/components/ReadModel/ReadModel_Callback.res.mjs

@@ -0,0 +1,48 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Effect from "effect/Effect";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as Projection$ReventlessCore from "../../Projection.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as ProjectionMapper$ReventlessCore from "../../ProjectionMapper.res.mjs";
+
+function Make(ReadModelSpec) {
+  return Mappings => (Spec => {
+    let EventProjector = ProjectionMapper$ReventlessCore.Make({
+      Id: ReadModelSpec.Id,
+      name: ReadModelSpec.name,
+      stateSchema: ReadModelSpec.stateSchema,
+      subIdConfig: ReadModelSpec.subIdConfig
+    })(Mappings);
+    let comp = `ReadModel(` + ReadModelSpec.name + `)`;
+    let handleJsonEvents = stream => Effect.flatMap(Stream.runCollect(stream), events => {
+      let total = events.length.toString();
+      return Stdlib_Array.reduce(events.map((json, idx) => {
+        let context = Message$ReventlessCore.decode(json, Message$Reventless.contextSchema);
+        let sourceName = context.meta.service;
+        let actions = EventProjector.map(sourceName, json);
+        let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
+        let idxStr = (idx + 1 | 0).toString();
+        Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, json, `handling event ` + idxStr + `/` + total + ` from ` + sourceName + `: ` + LogFormat$ReventlessCore.eventDetail(json) + ` actions:` + actionsStr));
+        return actions;
+      }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
+        let action$1 = Projection$ReventlessCore.rewriteAction(action, ReadModelSpec.stateSchema);
+        return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
+      }));
+    });
+    return {
+      EventProjector: EventProjector,
+      comp: comp,
+      handleJsonEvents: handleJsonEvents
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/components/Scheduler/Scheduler.res

@@ -0,0 +1,13 @@
+let componentType = ComponentType.Scheduler
+
+type outputs = ReventlessInfra.Scheduler.outputs
+type createSchedule = ReventlessInfra.Scheduler.createSchedule
+type deleteSchedule = ReventlessInfra.Scheduler.deleteSchedule
+type operations = ReventlessInfra.Scheduler.operations
+
+type t
+type component = Component.t<t, outputs, operations>
+
+module type T = {
+  let make: (~opts: Pulumi.ComponentResource.options=?) => component
+}

package/src/components/Scheduler/Scheduler.res.mjs

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

package/src/components/Scheduler/Scheduler_Adapter.res

@@ -0,0 +1,13 @@
+type scheduledPublisher = {
+  resource: ReventlessInfra.Adapter.resource,
+  operations: Pulumi.Output.t<Scheduler.operations>,
+}
+
+type scheduledPublisherMaker = (
+  ~name: string,
+  ~opts: Pulumi.CustomResourceOptions.t,
+) => scheduledPublisher
+
+module type ScheduledPublisher = {
+  let make: scheduledPublisherMaker
+}

package/src/components/Scheduler/Scheduler_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/Scheduler/Scheduler_Builder.res

@@ -0,0 +1,19 @@
+module Make = (ScheduledPublisher: Scheduler_Adapter.ScheduledPublisher): Scheduler.T => {
+  let construct = (self, name): Component.constructed => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let scheduledPublisher = ScheduledPublisher.make(~name, ~opts)
+
+    self->Component.setOperations(scheduledPublisher.operations)
+    let outputs: Scheduler.outputs = {resource: scheduledPublisher.resource}
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (~opts=?): Scheduler.component =>
+    Component.make(
+      ~componentType=Scheduler.componentType->ComponentType.toString,
+      ~name=Scheduler.componentType->ComponentType.toName,
+      ~construct,
+      ~opts,
+    )
+}

package/src/components/Scheduler/Scheduler_Builder.res.mjs

@@ -0,0 +1,29 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as Scheduler$ReventlessCore from "./Scheduler.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+
+function Make(ScheduledPublisher) {
+  let construct = (self, name) => {
+    let opts_parent = Component$ReventlessCore.toPulumiResource(self);
+    let opts = {
+      parent: opts_parent
+    };
+    let scheduledPublisher = ScheduledPublisher.make(name, opts);
+    Component$ReventlessCore.setOperations(self, scheduledPublisher.operations);
+    let outputs = {
+      resource: scheduledPublisher.resource
+    };
+    return Component$ReventlessCore.setOutputs(self, outputs);
+  };
+  let make = opts => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Scheduler$ReventlessCore.componentType), ComponentType$ReventlessCore.toName(Scheduler$ReventlessCore.componentType), construct, opts);
+  return {
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/SideEffectHandler/SideEffectHandler.res

@@ -0,0 +1,30 @@
+module ReventlessEventCollector = EventCollector
+
+let componentType = ComponentType.SideEffectHandler
+
+type t
+type outputs = {name: string, eventCollector: EventCollector.outputs}
+type operations = {
+  enqueueEvent: EventCollector.enqueueEvent,
+  createSchedule: Reventless.Schedule.create,
+  deleteSchedule: Reventless.Schedule.delete,
+}
+type component = Component.t<t, outputs, operations>
+
+type sideEffects = array<module(Reventless.SideEffect.T)>
+
+module type T = {
+  let make: (
+    ~name: string,
+    ~sideEffects: sideEffects,
+    ~allEventTopics: EventTopic.allOutputs,
+    ~allCommandTopics: Pulumi.Output.t<CommandTopic.allOutputs>,
+    ~targets: array<string>=?,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~scheduler: Scheduler.operations,
+    ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+    ~memorySize: int=?,
+    ~timeout: int=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/SideEffectHandler/SideEffectHandler.res.mjs

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

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res

@@ -0,0 +1,117 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  SpecificEventCollector: EventCollector.T,
+  EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+    with type EventCollectorChannel.callbackEvent := SpecificEventCollector.callbackEvent,
+): SideEffectHandler.T => {
+  let construct = (
+    ~sideEffects,
+    ~allEventTopics,
+    ~allCommandTopics,
+    ~targets=?,
+    ~queryEngine,
+    ~scheduler,
+    ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+    ~memorySize,
+    ~timeout,
+    self,
+    name,
+  ) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+
+    let aggregateNames =
+      sideEffects
+      ->Array.map((module(SideEffect: Reventless.SideEffect.T)) => SideEffect.Source.name)
+      ->Belt.Set.String.fromArray
+
+    let eventTopics = allEventTopics->EventTopic.filter(aggregateNames)
+    let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+
+    module Callback = SideEffectHandler_Callback.Make({
+      let sideEffects = sideEffects
+      let queryEngine = queryEngine
+    })
+    let handler = SpecificEventCollector.makeHandler(
+      ~eventCollector,
+      ~jsonEventsHandler=Callback.handleJsonEvents,
+    )
+
+    let _ = allCommandTopics->Pulumi.Output.apply(allCommandTopics => {
+      let commandTopics =
+        targets
+        ->Option.map(targets =>
+          allCommandTopics->CommandTopic.filter(targets->Set.fromArray)->Dict.valuesToArray
+        )
+        ->Option.getOr([])
+      let resources = commandTopics->Array.flatMap(commandTopic => commandTopic.resources)
+
+      eventCollector->EventCollectorRuntimeBuilder.forEventCollector(
+        ~handler,
+        ~eventTopics,
+        ~resources,
+        ~memorySize,
+        ~timeout,
+      )
+    })
+
+    self->Component.setOperations(
+      (
+        eventCollector->Component.operations,
+        (eventCollector->Component.outputs).resources->Adapter.resourcesToResolvedOutput,
+      )
+      ->Pulumi.Output.all2
+      ->Pulumi.Output.apply((({enqueueEvent}, eventCollectorResources)) => {
+        SideEffectHandler.enqueueEvent,
+        createSchedule: ScheduleOps.create(
+          ~scheduler,
+          ~channelResources=eventCollectorResources,
+          ~resourceNaming,
+        ),
+        deleteSchedule: ScheduleOps.delete(
+          ~scheduler,
+          ~channelResources=eventCollectorResources,
+          ~resourceNaming,
+        ),
+      }),
+    )
+
+    self->Component.setOutputs({
+      SideEffectHandler.name,
+      eventCollector: eventCollector->Component.outputs,
+    })
+  }
+
+  let make = (
+    ~name,
+    ~sideEffects,
+    ~allEventTopics,
+    ~allCommandTopics,
+    ~targets=?,
+    ~queryEngine,
+    ~scheduler,
+    ~resourceNaming,
+    ~memorySize=2048,
+    ~timeout=180,
+    ~opts=?,
+  ) => {
+    Component.make(
+      ~componentType=SideEffectHandler.componentType->ComponentType.toString,
+      ~name,
+      ~construct=construct(
+        ~sideEffects,
+        ~allEventTopics,
+        ~allCommandTopics,
+        ~targets?,
+        ~queryEngine,
+        ~scheduler,
+        ~resourceNaming,
+        ~memorySize,
+        ~timeout,
+        ...
+      ),
+      ~opts,
+    )
+  }
+}