@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/AggregateEntryPoint.mjs

@@ -0,0 +1,313 @@
+// Aggregate Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports Spec+Behavior modules,
+// wires EventLog_Operations, Aggregate_Callback, CommandTopic_Callback.
+// Handles both SQS CommandTopic events (Route 2) and AppSync direct invocation (Route 1).
+
+import * as Effect from "effect/Effect";
+import { patchSpecId, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { Make as eventLogOperationsMake } from "@reventlessdev/reventless-core/src/components/EventLog/EventLog_Operations.res.mjs";
+import { Make as aggregateCallbackMake } from "@reventlessdev/reventless-core/src/components/Aggregate/Aggregate_Callback.res.mjs";
+import { Make as commandTopicCallbackMake } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Callback.res.mjs";
+import { makeGenerateCommand } from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+import { commandOutcomeToJson, runInlineAndCollect } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import { append, replay, replayStream, appendStream } from "@reventlessdev/reventless-aws/src/adapter/EventLog/EventLogStorage_DynamoDb_Runtime.res.mjs";
+import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import { DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb";
+import { unmarshall } from "@aws-sdk/util-dynamodb";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// ---------------------------------------------------------------------------
+// Plugin status gate — mirrors CommandGeneratorResolvers_GraphQL.checkPluginStatus.
+// Rejects mutations on plugins whose Plugin RM `status` is not `Connected`,
+// returning the split error codes from docs/analysis/plugin-lifecycle-tiers.md:
+//   Disconnected → PluginUnavailable (tier 1, retryable)
+//   Inactive     → PluginInactive    (tier 2, admin-controlled)
+//   Retired      → PluginRetired     (tier 2, admin-archived version)
+// Platform_* admin mutations bypass the gate. Disabled silently if
+// PLUGIN_RM_TABLE_NAME env var is not set.
+// ---------------------------------------------------------------------------
+
+const PLUGIN_RM_TABLE_NAME = process.env["PLUGIN_RM_TABLE_NAME"];
+const PLUGIN_RM_CACHE_TTL_MS = parseInt(process.env["PLUGIN_RM_CACHE_TTL_MS"] || "5000", 10);
+const ddbClient = PLUGIN_RM_TABLE_NAME ? new DynamoDBClient({}) : null;
+
+let pluginStatusCache = null;
+let pluginStatusCacheExpiresAt = 0;
+
+async function loadPluginStatuses() {
+  const now = Date.now();
+  if (pluginStatusCache !== null && now < pluginStatusCacheExpiresAt) {
+    return pluginStatusCache;
+  }
+  const dict = {};
+  let exclusiveStartKey = undefined;
+  do {
+    const res = await ddbClient.send(new ScanCommand({
+      TableName: PLUGIN_RM_TABLE_NAME,
+      Limit: 1000,
+      ExclusiveStartKey: exclusiveStartKey,
+    }));
+    for (const raw of res.Items || []) {
+      try {
+        const item = unmarshall(raw);
+        if (typeof item.name === "string" && typeof item.status === "string") {
+          dict[item.name] = item.status;
+        }
+      } catch (_) {}
+    }
+    exclusiveStartKey = res.LastEvaluatedKey;
+  } while (exclusiveStartKey);
+  pluginStatusCache = dict;
+  pluginStatusCacheExpiresAt = now + PLUGIN_RM_CACHE_TTL_MS;
+  return dict;
+}
+
+function extractFieldName(event) {
+  // AppSync resolver template populates `event.meta.info` with
+  // `${parentTypeName}.${fieldName}` (see AppSync_Resolver_Functions.invokeCommandGenerator).
+  const info = event?.meta?.info;
+  if (typeof info !== "string") return null;
+  const dot = info.indexOf(".");
+  return dot >= 0 ? info.slice(dot + 1) : info;
+}
+
+function pluginRejection(msgId, errorCode, detail) {
+  return {
+    __typename: "CommandRejected",
+    msgId,
+    errorCode,
+    errorDetail: detail,
+  };
+}
+
+async function checkPluginStatus(event) {
+  if (ddbClient === null) return null;
+  const fieldName = extractFieldName(event);
+  if (fieldName === null) return null;
+  const underscore = fieldName.indexOf("_");
+  const pluginPrefix = underscore >= 0 ? fieldName.slice(0, underscore) : fieldName;
+  if (pluginPrefix === "Platform") return null;
+  let statuses;
+  try {
+    statuses = await loadPluginStatuses();
+  } catch (err) {
+    log.warn("checkPluginStatus: failed to load Plugin RM statuses", { comp: "AggregateEntryPoint", detail: err?.message ?? String(err) });
+    return null;
+  }
+  const status = statuses[pluginPrefix];
+  const msgId = "00000000-0000-0000-0000-000000000000";
+  const detailPrefix = `Mutation.${fieldName}`;
+  switch (status) {
+    case undefined:
+    case "Connected":
+      return null;
+    case "Disconnected":
+      return pluginRejection(msgId, "PluginUnavailable", `${detailPrefix}: plugin is disconnected`);
+    case "Inactive":
+      return pluginRejection(msgId, "PluginInactive", `${detailPrefix}: plugin is inactive`);
+    case "Retired":
+      return pluginRejection(msgId, "PluginRetired", `${detailPrefix}: plugin version has been retired`);
+    default:
+      return null;
+  }
+}
+
+// Build the per-aggregate parts shared by Route 1 (AppSync direct invoke) and
+// Route 2 (SQS event source): the in-process command handler (used both as the
+// inline dispatch target and as the SQS message handler) plus the resolved
+// queue ref for the fire-and-forget async path.
+function buildAggregateParts(specModule, behaviorModule, eventLogTableName, queueUrl) {
+  const patchedSpec = patchSpecId(specModule);
+  const resolvedTable = { name: eventLogTableName };
+  const rawStorageOps = {
+    append: append(resolvedTable),
+    replay: replay(resolvedTable),
+    replayStream: replayStream(resolvedTable),
+    appendStream: appendStream(resolvedTable),
+  };
+  const eventLogOps = eventLogOperationsMake(patchedSpec)({
+    Spec: patchedSpec,
+    EventTopic: { Spec: patchedSpec },
+    eventTopic: { publish: async () => {} },
+    storage: rawStorageOps,
+  });
+  const aggregateCallback = aggregateCallbackMake(patchedSpec)(behaviorModule)({
+    Spec: patchedSpec,
+    EventLog: { Spec: patchedSpec },
+    eventLog: eventLogOps,
+  });
+  const commandTopicCallback = commandTopicCallbackMake(patchedSpec)({
+    Spec: patchedSpec,
+    commandsHandler: aggregateCallback.handleCommands,
+  });
+  const resolvedQueue = makeQueueRef(queueUrl);
+  return {
+    patchedSpec,
+    handleJsonCommands: commandTopicCallback.handleJsonCommands,
+    sqsHandler: handleQueueEvent(resolvedQueue, commandTopicCallback.handleJsonCommands),
+    resolvedQueue,
+  };
+}
+
+function buildCommandGeneratorHandler(parts, dispatchMode) {
+  const { patchedSpec, handleJsonCommands, resolvedQueue } = parts;
+  const publishJsons = sqsPublishJsons(resolvedQueue, "SQS_FIFO");
+  // Sync (default): dispatch inline so the AppSync resolver gets a typed
+  // Accepted/Rejected outcome. Async: fire-and-forget to SQS, return Pending —
+  // the SQS event source (Route 2) processes the command later.
+  const publishJsonsAndWait = dispatchMode === "async"
+    ? undefined
+    : (jsons) => runInlineAndCollect(jsons, handleJsonCommands);
+  // Positional args after ReScript compiles labeled params:
+  //   (publishJsons, publishJsonsAndWait, serviceName, commandSchema, componentKind, stripIdFromParams)
+  // The `undefined` for `stripIdFromParams` must be passed explicitly here —
+  // omitting it shifts everything left, sending the schema object through the
+  // serviceName slot (string-concat then throws "Cannot convert object to
+  // primitive value" once the log line tries to print "CommandGenerator(<schema>)").
+  const generateCommand = makeGenerateCommand(publishJsons, publishJsonsAndWait, patchedSpec.name, patchedSpec.commandSchema, "Aggregate", undefined);
+  return (event, _context) => {
+    // Add identity fallback: use payload.identity if present, otherwise construct from meta.user.
+    const identity = (event.identity != null && typeof event.identity === 'object')
+      ? event.identity
+      : {
+          userId: event.meta?.user ?? "anonymous",
+          username: event.meta?.user ?? "anonymous",
+          groups: [],
+          provider: { TAG: "Custom", _0: "aws" },
+        };
+    // CommandGenerator.meta declares ip as array<string> (X-Forwarded-For chain).
+    // The AppSync resolver template sends a single string (or null) from
+    // identity.sourceIp — normalize to array so generateCommand's
+    // `payload.meta.ip->Array.shift` doesn't crash on null/non-array values.
+    const rawIp = event.meta?.ip;
+    const ip = rawIp == null ? [] : Array.isArray(rawIp) ? rawIp : [rawIp];
+    const meta = { ...event.meta, ip };
+    return generateCommand({ ...event, meta, identity });
+  };
+}
+
+// Set at handler entry; read by runEffect to tag logs with the Lambda request id.
+let _currentRequestId = "unknown";
+
+function runEffect(correlationId, effect) {
+  let e = effect
+    // Promote correlationId/requestId/plugin to top-level JSON log fields —
+    // decoded by EffectLogger.install() from Effect log annotations. Harmless
+    // no-op if the unified logger isn't installed.
+    .pipe(Effect.annotateLogs("correlationId", correlationId || "unknown"))
+    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
+  if (pluginName) e = e.pipe(Effect.annotateLogs("plugin", pluginName));
+  return e
+    .pipe(Effect.provideService(requestContextTag, { correlationId: correlationId || "unknown" }))
+    .pipe(Effect.runPromise);
+}
+
+function groupBySource(records) {
+  const dict = {};
+  records.forEach(record => {
+    const arn = record.eventSourceARN;
+    const existing = dict[arn] || [];
+    dict[arn] = existing.concat([record]);
+  });
+  return dict;
+}
+
+function extractCorrelationId(records) {
+  const first = records[0];
+  if (!first) return undefined;
+  const body = first.body;
+  if (body == null) return undefined;
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const meta = parsed.meta;
+      if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+        const cid = meta.correlationId;
+        if (typeof cid === "string") return cid;
+      }
+    }
+  } catch (_) {}
+  return undefined;
+}
+
+// DISPATCH_MODE controls whether AppSync direct-invoke commands are run inline
+// (sync, default) or pushed to SQS for asynchronous processing (async).
+// Aggregate_Builder_Single bundles this entry point with sync; the async
+// variant (Aggregate_Builder_Single_Async) sets DISPATCH_MODE=async.
+const DISPATCH_MODE = process.env["DISPATCH_MODE"] === "async" ? "async" : "sync";
+
+async function buildAllHandlers() {
+  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
+  const config = JSON.parse(configStr);
+  const cmdTopicHandlers = {};
+  const cmdGenHandlers = {};
+  await Promise.all(config.handlers.map(async h => {
+    const specModule = await dynamicImport(h.specModule);
+    const behaviorModule = await dynamicImport(h.behaviorModule);
+    const parts = buildAggregateParts(specModule, behaviorModule, h.eventLogTable, h.queueUrl);
+    cmdTopicHandlers[h.queueArn] = parts.sqsHandler;
+    cmdGenHandlers[specModule.name] = buildCommandGeneratorHandler(parts, DISPATCH_MODE);
+  }));
+  return [cmdTopicHandlers, cmdGenHandlers];
+}
+
+const initPromise = buildAllHandlers();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const [cmdTopicHandlers, cmdGenHandlers] = await initPromise;
+
+  // Route 1: AppSync direct invocation
+  if (event.command != null && event.arguments != null) {
+    // Plugin status gate (Part 2.3) — checked before dispatching to the
+    // per-aggregate handler so a deactivated plugin's mutations are rejected
+    // without touching the EventLog or CommandTopic.
+    const rejection = await checkPluginStatus(event);
+    if (rejection !== null) {
+      log.warn("plugin status gate rejected: " + rejection.errorCode, { comp: "CommandGenerator" });
+      return rejection;
+    }
+    const entries = Object.entries(cmdGenHandlers);
+    const len = entries.length;
+    let i = 0;
+    let result = null;
+    let found = false;
+    while (i < len && !found) {
+      const [name, cmdGenHandler] = entries[i];
+      try {
+        const r = await runEffect(undefined, cmdGenHandler(event, context));
+        log.debug("processed command via " + name, { comp: "CommandGenerator" });
+        result = r;
+        found = true;
+      } catch (e) {
+        log.debug("handler '" + name + "' threw, trying next", { comp: "CommandGenerator", detail: e && e.message ? e.message : String(e) });
+        i = i + 1;
+      }
+    }
+    if (!found) {
+      log.warn("no handler matched command", { comp: "CommandGenerator" });
+      return null;
+    }
+    // generateCommand returns a ReScript commandOutcome variant
+    // (Accepted/Rejected/Pending) compiled to a `{TAG, ...}` JS object. AppSync
+    // resolves the CommandResult union by `__typename` — convert to that shape.
+    return commandOutcomeToJson(result);
+  }
+
+  // Route 2: SQS CommandTopic events
+  const records = event.Records || [];
+  const correlationId = extractCorrelationId(records);
+  const grouped = groupBySource(records);
+  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
+    const cmdHandler = cmdTopicHandlers[arn];
+    if (cmdHandler !== undefined) {
+      log.debug("found handler for CommandTopic " + arn, { comp: "AggregateRuntime" });
+      await runEffect(correlationId, cmdHandler({ Records: subRecords }, context));
+    } else {
+      log.warn("no handler found: " + arn, { comp: "AggregateRuntime" });
+    }
+  }));
+  return "";
+}

package/src/adapter/Runtime/AggregateRuntime_Builder_Micro.res

@@ -0,0 +1,327 @@
+module CommandTopicChannel = CommandTopicChannel.SQS_Sync
+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): 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): 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,
+            )
+
+          // Collect user packages (shared by CmdTopic and CmdGen)
+          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)
+
+            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",
+              `eventCollector registered for ${spec.aggregateName} but no mappingsModulePath — skipping EventMapper Lambda`,
+            )
+          | _ => ()
+          }
+        | None =>
+          log.warn(
+            ~comp="AggregateRuntime_Builder_Micro",
+            `no handler registered for ${spec.aggregateName}`,
+          )
+        }
+      })
+    }
+    finished := true
+  }