@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/SideEffectHandlerRuntime_Builder_Single.res

@@ -0,0 +1,178 @@
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+type sideEffectInfo = {
+  sideEffectModulePaths: array<string>,
+}
+
+let sideEffectInfos: dict<sideEffectInfo> = Dict.make()
+
+let registerSideEffectHandler = (~sideEffectHandlerName, ~sideEffectModulePaths) =>
+  sideEffectInfos->Dict.set(sideEffectHandlerName, {sideEffectModulePaths: sideEffectModulePaths})
+
+type storedSpec = {
+  componentName: string,
+  parentResource: Pulumi.Resource.t,
+  sourceUrns: Pulumi.Output.t<array<string>>,
+  channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<
+    EventCollectorChannel.callbackEvent,
+    context,
+    EventCollectorChannel.channelParts,
+  >,
+  memorySize: int,
+  timeout: int,
+}
+
+let storedSpecs: array<storedSpec> = []
+let grandParent = ref(None)
+
+let forEventCollector: ReventlessCore.Runtime.forEventCollector<
+  ReventlessCore.Runtime.effectHandler<
+    EventCollectorChannel.callbackEvent,
+    context,
+    unit,
+    string,
+  >,
+  ReventlessCore.EventCollector.component,
+> = (
+  ~handler as _,
+  ~eventTopics,
+  ~resources,
+  ~memorySize=1024,
+  ~timeout=30,
+  eventCollector,
+) => {
+  let eventCollectorResource = eventCollector->ReventlessCore.Component.toPulumiResource
+  let channel = eventCollector->ReventlessCore.EventCollector_Adapter.channel
+  let eventCollectorName = eventCollectorResource.name->Option.getOr("Unnamed")
+
+  switch eventCollectorResource.parent {
+  | Some(parentResource) =>
+    let parentName = parentResource.name->Option.getOr("Unnamed")
+    if grandParent.contents == None {
+      grandParent := parentResource.parent
+    }
+
+    let sourceUrns =
+      (eventCollector->ReventlessCore.Component.outputs).resources
+      ->Array.map(({urn}) => urn)
+      ->Pulumi.Output.all
+
+    storedSpecs
+    ->Array.push({
+      componentName: parentName,
+      parentResource,
+      sourceUrns,
+      channelSpec: {channel, eventTopics, resources},
+      memorySize,
+      timeout,
+    })
+    ->ignore
+
+    log.info(
+      ~comp="SideEffectHandlerRuntime_Builder_Single",
+      `registered ${eventCollectorName} for ${parentName}`,
+    )
+  | None =>
+    JsError.throwWithMessage(
+      `forEventCollector(single): eventCollector ${eventCollectorName} has no parent`,
+    )
+  }
+}
+
+let finished = ref(false)
+
+let finish = () =>
+  if !finished.contents {
+    if storedSpecs->Array.length > 0 {
+      let (maxMemorySize, maxTimeout) = storedSpecs->Array.reduce((0, 0), (
+        (accMemorySize, accTimeout),
+        {memorySize, timeout},
+      ) => {
+        (Math.Int.max(accMemorySize, memorySize), Math.Int.max(accTimeout, timeout))
+      })
+
+      switch grandParent.contents {
+      | Some(parent) =>
+        let opts = {Pulumi.ComponentResource.parent: parent}
+
+        // Build HANDLER_CONFIG as a single JSON env var.
+        let handlerOutputs: array<Pulumi.Output.t<string>> = []
+        let packageDirs: dict<string> = Dict.make()
+
+        storedSpecs->Array.forEach(spec => {
+          switch sideEffectInfos->Dict.get(spec.componentName) {
+          | Some(info) =>
+            // Collect unique user packages for the code asset
+            info.sideEffectModulePaths->Array.forEach(modPath => {
+              let pkg = Util_Bundle.extractPackageName(modPath)
+              packageDirs->Dict.set(pkg, Util_Bundle.resolvePackageRoot(pkg))
+            })
+
+            // Build JSON array of module paths
+            let modulesJson =
+              info.sideEffectModulePaths
+              ->Array.map(p => p->JSON.stringifyAny->Option.getOr(`""`))
+              ->Array.join(",")
+
+            let handlerJson =
+              spec.sourceUrns
+              ->Pulumi.Output.apply(urns => {
+                let sourceUrn = urns->Array.getUnsafe(0)
+                `{"sideEffectModules":[${modulesJson}],"sourceUrn":"${sourceUrn}"}`
+              })
+            let _ = handlerOutputs->Array.push(handlerJson)
+          | None =>
+            log.warn(
+              ~comp="SideEffectHandlerRuntime_Builder_Single",
+              `no handler registered for ${spec.componentName}`,
+            )
+          }
+        })
+
+        let handlerConfigOutput =
+          Pulumi.Output.all(handlerOutputs)
+          ->Pulumi.Output.apply(handlers =>
+            `{"handlers":[${handlers->Array.join(",")}]}`
+          )
+
+        let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+        envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+
+        // Build AssetArchive: static re-export + user packages
+        let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+          ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/SideEffectEntryPoint.mjs",
+          ~packageDirs,
+        )
+
+        let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+          ~name="AllSideEffectHandlers",
+          ~code,
+          ~sourceCodeHash,
+          ~envVars,
+          ~memorySize=maxMemorySize,
+          ~timeout=maxTimeout,
+          ~opts,
+        )
+
+        let channelSpecs = storedSpecs->Array.map(({channelSpec}) => channelSpec)
+        let _connectResources = EventCollectorChannel.connect(
+          ~name="AllSideEffectHandlers",
+          ~channelSpecs,
+          ~runtime,
+          ~opts,
+        )
+      | None =>
+        log.warn(
+          ~comp="SideEffectHandlerRuntime_Builder_Single",
+          `finish: grandParent not set`,
+        )
+      }
+    }
+    finished := true
+  }

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

