@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/AggregateRuntime_Builder_Micro.res.mjs

@@ -0,0 +1,239 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Aggregate$ReventlessCore from "@reventlessdev/reventless-core/src/components/Aggregate/Aggregate.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
+import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let aggregateInfos = {};
+
+function registerAggregate(aggregateName, specModulePath, behaviorModulePath, eventLogTableName, mappingsModulePath) {
+  aggregateInfos[aggregateName] = {
+    specModulePath: specModulePath,
+    behaviorModulePath: behaviorModulePath,
+    eventLogTableName: eventLogTableName,
+    mappingsModulePath: mappingsModulePath
+  };
+}
+
+let storedSpecs = {};
+
+function getStoredSpec(aggregateName, aggregateResource) {
+  return Stdlib_Option.getOr(storedSpecs[aggregateName], {
+    aggregateName: aggregateName,
+    aggregateResource: aggregateResource,
+    queueUrl: Pulumi.output(""),
+    queueArn: Pulumi.output(""),
+    commandTopicConnects: [],
+    commandGeneratorConnects: [],
+    eventCollectorChannelSpec: undefined,
+    commandTopicMemorySize: 0,
+    commandTopicTimeout: 0,
+    commandGeneratorMemorySize: 0,
+    commandGeneratorTimeout: 0,
+    eventCollectorMemorySize: 0,
+    eventCollectorTimeout: 0
+  });
+}
+
+function forCommandGenerator(param, connect, memorySizeOpt, timeoutOpt, commandGenerator) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let resource = Component$ReventlessCore.toPulumiResource(commandGenerator);
+  let aggregateResource = resource.__parentResource;
+  if (aggregateResource === undefined) {
+    return;
+  }
+  let aggregateName = Stdlib_Option.getOr(aggregateResource.__name, "Unnamed");
+  let spec = getStoredSpec(aggregateName, aggregateResource);
+  storedSpecs[aggregateName] = {
+    aggregateName: spec.aggregateName,
+    aggregateResource: spec.aggregateResource,
+    queueUrl: spec.queueUrl,
+    queueArn: spec.queueArn,
+    commandTopicConnects: spec.commandTopicConnects,
+    commandGeneratorConnects: spec.commandGeneratorConnects.concat([connect]),
+    eventCollectorChannelSpec: spec.eventCollectorChannelSpec,
+    commandTopicMemorySize: spec.commandTopicMemorySize,
+    commandTopicTimeout: spec.commandTopicTimeout,
+    commandGeneratorMemorySize: Math.max(spec.commandGeneratorMemorySize, memorySize),
+    commandGeneratorTimeout: Math.max(spec.commandGeneratorTimeout, timeout),
+    eventCollectorMemorySize: spec.eventCollectorMemorySize,
+    eventCollectorTimeout: spec.eventCollectorTimeout
+  };
+}
+
+function forCommandTopic(param, connect, memorySizeOpt, timeoutOpt, commandTopic) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let commandTopicResource = Component$ReventlessCore.toPulumiResource(commandTopic);
+  let aggregateResource = commandTopicResource.__parentResource;
+  if (aggregateResource !== undefined) {
+    let aggregateName = Stdlib_Option.getOr(aggregateResource.__name, "Unnamed");
+    let channel = commandTopic.channel;
+    let channelParts = channel.parts;
+    let queue = channelParts.queue;
+    let spec = getStoredSpec(aggregateName, aggregateResource);
+    storedSpecs[aggregateName] = {
+      aggregateName: spec.aggregateName,
+      aggregateResource: spec.aggregateResource,
+      queueUrl: queue.id,
+      queueArn: queue.arn,
+      commandTopicConnects: spec.commandTopicConnects.concat([connect]),
+      commandGeneratorConnects: spec.commandGeneratorConnects,
+      eventCollectorChannelSpec: spec.eventCollectorChannelSpec,
+      commandTopicMemorySize: Math.max(spec.commandTopicMemorySize, memorySize),
+      commandTopicTimeout: Math.max(spec.commandTopicTimeout, timeout),
+      commandGeneratorMemorySize: spec.commandGeneratorMemorySize,
+      commandGeneratorTimeout: spec.commandGeneratorTimeout,
+      eventCollectorMemorySize: spec.eventCollectorMemorySize,
+      eventCollectorTimeout: spec.eventCollectorTimeout
+    };
+    return;
+  }
+  let name = Stdlib_Option.getOr(commandTopicResource.__name, "Unnamed");
+  Stdlib_JsError.throwWithMessage(`forCommandTopic(micro): commandTopic ` + name + ` has no Aggregate parent`);
+}
+
+function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeoutOpt, eventCollector) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 2048;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 180;
+  let eventCollectorResource = Component$ReventlessCore.toPulumiResource(eventCollector);
+  let channel = eventCollector.channel;
+  let aggregateResource = Stdlib_Option.flatMap(eventCollectorResource.__parentResource, parent => parent.__parentResource);
+  if (aggregateResource !== undefined) {
+    let aggregateName = Stdlib_Option.getOr(aggregateResource.__name, "Unnamed");
+    let spec = getStoredSpec(aggregateName, aggregateResource);
+    storedSpecs[aggregateName] = {
+      aggregateName: spec.aggregateName,
+      aggregateResource: spec.aggregateResource,
+      queueUrl: spec.queueUrl,
+      queueArn: spec.queueArn,
+      commandTopicConnects: spec.commandTopicConnects,
+      commandGeneratorConnects: spec.commandGeneratorConnects,
+      eventCollectorChannelSpec: {
+        channel: channel,
+        eventTopics: eventTopics,
+        resources: resources
+      },
+      commandTopicMemorySize: spec.commandTopicMemorySize,
+      commandTopicTimeout: spec.commandTopicTimeout,
+      commandGeneratorMemorySize: spec.commandGeneratorMemorySize,
+      commandGeneratorTimeout: spec.commandGeneratorTimeout,
+      eventCollectorMemorySize: Math.max(spec.eventCollectorMemorySize, memorySize),
+      eventCollectorTimeout: Math.max(spec.eventCollectorTimeout, timeout)
+    };
+    return;
+  }
+  let name = Stdlib_Option.getOr(eventCollectorResource.__name, "Unnamed");
+  Stdlib_JsError.throwWithMessage(`forEventCollector(micro): eventCollector ` + name + ` has no Aggregate parent`);
+}
+
+let finished = {
+  contents: false
+};
+
+function finish() {
+  if (finished.contents) {
+    return;
+  }
+  let specs = Object.values(storedSpecs);
+  if (specs.length !== 0) {
+    specs.forEach(spec => {
+      let info = aggregateInfos[spec.aggregateName];
+      if (info === undefined) {
+        return log.warn("AggregateRuntime_Builder_Micro", undefined, `no handler registered for ` + spec.aggregateName);
+      }
+      let aggregateOpts_parent = spec.aggregateResource;
+      let aggregateOpts = {
+        parent: aggregateOpts_parent
+      };
+      let baseName = ComponentType$ReventlessCore.name(spec.aggregateName, Aggregate$ReventlessCore.componentType);
+      let packageDirs = {};
+      let specPkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+      let behaviorPkg = Util_Bundle$ReventlessAws.extractPackageName(info.behaviorModulePath);
+      packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+      packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
+      let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+      let behaviorModule = Stdlib_Option.getOr(JSON.stringify(info.behaviorModulePath), `""`);
+      let cmdTopicHandlerConfigOutput = Pulumi.all([
+        info.eventLogTableName,
+        spec.queueUrl,
+        spec.queueArn
+      ]).apply(param => `{"handlers":[{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"}]}`);
+      let cmdTopicEnvVars = {};
+      cmdTopicEnvVars["HANDLER_CONFIG"] = cmdTopicHandlerConfigOutput;
+      let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs", packageDirs, undefined);
+      let cmdTopicName = baseName + "CmdHandler";
+      let cmdTopicRuntime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(cmdTopicName, match.code, match.sourceCodeHash, cmdTopicEnvVars, Math.max(spec.commandTopicMemorySize, 1024), Math.max(spec.commandTopicTimeout, 30), undefined, undefined, undefined, undefined, aggregateOpts);
+      spec.commandTopicConnects.forEach(connect => connect(cmdTopicRuntime));
+      if (spec.commandGeneratorConnects.length !== 0) {
+        let cmdGenHandlerConfigOutput = Pulumi.all([
+          info.eventLogTableName,
+          spec.queueUrl,
+          spec.queueArn
+        ]).apply(param => `{"handlers":[{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"}]}`);
+        let cmdGenEnvVars = {};
+        cmdGenEnvVars["HANDLER_CONFIG"] = cmdGenHandlerConfigOutput;
+        let match$1 = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs", packageDirs, undefined);
+        let cmdGenName = baseName + "CmdGen";
+        let cmdGenRuntime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(cmdGenName, match$1.code, match$1.sourceCodeHash, cmdGenEnvVars, Math.max(spec.commandGeneratorMemorySize, 1024), Math.max(spec.commandGeneratorTimeout, 30), undefined, undefined, undefined, undefined, aggregateOpts);
+        spec.commandGeneratorConnects.forEach(connect => connect(cmdGenRuntime));
+      }
+      let match$2 = spec.eventCollectorChannelSpec;
+      let match$3 = info.mappingsModulePath;
+      if (match$2 === undefined) {
+        return;
+      }
+      if (match$3 === undefined) {
+        return log.warn("AggregateRuntime_Builder_Micro", undefined, `eventCollector registered for ` + spec.aggregateName + ` but no mappingsModulePath — skipping EventMapper Lambda`);
+      }
+      let evtMapperEnvVars = {};
+      let targetSpecModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+      let mappingsModuleJson = Stdlib_Option.getOr(JSON.stringify(match$3), `""`);
+      let handlerConfigJson = spec.queueUrl.apply(queueUrl => `{"targetSpecModule":` + targetSpecModule + `,"mappingsModule":` + mappingsModuleJson + `,"queueUrl":"` + queueUrl + `"}`);
+      evtMapperEnvVars["HANDLER_CONFIG"] = handlerConfigJson;
+      let evtMapperPackageDirs = {};
+      let specPkg$1 = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+      let mappingsPkg = Util_Bundle$ReventlessAws.extractPackageName(match$3);
+      evtMapperPackageDirs[specPkg$1] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg$1);
+      evtMapperPackageDirs[mappingsPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(mappingsPkg);
+      let match$4 = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/EventMapperEntryPoint.mjs", evtMapperPackageDirs, undefined);
+      let evtMapperName = baseName + "EventMapper";
+      let evtMapperRuntime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(evtMapperName, match$4.code, match$4.sourceCodeHash, evtMapperEnvVars, Math.max(spec.eventCollectorMemorySize, 2048), Math.max(spec.eventCollectorTimeout, 180), undefined, undefined, undefined, undefined, aggregateOpts);
+      EventCollectorChannel_DynamoDbStream$ReventlessAws.connect(evtMapperName, [match$2], evtMapperRuntime, aggregateOpts);
+    });
+  }
+  finished.contents = true;
+}
+
+let CommandTopicChannel;
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  CommandTopicChannel,
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  aggregateInfos,
+  registerAggregate,
+  storedSpecs,
+  getStoredSpec,
+  forCommandGenerator,
+  forCommandTopic,
+  forEventCollector,
+  finished,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/AggregateRuntime_Builder_Micro_Async.res

