@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -0,0 +1,187 @@
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+type sliceInfo = {
+  specModulePath: string,
+  callbackType: string,
+  queryDbTableName: Pulumi.Output.t<string>,
+}
+
+let bundledInfos: dict<sliceInfo> = Dict.make()
+
+let dcbQueueUrlRef: ref<option<Pulumi.Output.t<string>>> = ref(None)
+let setDcbQueueUrl = url => dcbQueueUrlRef := Some(url)
+
+let registerAutomationSlice = (
+  ~name,
+  ~specModulePath,
+  ~callbackType="automation",
+  ~queryDbTableName,
+) =>
+  bundledInfos->Dict.set(name, {specModulePath, callbackType, queryDbTableName})
+
+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="AutomationSliceRuntime_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}
+
+        let handlerOutputs: array<Pulumi.Output.t<string>> = []
+        let packageDirs: dict<string> = Dict.make()
+
+        let dcbQueueUrl = switch dcbQueueUrlRef.contents {
+        | Some(url) => url
+        | None => Pulumi.Output.make("NOT_AVAILABLE")
+        }
+
+        storedSpecs->Array.forEach(spec => {
+          switch bundledInfos->Dict.get(spec.componentName) {
+          | Some(info) =>
+            let pkg = Util_Bundle.extractPackageName(info.specModulePath)
+            packageDirs->Dict.set(pkg, Util_Bundle.resolvePackageRoot(pkg))
+
+            let specModule =
+              info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let callbackType =
+              info.callbackType->JSON.stringifyAny->Option.getOr(`""`)
+
+            let handlerJson =
+              Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, spec.sourceUrns))
+              ->Pulumi.Output.apply(((tableName, queueUrl, urns)) => {
+                let sourceUrn = urns->Array.getUnsafe(0)
+                `{"specModule":${specModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${sourceUrn}"}`
+              })
+            let _ = handlerOutputs->Array.push(handlerJson)
+          | None =>
+            log.warn(
+              ~comp="AutomationSliceRuntime_Builder_Single",
+              `no bundled info 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)
+
+        let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+          ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs",
+          ~packageDirs,
+        )
+
+        let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+          ~name="AllAutomationSlices",
+          ~code,
+          ~sourceCodeHash,
+          ~envVars,
+          ~memorySize=maxMemorySize,
+          ~timeout=maxTimeout,
+          ~opts,
+        )
+
+        let channelSpecs = storedSpecs->Array.map(({channelSpec}) => channelSpec)
+        let _connectResources = EventCollectorChannel.connect(
+          ~name="AllAutomationSlices",
+          ~channelSpecs,
+          ~runtime,
+          ~opts,
+        )
+      | None =>
+        log.warn(
+          ~comp="AutomationSliceRuntime_Builder_Single",
+          `finish: grandParent not set`,
+        )
+      }
+    }
+    finished := true
+  }

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

@@ -0,0 +1,147 @@
+// 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 bundledInfos = {};
+
+let dcbQueueUrlRef = {
+  contents: undefined
+};
+
+function setDcbQueueUrl(url) {
+  dcbQueueUrlRef.contents = url;
+}
+
+function registerAutomationSlice(name, specModulePath, callbackTypeOpt, queryDbTableName) {
+  let callbackType = callbackTypeOpt !== undefined ? callbackTypeOpt : "automation";
+  bundledInfos[name] = {
+    specModulePath: specModulePath,
+    callbackType: callbackType,
+    queryDbTableName: queryDbTableName
+  };
+}
+
+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("AutomationSliceRuntime_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 = {};
+      let url = dcbQueueUrlRef.contents;
+      let dcbQueueUrl = url !== undefined ? url : Pulumi.output("NOT_AVAILABLE");
+      storedSpecs.forEach(spec => {
+        let info = bundledInfos[spec.componentName];
+        if (info === undefined) {
+          return log.warn("AutomationSliceRuntime_Builder_Single", undefined, `no bundled info registered for ` + spec.componentName);
+        }
+        let pkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+        packageDirs[pkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(pkg);
+        let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+        let callbackType = Stdlib_Option.getOr(JSON.stringify(info.callbackType), `""`);
+        let handlerJson = Pulumi.all([
+          info.queryDbTableName,
+          dcbQueueUrl,
+          spec.sourceUrns
+        ]).apply(param => {
+          let sourceUrn = param[2][0];
+          return `{"specModule":` + specModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","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/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", 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("AllAutomationSlices", channelSpecs, runtime, opts);
+    } else {
+      log.warn("AutomationSliceRuntime_Builder_Single", undefined, `finish: grandParent not set`);
+    }
+  }
+  finished.contents = true;
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  bundledInfos,
+  dcbQueueUrlRef,
+  setDcbQueueUrl,
+  registerAutomationSlice,
+  storedSpecs,
+  grandParent,
+  forEventCollector,
+  finished,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/CounterEntryPoint.mjs

@@ -0,0 +1,91 @@
+// Counter Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports Target Spec and Mappings,
+// wires Counter_Callback.Make + EventMapper_Callback.MakeCounterHandler.
+// Routes DynamoDB Stream events from references and counts tables.
+
+import { schema as surySchema, string as suryString, $$int as suryInt, parseJsonOrThrow } from "sury/src/S.res.mjs";
+import { patchSpecId, makeTableRef, makeQueueRef, log } from "./HandlerFactoryHelpers.mjs";
+import { parseDynamoDbStreamRecordState } from "@reventlessdev/reventless-aws/src/util/Util_DynamoDbStream_Runtime.res.mjs";
+import { Make as counterCallbackMake } from "@reventlessdev/reventless-core/src/components/Counter/Counter_Callback.res.mjs";
+import { MakeCounterHandler } from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
+import { count as qdbCount } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// Build the referencesView schema: {id: string, inc: int}
+const referencesViewSchema = surySchema(s => ({
+  id: s.m(suryString),
+  inc: s.m(suryInt),
+}));
+
+async function buildHandler() {
+  const configStr = process.env["HANDLER_CONFIG"] || "{}";
+  const config = JSON.parse(configStr);
+
+  const targetSpecModule = await dynamicImport(config.targetSpecModule);
+  const mappingsModule = await dynamicImport(config.mappingsModule);
+
+  const patchedTarget = patchSpecId(targetSpecModule);
+  const countsTable = makeTableRef(config.countsTableName);
+  const countsDbCount = qdbCount(countsTable);
+
+  const pubJsons = sqsPublishJsons(makeQueueRef(config.publishQueueUrl), "SQS_FIFO");
+  const queryEngine = { query: async () => [], queryAll: async () => [] };
+
+  const counterHandler = MakeCounterHandler(patchedTarget)(mappingsModule)({ publishJsons: pubJsons, queryEngine });
+  const callback = counterCallbackMake({
+    name: "BundledCounter",
+    countsDbCount,
+    jsonEventsHandler: counterHandler.handleCounterEvents,
+  });
+
+  return [config.referencesStreamArn, config.countsStreamArn, callback];
+}
+
+const initPromise = buildHandler();
+
+export async function handler(event, _context) {
+  const [referencesStreamArn, countsStreamArn, callback] = await initPromise;
+  const records = event.Records || [];
+
+  const dynamoDbRecords = records.filter(r =>
+    r.eventSource === "aws:dynamodb" &&
+    (r.eventSourceARN === referencesStreamArn || r.eventSourceARN === countsStreamArn)
+  );
+
+  const referenceRecords = dynamoDbRecords.filter(r => r.eventSourceARN === referencesStreamArn);
+  const countRecords = dynamoDbRecords.filter(r => r.eventSourceARN === countsStreamArn);
+
+  const references = referenceRecords.flatMap(record => {
+    const state = parseDynamoDbStreamRecordState(record);
+    switch (state.TAG) {
+      case 0: { // NewImage(id, newImage)
+        const id = state._0;
+        let inc;
+        try {
+          inc = parseJsonOrThrow(state._1, referencesViewSchema).inc;
+        } catch (_) {
+          inc = 1;
+        }
+        return [[id, inc]];
+      }
+      case 2: // NewAndOldImage — duplicate
+        log.debug("ignoring duplicate id: " + state._0, { comp: "CounterEntryPoint" });
+        return [];
+      default:
+        return [];
+    }
+  });
+
+  const counts = countRecords.flatMap(record => {
+    const state = parseDynamoDbStreamRecordState(record);
+    if (state.TAG === 0 || state.TAG === 2) {
+      return [state._1];
+    }
+    return [];
+  });
+
+  await callback.counterHandler(references, counts);
+  return "";
+}

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -0,0 +1,265 @@
+// DcbCommandTopic Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports StateChangeSlice modules,
+// builds shared DcbEventLog operations and per-slice handlers keyed by command type name.
+// Dual routing: AppSync direct invocation and SQS CommandTopic events.
+
+import * as Chunk from "effect/Chunk";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { patchSpecId, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { decodeCommand$p as decodeCommandPrime } from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import {
+  extractVariantNames,
+  extractTagKeysByEventType,
+  mergeTagKeysByEventType,
+  extractCrossPartitionTagKeys,
+} from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import { Make as dcbEventLogOperationsMake } from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
+import { Make as stateChangeSliceCallbackMake } from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_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 { json as jsonSchema } from "sury/src/S.res.mjs";
+import { read, append, readStream } from "@reventlessdev/reventless-aws/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
+import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// DISPATCH_MODE controls whether AppSync direct-invoke commands are run inline
+// (sync, default) or pushed to SQS for asynchronous processing (async).
+// Set by PluginRuntime_Builder.forDcbCommandTopic when wiring the async DCB
+// CommandTopic; sync is the default for the primary DCB topic.
+const DISPATCH_MODE = process.env["DISPATCH_MODE"] === "async" ? "async" : "sync";
+
+function extractTypeName(json) {
+  if (typeof json === 'string') return json;
+  if (json && typeof json === 'object') {
+    const commandJson = json.commandJson || json.command || json;
+    if (typeof commandJson === 'string') return commandJson;
+    if (commandJson && commandJson.TAG) return commandJson.TAG;
+    const keys = Object.keys(commandJson);
+    if (keys.length === 1 && keys[0] !== 'id' && keys[0] !== 'meta') return keys[0];
+  }
+  return undefined;
+}
+
+// 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 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;
+}
+
+function getIdStringSchema() {
+  return IdString.schema;
+}
+
+// Exported for tests: build the [sqsHandler, cmdGenHandler] pair from an
+// already-parsed `HANDLER_CONFIG` shape, with an injectable module loader.
+// In production, `buildHandler` below wraps this with the env-config + the
+// Lambda's `/var/task/node_modules` dynamic-import; integration tests inject
+// their own loader that returns pre-imported spec/behavior modules so the test
+// can drive the real `cmdGenHandler` end-to-end against DynamoDB Local.
+export async function buildHandlersForConfig(config, opts = {}) {
+  const loadModule = opts.loadModule ?? dynamicImport;
+  const resolvedTable = { name: config.dcbEventLogTableName };
+  const rawStorageOps = {
+    read: read(resolvedTable),
+    append: append(resolvedTable),
+    readStream: readStream(resolvedTable),
+  };
+
+  const handlersByType = {};
+  const sharedDcbEventLogOps = dcbEventLogOperationsMake({
+    name: config.pluginName,
+    // Mirrors DcbEventLog_Builder.res's `name ++ "DcbEventLog"` — the
+    // canonical service identity used by Plugin_Callback dispatch and the
+    // DcbEventLog_Operations meta.service normalisation in append.
+    serviceName: config.pluginName + "DcbEventLog",
+    storage: rawStorageOps,
+    publishJson: async (_name, _meta, _json) => {},
+  });
+
+  // Load all spec/behavior pairs first, then derive the per-plugin
+  // tagKeysByEventType / crossPartitionTagKeys across the produced event
+  // schemas — mirroring Dcb_Builder.res's build-time derivation — so the
+  // runtime slice callback receives the same values it would in-process.
+  const loadedSlices = await Promise.all(
+    config.stateChangeSliceModules.map(async ({ spec, behavior }) => {
+      const specModule = await loadModule(spec);
+      const behaviorModule = await loadModule(behavior);
+      const patchedSpec = patchSpecId(specModule);
+      return { patchedSpec, behaviorModule };
+    })
+  );
+
+  const producedSchemas = loadedSlices.map(({ patchedSpec }) => patchedSpec.eventSchema);
+  const tagKeysByEventType = mergeTagKeysByEventType(
+    producedSchemas.map(s => extractTagKeysByEventType(s))
+  );
+  const crossPartitionTagKeys = Array.from(
+    new Set(producedSchemas.flatMap(s => extractCrossPartitionTagKeys(s)))
+  );
+
+  loadedSlices.forEach(({ patchedSpec, behaviorModule }) => {
+    const sliceCallback = stateChangeSliceCallbackMake(patchedSpec)(behaviorModule);
+    const commandSchema = patchedSpec.commandSchema;
+    const typeNames = extractVariantNames(commandSchema);
+
+    const jsonHandler = stream => {
+      const decodedStream = Stream.flatMap(
+        Stream.mapEffect(stream, topicItem => Effect.sync(() => {
+          try {
+            const decoded = decodeCommandPrime(topicItem.command, getIdStringSchema(), commandSchema);
+            return { TAG: "Some", _0: { command: decoded, reference: topicItem.reference } };
+          } catch (_) {
+            return { TAG: "None", _0: 0 };
+          }
+        })),
+        opt => opt.TAG === "Some" ? Stream.make(opt._0) : Stream.empty
+      );
+      // Positional args match StateChangeSlice_Callback.res's compiled signature:
+      // (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, dcbEventLog, stream).
+      return sliceCallback.handleCommands(
+        tagKeysByEventType,
+        crossPartitionTagKeys,
+        sharedDcbEventLogOps,
+        decodedStream,
+      );
+    };
+
+    typeNames.forEach(typeName => {
+      handlersByType[typeName] = jsonHandler;
+    });
+  });
+
+  // Composite handler used by Route 2 (SQS event source) AND inline dispatch
+  // for Route 1 sync mode. Routes each item to the slice handler matching its
+  // command TAG; unknown TAGs are dropped with a warning.
+  const compositeJsonCommandsHandler = stream => Effect.map(
+    Stream.runCollect(
+      Stream.mapEffect(stream, topicItem => {
+        const typeNameOpt = extractTypeName(topicItem.command);
+        if (typeNameOpt !== undefined) {
+          const sliceHandler = handlersByType[typeNameOpt];
+          if (sliceHandler !== undefined) {
+            return sliceHandler(Stream.make(topicItem));
+          } else {
+            log.warn("no handler for command type: " + typeNameOpt, { comp: "DcbCommandTopicRuntime" });
+            return Effect.succeed([]);
+          }
+        }
+        log.warn("could not extract command type", { comp: "DcbCommandTopicRuntime" });
+        return Effect.succeed([]);
+      })
+    ),
+    chunk => Chunk.toReadonlyArray(chunk).flat()
+  );
+
+  const resolvedQueue = makeQueueRef(config.queueUrl);
+  const sqsHandler = handleQueueEvent(resolvedQueue, compositeJsonCommandsHandler);
+  const publishJsons = sqsPublishJsons(resolvedQueue, "SQS_FIFO");
+
+  // Sync (default): inline-dispatch the command via the same composite handler
+  // that Route 2 uses, so the AppSync resolver gets a typed Accepted/Rejected
+  // outcome. Async: undefined → makeGenerateCommand falls back to publishJsons
+  // and returns Pending. The schema is permissive (S.json) because AppSync has
+  // already validated input against the SDL — per-slice schemas reapply inside
+  // the slice handlers via decodeCommandPrime.
+  const publishJsonsAndWait = DISPATCH_MODE === "async"
+    ? undefined
+    : (jsons) => runInlineAndCollect(jsons, compositeJsonCommandsHandler);
+
+  // Positional args match CommandGenerator_Callback.makeGenerateCommand's
+  // ReScript-compiled signature: (publishJsons, publishJsonsAndWait,
+  // serviceName, commandSchema, componentKind, stripIdFromParams).
+  // stripIdFromParams=false: DCB slices may declare a literal `id` field as part
+  // of the command schema (composite partition keys etc.) — don't strip it.
+  const generateCommand = makeGenerateCommand(
+    publishJsons,
+    publishJsonsAndWait,
+    config.pluginName,
+    jsonSchema,
+    "StateChangeSlice",
+    false,
+  );
+
+  const cmdGenHandler = (event) => {
+    // CommandGenerator.meta declares ip as array<string> (X-Forwarded-For chain).
+    // AppSync sends a single string or null from identity.sourceIp.
+    const rawIp = event.meta && event.meta.ip;
+    const ip = rawIp == null ? [] : Array.isArray(rawIp) ? rawIp : [rawIp];
+    const meta = { ...event.meta, ip };
+    const identity = (event.identity != null && typeof event.identity === 'object')
+      ? event.identity
+      : {
+          userId: (event.meta && event.meta.user) ?? "anonymous",
+          username: (event.meta && event.meta.user) ?? "anonymous",
+          groups: [],
+          provider: { TAG: "Custom", _0: "aws" },
+        };
+    return generateCommand({ ...event, meta, identity });
+  };
+
+  return [sqsHandler, cmdGenHandler];
+}
+
+async function buildHandler() {
+  const configStr = process.env["HANDLER_CONFIG"];
+  // Importing this module without HANDLER_CONFIG (e.g. from a test that drives
+  // `buildHandlersForConfig` directly) must not crash module evaluation.
+  // Lambda always sets HANDLER_CONFIG; the production path is unchanged.
+  if (!configStr) return [null, null];
+  const config = JSON.parse(configStr);
+  return buildHandlersForConfig(config, { loadModule: dynamicImport });
+}
+
+const initPromise = buildHandler();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const [sqsHandler, cmdGenHandler] = await initPromise;
+
+  // Route 1: AppSync direct invocation — payload carries the CommandGenerator.payload
+  // shape (`{command, arguments, meta, identity?}`).
+  if (event.command != null && event.arguments != null) {
+    log.debug("AppSync direct invocation (" + DISPATCH_MODE + ")", { comp: "DcbCommandTopicRuntime" });
+    const outcome = await runEffect(undefined, cmdGenHandler(event));
+    return commandOutcomeToJson(outcome);
+  }
+
+  // Route 2: SQS CommandTopic events
+  const records = event.Records || [];
+  const correlationId = extractCorrelationId(records);
+  log.debug("processing " + records.length.toString() + " record(s)", { comp: "DcbCommandTopicRuntime" });
+  await runEffect(correlationId, sqsHandler(event, context));
+  return "";
+}