@@ -0,0 +1,129 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as 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 Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.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 sideEffectInfos = {};
+
+function registerSideEffectHandler(sideEffectHandlerName, sideEffectModulePaths) {
+  sideEffectInfos[sideEffectHandlerName] = {
+    sideEffectModulePaths: sideEffectModulePaths
+  };
+}
+
+let storedSpecs = [];
+
+let grandParent = {
+  contents: undefined
+};
+
+function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeoutOpt, eventCollector) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let eventCollectorResource = Component$ReventlessCore.toPulumiResource(eventCollector);
+  let channel = eventCollector.channel;
+  let eventCollectorName = Stdlib_Option.getOr(eventCollectorResource.__name, "Unnamed");
+  let parentResource = eventCollectorResource.__parentResource;
+  if (parentResource === undefined) {
+    return Stdlib_JsError.throwWithMessage(`forEventCollector(single): eventCollector ` + eventCollectorName + ` has no parent`);
+  }
+  let parentName = Stdlib_Option.getOr(parentResource.__name, "Unnamed");
+  if (grandParent.contents === undefined) {
+    grandParent.contents = parentResource.__parentResource;
+  }
+  let sourceUrns = Pulumi.all(Component$ReventlessCore.outputs(eventCollector).resources.map(param => param.urn));
+  storedSpecs.push({
+    componentName: parentName,
+    parentResource: parentResource,
+    sourceUrns: sourceUrns,
+    channelSpec: {
+      channel: channel,
+      eventTopics: eventTopics,
+      resources: resources
+    },
+    memorySize: memorySize,
+    timeout: timeout
+  });
+  log.info("SideEffectHandlerRuntime_Builder_Single", undefined, `registered ` + eventCollectorName + ` for ` + parentName);
+}
+
+let finished = {
+  contents: false
+};
+
+function finish() {
+  if (finished.contents) {
+    return;
+  }
+  if (storedSpecs.length !== 0) {
+    let match = Stdlib_Array.reduce(storedSpecs, [
+      0,
+      0
+    ], (param, param$1) => [
+      Math.max(param[0], param$1.memorySize),
+      Math.max(param[1], param$1.timeout)
+    ]);
+    let parent = grandParent.contents;
+    if (parent !== undefined) {
+      let opts_parent = parent;
+      let opts = {
+        parent: opts_parent
+      };
+      let handlerOutputs = [];
+      let packageDirs = {};
+      storedSpecs.forEach(spec => {
+        let info = sideEffectInfos[spec.componentName];
+        if (info === undefined) {
+          return log.warn("SideEffectHandlerRuntime_Builder_Single", undefined, `no handler registered for ` + spec.componentName);
+        }
+        info.sideEffectModulePaths.forEach(modPath => {
+          let pkg = Util_Bundle$ReventlessAws.extractPackageName(modPath);
+          packageDirs[pkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(pkg);
+        });
+        let modulesJson = info.sideEffectModulePaths.map(p => Stdlib_Option.getOr(JSON.stringify(p), `""`)).join(",");
+        let handlerJson = spec.sourceUrns.apply(urns => {
+          let sourceUrn = urns[0];
+          return `{"sideEffectModules":[` + modulesJson + `],"sourceUrn":"` + sourceUrn + `"}`;
+        });
+        handlerOutputs.push(handlerJson);
+      });
+      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
+      let envVars = {};
+      envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      let match$1 = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/SideEffectEntryPoint.mjs", packageDirs, undefined);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllSideEffectHandlers", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, opts);
+      let channelSpecs = storedSpecs.map(param => param.channelSpec);
+      EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllSideEffectHandlers", channelSpecs, runtime, opts);
+    } else {
+      log.warn("SideEffectHandlerRuntime_Builder_Single", undefined, `finish: grandParent not set`);
+    }
+  }
+  finished.contents = true;
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  sideEffectInfos,
+  registerSideEffectHandler,
+  storedSpecs,
+  grandParent,
+  forEventCollector,
+  finished,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res

@@ -0,0 +1,166 @@
+// Runtime builder for the DCB StateChange command-handler Lambda.
+//
+// Builds the `<Plugin>DcbCmdHandler` (sync) / `<Plugin>DcbAsyncCmdHandler` (async)
+// Lambda that runs all of a plugin's StateChangeSlice command handlers — the
+// "Single" deployment strategy (one shared Lambda per plugin). DCB StateChange
+// has no other topology, so there is no `_PerSlice`/`_Micro` variant.
+//
+// Mirrors StateViewSliceRuntime_Builder_Single so the two DCB slice runtimes are
+// discoverable side by side. The registration state (which slices, table name,
+// per-flavor commandHandlerConfig) is plugin-runtime-level and stays in
+// PluginRuntime_Builder; its `forDcbCommandTopic` is a thin delegator that reads
+// those refs and calls the build below. This module owns only the build.
+
+let log = ReventlessCore.Logger.fromEnv()
+
+// `slicePaths`: `(specPath, behaviorPath)` per StateChangeSlice (already merged
+// from auto- and manually-registered sources by the caller).
+let forDcbCommandTopic = (
+  ~slicePaths: array<(string, string)>,
+  ~dcbTableName: option<Pulumi.Output.t<string>>,
+  ~pluginName: string,
+  ~syncConfig: ReventlessCore.Runtime.commandHandlerConfig,
+  ~asyncConfig: ReventlessCore.Runtime.commandHandlerConfig,
+  ~connect,
+  dcbCommandTopic,
+) =>
+  if slicePaths->Array.length == 0 {
+    log.warn(
+      ~comp="StateChangeSliceRuntime_Builder_Single",
+      "forDcbCommandTopic skipped (no slice specs)",
+    )
+  } else {
+    let commandTopicResource = dcbCommandTopic->ReventlessCore.Component.toPulumiResource
+    // The CommandTopic resource is named `<Plugin>Dcb` (sync) or `<Plugin>DcbAsync`
+    // (async) by Dcb_Builder. Detect async off that bare stem (below), then append
+    // the canonical `CmdHandler` Lambda kind so the command-handler Lambda is
+    // greppable alongside the aggregate lineage.
+    let baseName = commandTopicResource.name->Option.getOr("UnnamedDcb")
+    let opts = {Pulumi.ComponentResource.parent: commandTopicResource}
+
+    // Extract SQS queue from the DCB CommandTopic
+    let channel = dcbCommandTopic->ReventlessCore.CommandTopic_Adapter.channel
+    let channelParts: Util.SQS.channelParts = Obj.magic(channel.parts)
+    let queue = channelParts.queue
+
+    let dcbTableName = switch dcbTableName {
+    | Some(tableName) => tableName
+    | None => Pulumi.Output.make("NOT_AVAILABLE")
+    }
+
+    // The async DCB CommandTopic is named `<Plugin>DcbAsync` by Dcb_Builder, so the
+    // bare stem's `Async` suffix is an unambiguous signal. Flip
+    // DcbCommandTopicEntryPoint into async dispatch — Route 1 returns CommandPending
+    // instead of running the slice handler inline.
+    let isAsync = baseName->String.endsWith("Async")
+    let name = baseName ++ "CmdHandler"
+
+    let cfg = isAsync ? asyncConfig : syncConfig
+
+    let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+    envVars->Dict.set("DCB_TABLE", dcbTableName->Pulumi.Output.asInput)
+    envVars->Dict.set("QUEUE_URL", queue.id->Pulumi.Output.asInput)
+    if isAsync {
+      envVars->Dict.set("DISPATCH_MODE", "async"->Pulumi.Input.make)
+    }
+    cfg.envVars->Option.forEach(extra =>
+      extra->Dict.forEachWithKey((value, key) => {
+        if envVars->Dict.get(key)->Option.isNone {
+          envVars->Dict.set(key, value->Pulumi.Output.make->Pulumi.Output.asInput)
+        }
+      })
+    )
+
+    // Build HANDLER_CONFIG JSON: array of {spec, behavior} objects so the entry point
+    // can dynamically import both modules and apply the curried StateChangeSlice_Callback.Make
+    // functor (Make(Spec)(Behavior)).
+    let sliceModulesJson =
+      slicePaths
+      ->Array.map(((specPath, behaviorPath)) => {
+        let s = specPath->JSON.stringifyAny->Option.getOr(`""`)
+        let b = behaviorPath->JSON.stringifyAny->Option.getOr(`""`)
+        `{"spec":${s},"behavior":${b}}`
+      })
+      ->Array.join(",")
+
+    let handlerConfigJson =
+      Pulumi.Output.all2((dcbTableName, queue.id))
+      ->Pulumi.Output.apply(((table, queueUrl)) => {
+        let pluginNameJson = pluginName->JSON.stringifyAny->Option.getOr(`""`)
+        `{"dcbEventLogTableName":"${table}","queueUrl":"${queueUrl}","pluginName":${pluginNameJson},"stateChangeSliceModules":[${sliceModulesJson}]}`
+      })
+    envVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
+
+    // Build code asset
+    let packageDirs: dict<string> = Dict.make()
+    slicePaths->Array.forEach(((specPath, behaviorPath)) => {
+      let specPkg = Util_Bundle.extractPackageName(specPath)
+      packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+      let behaviorPkg = Util_Bundle.extractPackageName(behaviorPath)
+      packageDirs->Dict.set(behaviorPkg, Util_Bundle.resolvePackageRoot(behaviorPkg))
+    })
+    // Include the framework packages alongside the entry point so the deployed
+    // Lambda picks up uncommitted local changes without waiting for the Lambda
+    // Layer rebuild (the layer fetches @reventlessdev/reventless-* from GitHub
+    // Packages, not the local pnpm workspace). reventless-core is critical here
+    // because StateChangeSlice_Callback (the actual command handler) lives in core.
+    packageDirs->Dict.set(
+      "@reventlessdev/reventless-aws",
+      Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-aws"),
+    )
+    packageDirs->Dict.set(
+      "@reventlessdev/reventless-core",
+      Util_Bundle.resolvePackageRoot("@reventlessdev/reventless-core"),
+    )
+
+    let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+      ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs",
+      ~packageDirs,
+    )
+
+    cfg.sqsBatchSize->Option.forEach(CommandTopicChannel.SQS.setBatchSize)
+
+    let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+      ~name,
+      ~code,
+      ~sourceCodeHash,
+      ~envVars,
+      ~memorySize=?cfg.memorySize,
+      ~timeout=?cfg.timeout,
+      ~reservedConcurrency=?cfg.reservedConcurrency,
+      ~ephemeralStorageMb=?cfg.ephemeralStorageMb,
+      ~logRetentionDays=?cfg.logRetentionDays,
+      // This is the StateChangeSlice command handler — provision the DCB
+      // retry/conflict metric filters (takes effect when logRetentionDays is set).
+      ~dcbMetrics=true,
+      ~opts,
+    )
+
+    // The DCB command topic Lambda is invoked directly by AppSync (Route 1) and
+    // needs sqs:SendMessage to publish commands to the FIFO queue for processing.
+    // makeWithDefaultPolicy only grants sqs:Receive* (for SQS trigger Route 2).
+    let _ = queue.arn->Pulumi.Output.apply(queueArn => {
+      PulumiAws.IAM.RolePolicy.make(
+        ~name=`${name}-sqsSend`,
+        ~args={
+          policy: PulumiAws.PolicyDocument.make(
+            ~id=`${name}-sqsSendPolicy`,
+            ~statements=[
+              {
+                sid: "AllowSqsSend",
+                effect: Allow,
+                actions: Action("sqs:SendMessage"),
+                resources: Resource(queueArn),
+              },
+            ],
+          )
+          ->PulumiAws.PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: runtime.parts.lambdaRole.id->Pulumi.Output.asInput,
+        },
+      )
+    })
+
+    connect(~runtime)
+    CommandTopicChannel.SQS.clearBatchSize()
+  }

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