@@ -0,0 +1,331 @@
+// Async variant of AggregateRuntime_Builder_Micro.
+// Uses SQS_Async (FIFO) instead of SQS_Sync — commands return CommandPending immediately.
+// Use via Platform.Aggregate.MakeAsync (or directly in _Aws plugin variants) for
+// high-contention aggregates where the caller cannot wait for synchronous processing.
+module CommandTopicChannel = CommandTopicChannel.SQS_Async
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+type aggregateInfo = {
+  specModulePath: string,
+  behaviorModulePath: string,
+  eventLogTableName: Pulumi.Output.t<string>,
+  mappingsModulePath: option<string>,
+}
+
+let aggregateInfos: dict<aggregateInfo> = Dict.make()
+
+let registerAggregate = (
+  ~aggregateName,
+  ~specModulePath,
+  ~behaviorModulePath,
+  ~eventLogTableName,
+  ~mappingsModulePath=?,
+) =>
+  aggregateInfos->Dict.set(
+    aggregateName,
+    {specModulePath, behaviorModulePath, eventLogTableName, mappingsModulePath},
+  )
+
+type storedSpec = {
+  aggregateName: string,
+  aggregateResource: Pulumi.Resource.t,
+  queueUrl: Pulumi.Output.t<string>,
+  queueArn: Pulumi.Output.t<string>,
+  commandTopicConnects: array<ReventlessCore.Runtime.connect<runtimeParts>>,
+  commandGeneratorConnects: array<ReventlessCore.Runtime.connect<runtimeParts>>,
+  eventCollectorChannelSpec: option<
+    ReventlessCore.EventCollector_Adapter.channelSpec<
+      EventCollectorChannel.callbackEvent,
+      context,
+      EventCollectorChannel.channelParts,
+    >,
+  >,
+  commandTopicMemorySize: int,
+  commandTopicTimeout: int,
+  commandGeneratorMemorySize: int,
+  commandGeneratorTimeout: int,
+  eventCollectorMemorySize: int,
+  eventCollectorTimeout: int,
+}
+
+let storedSpecs: dict<storedSpec> = Dict.make()
+
+let getStoredSpec = (aggregateName, aggregateResource) =>
+  storedSpecs
+  ->Dict.get(aggregateName)
+  ->Option.getOr({
+    aggregateName,
+    aggregateResource,
+    queueUrl: ""->Pulumi.Output.make,
+    queueArn: ""->Pulumi.Output.make,
+    commandTopicConnects: [],
+    commandGeneratorConnects: [],
+    eventCollectorChannelSpec: None,
+    commandTopicMemorySize: 0,
+    commandTopicTimeout: 0,
+    commandGeneratorMemorySize: 0,
+    commandGeneratorTimeout: 0,
+    eventCollectorMemorySize: 0,
+    eventCollectorTimeout: 0,
+  })
+
+let forCommandGenerator: ReventlessCore.Runtime.forComponent<
+  ReventlessCore.CommandGenerator.effectEventHandler<context>,
+  runtimeParts,
+  ReventlessCore.CommandGenerator.component,
+> = (
+  ~handler as _,
+  ~connect,
+  ~memorySize=1024,
+  ~timeout=30,
+  commandGenerator,
+) => {
+  let resource = commandGenerator->ReventlessCore.Component.toPulumiResource
+  switch resource.parent {
+  | Some(aggregateResource) =>
+    let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
+    let spec = getStoredSpec(aggregateName, aggregateResource)
+    storedSpecs->Dict.set(aggregateName, {
+      ...spec,
+      commandGeneratorConnects: spec.commandGeneratorConnects->Array.concat([connect]),
+      commandGeneratorMemorySize: Math.Int.max(spec.commandGeneratorMemorySize, memorySize),
+      commandGeneratorTimeout: Math.Int.max(spec.commandGeneratorTimeout, timeout),
+    })
+  | None => ()
+  }
+}
+
+let forCommandTopic: ReventlessCore.Runtime.forComponent<
+  ReventlessCore.Runtime.effectHandler<
+    CommandTopicChannel.callbackEvent,
+    context,
+    unit,
+    string,
+  >,
+  runtimeParts,
+  ReventlessCore.CommandTopic.component<'op>,
+> = (
+  ~handler as _,
+  ~connect,
+  ~memorySize=1024,
+  ~timeout=30,
+  commandTopic,
+) => {
+  let commandTopicResource = commandTopic->ReventlessCore.Component.toPulumiResource
+  switch commandTopicResource.parent {
+  | Some(aggregateResource) =>
+    let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
+    let channel = commandTopic->ReventlessCore.CommandTopic_Adapter.channel
+    let channelParts: Util.SQS.channelParts = Obj.magic(channel.parts)
+    let queue = channelParts.queue
+
+    let spec = getStoredSpec(aggregateName, aggregateResource)
+    storedSpecs->Dict.set(aggregateName, {
+      ...spec,
+      queueUrl: queue.id,
+      queueArn: queue.arn,
+      commandTopicConnects: spec.commandTopicConnects->Array.concat([connect]),
+      commandTopicMemorySize: Math.Int.max(spec.commandTopicMemorySize, memorySize),
+      commandTopicTimeout: Math.Int.max(spec.commandTopicTimeout, timeout),
+    })
+  | None =>
+    let name = commandTopicResource.name->Option.getOr("Unnamed")
+    JsError.throwWithMessage(
+      `forCommandTopic(micro-async): commandTopic ${name} has no Aggregate parent`,
+    )
+  }
+}
+
+let forEventCollector: ReventlessCore.Runtime.forEventCollector<
+  ReventlessCore.Runtime.effectHandler<
+    EventCollectorChannel.callbackEvent,
+    context,
+    unit,
+    string,
+  >,
+  ReventlessCore.EventCollector.component,
+> = (
+  ~handler as _,
+  ~eventTopics,
+  ~resources,
+  ~memorySize=2048,
+  ~timeout=180,
+  eventCollector,
+) => {
+  let eventCollectorResource = eventCollector->ReventlessCore.Component.toPulumiResource
+  let channel = eventCollector->ReventlessCore.EventCollector_Adapter.channel
+  switch eventCollectorResource.parent->Option.flatMap(parent => parent.parent) {
+  | Some(aggregateResource) =>
+    let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
+    let spec = getStoredSpec(aggregateName, aggregateResource)
+    storedSpecs->Dict.set(aggregateName, {
+      ...spec,
+      eventCollectorChannelSpec: Some({channel, eventTopics, resources}),
+      eventCollectorMemorySize: Math.Int.max(spec.eventCollectorMemorySize, memorySize),
+      eventCollectorTimeout: Math.Int.max(spec.eventCollectorTimeout, timeout),
+    })
+  | None =>
+    let name = eventCollectorResource.name->Option.getOr("Unnamed")
+    JsError.throwWithMessage(
+      `forEventCollector(micro-async): eventCollector ${name} has no Aggregate parent`,
+    )
+  }
+}
+
+let finished = ref(false)
+
+let finish = () =>
+  if !finished.contents {
+    let specs = storedSpecs->Dict.valuesToArray
+    if specs->Array.length > 0 {
+      specs->Array.forEach(spec => {
+        switch aggregateInfos->Dict.get(spec.aggregateName) {
+        | Some(info) =>
+          let aggregateOpts = {
+            Pulumi.ComponentResource.parent: spec.aggregateResource,
+          }
+          let baseName =
+            spec.aggregateName->ReventlessCore.ComponentType.name(
+              ReventlessCore.Aggregate.componentType,
+            )
+
+          let packageDirs: dict<string> = Dict.make()
+          let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+          let behaviorPkg = Util_Bundle.extractPackageName(info.behaviorModulePath)
+          packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+          packageDirs->Dict.set(behaviorPkg, Util_Bundle.resolvePackageRoot(behaviorPkg))
+
+          let specModule =
+            info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+          let behaviorModule =
+            info.behaviorModulePath->JSON.stringifyAny->Option.getOr(`""`)
+
+          // --- CommandTopic Lambda ---
+          let cmdTopicHandlerConfigOutput =
+            Pulumi.Output.all3((info.eventLogTableName, spec.queueUrl, spec.queueArn))
+            ->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
+              `{"handlers":[{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"}]}`
+            )
+
+          let cmdTopicEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
+          cmdTopicEnvVars->Dict.set("HANDLER_CONFIG", cmdTopicHandlerConfigOutput->Pulumi.Output.asInput)
+
+          let {code: cmdTopicCode, sourceCodeHash: cmdTopicSourceCodeHash} = Util_Bundle.buildCodeArchive(
+            ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs",
+            ~packageDirs,
+          )
+
+          let cmdTopicName = baseName ++ "CmdHandler"
+          let cmdTopicRuntime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+            ~name=cmdTopicName,
+            ~code=cmdTopicCode,
+            ~sourceCodeHash=cmdTopicSourceCodeHash,
+            ~envVars=cmdTopicEnvVars,
+            ~memorySize=Math.Int.max(spec.commandTopicMemorySize, 1024),
+            ~timeout=Math.Int.max(spec.commandTopicTimeout, 30),
+            ~opts=aggregateOpts,
+          )
+
+          spec.commandTopicConnects->Array.forEach(connect => connect(~runtime=cmdTopicRuntime))
+
+          // --- CommandGenerator Lambda ---
+          if spec.commandGeneratorConnects->Array.length > 0 {
+            let cmdGenHandlerConfigOutput =
+              Pulumi.Output.all3((info.eventLogTableName, spec.queueUrl, spec.queueArn))
+              ->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
+                `{"handlers":[{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"}]}`
+              )
+
+            let cmdGenEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
+            cmdGenEnvVars->Dict.set("HANDLER_CONFIG", cmdGenHandlerConfigOutput->Pulumi.Output.asInput)
+            cmdGenEnvVars->Dict.set("DISPATCH_MODE", "async"->Pulumi.Input.make)
+
+            let {code: cmdGenCode, sourceCodeHash: cmdGenSourceCodeHash} = Util_Bundle.buildCodeArchive(
+              ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs",
+              ~packageDirs,
+            )
+
+            let cmdGenName = baseName ++ "CmdGen"
+            let cmdGenRuntime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+              ~name=cmdGenName,
+              ~code=cmdGenCode,
+              ~sourceCodeHash=cmdGenSourceCodeHash,
+              ~envVars=cmdGenEnvVars,
+              ~memorySize=Math.Int.max(spec.commandGeneratorMemorySize, 1024),
+              ~timeout=Math.Int.max(spec.commandGeneratorTimeout, 30),
+              ~opts=aggregateOpts,
+            )
+
+            spec.commandGeneratorConnects->Array.forEach(connect =>
+              connect(~runtime=cmdGenRuntime)
+            )
+          }
+
+          // --- EventMapper Lambda ---
+          switch (spec.eventCollectorChannelSpec, info.mappingsModulePath) {
+          | (Some(channelSpec), Some(mappingsModulePath)) =>
+            let evtMapperEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
+
+            let targetSpecModule =
+              info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let mappingsModuleJson =
+              mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
+
+            let handlerConfigJson =
+              spec.queueUrl
+              ->Pulumi.Output.apply(queueUrl =>
+                `{"targetSpecModule":${targetSpecModule},"mappingsModule":${mappingsModuleJson},"queueUrl":"${queueUrl}"}`
+              )
+            evtMapperEnvVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
+
+            let evtMapperPackageDirs: dict<string> = Dict.make()
+            let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+            let mappingsPkg = Util_Bundle.extractPackageName(mappingsModulePath)
+            evtMapperPackageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+            evtMapperPackageDirs->Dict.set(mappingsPkg, Util_Bundle.resolvePackageRoot(mappingsPkg))
+
+            let {code: evtMapperCode, sourceCodeHash: evtMapperSourceCodeHash} = Util_Bundle.buildCodeArchive(
+              ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/EventMapperEntryPoint.mjs",
+              ~packageDirs=evtMapperPackageDirs,
+            )
+
+            let evtMapperName = baseName ++ "EventMapper"
+            let evtMapperRuntime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+              ~name=evtMapperName,
+              ~code=evtMapperCode,
+              ~sourceCodeHash=evtMapperSourceCodeHash,
+              ~envVars=evtMapperEnvVars,
+              ~memorySize=Math.Int.max(spec.eventCollectorMemorySize, 2048),
+              ~timeout=Math.Int.max(spec.eventCollectorTimeout, 180),
+              ~opts=aggregateOpts,
+            )
+
+            let _connectResources = EventCollectorChannel.connect(
+              ~name=evtMapperName,
+              ~channelSpecs=[channelSpec],
+              ~runtime=evtMapperRuntime,
+              ~opts=aggregateOpts,
+            )
+          | (Some(_), None) =>
+            log.warn(
+              ~comp="AggregateRuntime_Builder_Micro_Async",
+              `eventCollector registered for ${spec.aggregateName} but no mappingsModulePath — skipping EventMapper Lambda`,
+            )
+          | _ => ()
+          }
+        | None =>
+          log.warn(
+            ~comp="AggregateRuntime_Builder_Micro_Async",
+            `no handler registered for ${spec.aggregateName}`,
+          )
+        }
+      })
+    }
+    finished := true
+  }