@@ -0,0 +1,87 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as CommandTopicChannel_SQS$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function forDcbCommandTopic(slicePaths, dcbTableName, pluginName, syncConfig, asyncConfig, connect, dcbCommandTopic) {
+  if (slicePaths.length === 0) {
+    return log.warn("StateChangeSliceRuntime_Builder_Single", undefined, "forDcbCommandTopic skipped (no slice specs)");
+  }
+  let commandTopicResource = Component$ReventlessCore.toPulumiResource(dcbCommandTopic);
+  let baseName = Stdlib_Option.getOr(commandTopicResource.__name, "UnnamedDcb");
+  let opts_parent = commandTopicResource;
+  let opts = {
+    parent: opts_parent
+  };
+  let channel = dcbCommandTopic.channel;
+  let channelParts = channel.parts;
+  let queue = channelParts.queue;
+  let dcbTableName$1 = dcbTableName !== undefined ? dcbTableName : Pulumi.output("NOT_AVAILABLE");
+  let isAsync = baseName.endsWith("Async");
+  let name = baseName + "CmdHandler";
+  let cfg = isAsync ? asyncConfig : syncConfig;
+  let envVars = {};
+  envVars["DCB_TABLE"] = dcbTableName$1;
+  envVars["QUEUE_URL"] = queue.id;
+  if (isAsync) {
+    envVars["DISPATCH_MODE"] = "async";
+  }
+  Stdlib_Option.forEach(cfg.envVars, extra => Stdlib_Dict.forEachWithKey(extra, (value, key) => {
+    if (Stdlib_Option.isNone(envVars[key])) {
+      envVars[key] = Pulumi.output(value);
+      return;
+    }
+  }));
+  let sliceModulesJson = slicePaths.map(param => {
+    let s = Stdlib_Option.getOr(JSON.stringify(param[0]), `""`);
+    let b = Stdlib_Option.getOr(JSON.stringify(param[1]), `""`);
+    return `{"spec":` + s + `,"behavior":` + b + `}`;
+  }).join(",");
+  let handlerConfigJson = Pulumi.all([
+    dcbTableName$1,
+    queue.id
+  ]).apply(param => {
+    let pluginNameJson = Stdlib_Option.getOr(JSON.stringify(pluginName), `""`);
+    return `{"dcbEventLogTableName":"` + param[0] + `","queueUrl":"` + param[1] + `","pluginName":` + pluginNameJson + `,"stateChangeSliceModules":[` + sliceModulesJson + `]}`;
+  });
+  envVars["HANDLER_CONFIG"] = handlerConfigJson;
+  let packageDirs = {};
+  slicePaths.forEach(param => {
+    let specPkg = Util_Bundle$ReventlessAws.extractPackageName(param[0]);
+    packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+    let behaviorPkg = Util_Bundle$ReventlessAws.extractPackageName(param[1]);
+    packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
+  });
+  packageDirs["@reventlessdev/reventless-aws"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-aws");
+  packageDirs["@reventlessdev/reventless-core"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-core");
+  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs", packageDirs, undefined);
+  Stdlib_Option.forEach(cfg.sqsBatchSize, CommandTopicChannel_SQS$ReventlessAws.setBatchSize);
+  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, match.code, match.sourceCodeHash, envVars, cfg.memorySize, cfg.timeout, cfg.reservedConcurrency, cfg.ephemeralStorageMb, cfg.logRetentionDays, true, opts);
+  queue.arn.apply(queueArn => new (Aws.iam.RolePolicy)(name + `-sqsSend`, {
+    policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `-sqsSendPolicy`, [{
+        Sid: "AllowSqsSend",
+        Effect: "Allow",
+        Action: "sqs:SendMessage",
+        Resource: queueArn
+      }])),
+    role: runtime.parts.lambdaRole.id
+  }));
+  connect(runtime);
+  CommandTopicChannel_SQS$ReventlessAws.clearBatchSize();
+}
+
+export {
+  log,
+  forDcbCommandTopic,
+}
+/* log Not a pure module */