@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/ReadModelEntryPoint.mjs

@@ -0,0 +1,143 @@
+// ReadModel Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports Spec/Mappings modules,
+// wires ReadModel_Callback.Make, builds handler map keyed by source URN.
+
+import * as Effect from "effect/Effect";
+import { patchSpecId, makeTableRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { Make as readModelCallbackMake } from "@reventlessdev/reventless-core/src/components/ReadModel/ReadModel_Callback.res.mjs";
+import { load as qdbLoad, loadStream as qdbLoadStream, save as qdbSave, saveBatch as qdbSaveBatch, count as qdbCount, $$delete as qdbDelete, deleteBatch as qdbDeleteBatch } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// Inject 'id' key into saved state objects
+function mkInjectIdSave(rawSave) {
+  return (id, state, saveMode, ttl) => {
+    const injected = (state && typeof state === "object" && !Array.isArray(state))
+      ? { ...state, id }
+      : state;
+    return rawSave(id, injected, saveMode, ttl);
+  };
+}
+
+function mkInjectIdSaveBatch(rawSaveBatch) {
+  return (items) =>
+    rawSaveBatch(items.map(([id, state, ttl]) => {
+      const injected = (state && typeof state === "object" && !Array.isArray(state))
+        ? { ...state, id }
+        : state;
+      return [id, injected, ttl];
+    }));
+}
+
+// Fix mappings module: ensure it has a `mappings` array
+function fixMappingsModule(mod) {
+  if (mod.mappings) return mod;
+  const mappingValues = Object.values(mod).filter(
+    (v) => v && typeof v === "object" && "sourceName" in v && "map" in v
+  );
+  if (mappingValues.length > 0) {
+    return { ...mod, mappings: mappingValues };
+  }
+  return mod;
+}
+
+// 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 buildReadModelHandler(specModule, mappingsModule, queryDbTableName) {
+  const patchedSpec = patchSpecId(specModule);
+  const table = makeTableRef(queryDbTableName);
+  const rawSave = qdbSave(table);
+  const rawSaveBatch = qdbSaveBatch(table);
+
+  const operations = {
+    load: qdbLoad(table),
+    loadStream: qdbLoadStream(table),
+    save: mkInjectIdSave(rawSave),
+    saveBatch: mkInjectIdSaveBatch(rawSaveBatch),
+    count: qdbCount(table),
+    delete: qdbDelete(table),
+    deleteBatch: qdbDeleteBatch(table),
+  };
+
+  const effectiveMappings = fixMappingsModule(mappingsModule);
+  const callback = readModelCallbackMake(patchedSpec)(effectiveMappings)({
+    ReadModelSpec: patchedSpec,
+    operations,
+  });
+
+  return (event, context) => handleStreamEvent(callback.handleJsonEvents, event, context);
+}
+
+async function buildAllHandlers() {
+  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
+  const config = JSON.parse(configStr);
+  const handlers = {};
+
+  await Promise.all(config.handlers.map(async h => {
+    const specModule = await dynamicImport(h.specModule);
+    const mappingsModule = await dynamicImport(h.mappingsModule);
+    const handler = buildReadModelHandler(specModule, mappingsModule, h.queryDbTableName);
+    // Multiple read models can share one source stream — e.g. every admin read
+    // model (Plugins, PluginHistory, PlatformEventGraph, UIFragmentRegistry)
+    // projects the Plugin aggregate's EventLog stream. Accumulate ALL handlers
+    // per source ARN; a plain `handlers[urn] = handler` collapses them to one
+    // (whichever async builder wins the Promise.all race), silently dropping the
+    // rest — which leaves their QueryDbs empty.
+    (handlers[h.sourceUrn] ||= []).push(handler);
+  }));
+
+  return handlers;
+}
+
+const initPromise = buildAllHandlers();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const handlers = await initPromise;
+  const records = event.Records || [];
+  const grouped = groupBySource(records);
+
+  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
+    const streamHandlers = handlers[arn];
+    if (streamHandlers !== undefined && streamHandlers.length > 0) {
+      log.debug("found " + streamHandlers.length + " handler(s) for " + arn, { comp: "ReadModelRuntime" });
+      // Run every read model registered for this source stream (independent
+      // QueryDbs, so concurrent is safe).
+      await Promise.all(
+        streamHandlers.map(streamHandler =>
+          runEffect(undefined, streamHandler({ Records: subRecords }, context))
+        )
+      );
+    } else {
+      log.warn("no handler found: " + arn, { comp: "ReadModelRuntime" });
+    }
+  }));
+
+  return "";
+}

package/src/adapter/Runtime/RuntimeEnvironment.res

@@ -0,0 +1 @@
+module Lambda = RuntimeEnvironment_Lambda

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

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

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res

@@ -0,0 +1,254 @@
+type event = PulumiAws.Lambda.CallbackFunction.event
+type context = PulumiAws.Lambda.context
+type parts = Util.Lambda.runtimeParts
+
+// Generic env vars and IAM policies for all Lambdas created by makeFromCodeAsset.
+// Consumers register additional config before deployPlugin triggers builder finish().
+let additionalEnvVars: dict<Pulumi.Input.t<string>> = Dict.make()
+
+type iamPolicy = {
+  suffix: string,
+  actions: string,
+  resourceArn: Pulumi.Output.t<string>,
+}
+let additionalIamPolicies: array<iamPolicy> = []
+
+// Legacy CallbackFunction path — retained for module type compatibility.
+// Not called at runtime; all Lambda deployments now use makeFromCodeAsset.
+// Can be removed once the module type no longer requires environmentMaker.
+let make: ReventlessCore.Runtime.environmentMaker<'event, context, 'result, parts> = (
+  ~name,
+  ~handler,
+  ~memorySize: int=1024,
+  ~timeout: int=30,
+  ~opts=?,
+) => {
+  open PulumiAws
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+
+  let lambdaRole = IAM.Role.makeWithDefaultPolicy(
+    ~name,
+    ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
+    ~opts?,
+  )
+
+  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let lambda =
+    handler->Pulumi.Output.apply(handler =>
+      Lambda.CallbackFunction.make(
+        ~name,
+        ~args=Lambda.CallbackFunction.Args.make(
+          ~callback=handler,
+          ~role=lambdaRole,
+          ~memorySize=memorySize->Pulumi.Input.make,
+          ~timeout=timeout->Pulumi.Input.make,
+          ~tags,
+        ),
+        ~opts?,
+      )
+    )
+
+  // Coerce CallbackFunction.t → Function.t (structurally compatible: both have arn, id, name).
+  // This legacy path is only retained for module type compatibility.
+  let lambdaAsFunction: Pulumi.Output.t<PulumiAws.Lambda.Function.t> = lambda->Obj.magic
+
+  {
+    parts: {lambda: lambdaAsFunction, lambdaRole},
+    resources: [
+      lambdaAsFunction
+      ->Pulumi.Output.apply(lambda => lambda->Util.Lambda.toResource(~tags=tags->Pulumi.Output.fromInput))
+      ->ReventlessCore.Adapter.outputToResource,
+      Util_IAM_Role.toResource(lambdaRole),
+    ],
+  }
+}
+
+let makeFromCodeAsset: (
+  ~name: string,
+  ~code: Pulumi.Archive.t,
+  ~sourceCodeHash: string,
+  ~envVars: dict<Pulumi.Input.t<string>>=?,
+  ~memorySize: int=?,
+  ~timeout: int=?,
+  ~reservedConcurrency: int=?,
+  ~ephemeralStorageMb: int=?,
+  ~logRetentionDays: int=?,
+  /** Provision the DCB append-retry/conflict CloudWatch metric filters on this
+      Lambda's log group (command-handler Lambdas only). Requires a managed log
+      group, so it only takes effect when `~logRetentionDays` is also set. */
+  ~dcbMetrics: bool=?,
+  ~opts: Pulumi.ComponentResource.options=?,
+) => ReventlessCore.Runtime.environment<parts> = (
+  ~name,
+  ~code,
+  ~sourceCodeHash,
+  ~envVars=Dict.make(),
+  ~memorySize: int=ReventlessCore.Runtime.CommandHandlerDefaults.memorySize,
+  ~timeout: int=ReventlessCore.Runtime.CommandHandlerDefaults.timeout,
+  ~reservedConcurrency=?,
+  ~ephemeralStorageMb=?,
+  ~logRetentionDays=?,
+  ~dcbMetrics=false,
+  ~opts=?,
+) => {
+  open PulumiAws
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+
+  let lambdaRole = IAM.Role.makeWithDefaultPolicy(
+    ~name,
+    ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
+    ~opts?,
+  )
+
+  // Create additional IAM policies registered by consumers.
+  additionalIamPolicies->Array.forEach(({suffix, actions, resourceArn}) => {
+    let _ = resourceArn->Pulumi.Output.apply(arn => {
+      let _ = PulumiAws.IAM.RolePolicy.make(
+        ~name=`${name}${suffix}`,
+        ~args={
+          policy: PolicyDocument.make(
+            ~id=`${name}${suffix}Policy`,
+            ~statements=[
+              {
+                sid: `Allow${suffix}`,
+                effect: Allow,
+                actions: Action(actions),
+                resources: Resource(arn),
+              },
+            ],
+          )
+          ->PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: lambdaRole.id->Pulumi.Output.asInput,
+        },
+      )
+    })
+  })
+
+  let layers =
+    Lambda.reventlessLayerArn
+    ->Option.map(arn => [arn->Pulumi.Input.make])
+    ->Option.getOr([])
+    ->Pulumi.Input.make
+
+  let variables = Dict.fromArray([
+    ("Environment", Pulumi.Pulumi.getStackName()->Pulumi.Input.make),
+  ])
+  envVars->Dict.forEachWithKey((value, key) => {
+    variables->Dict.set(key, value)
+  })
+  additionalEnvVars->Dict.forEachWithKey((value, key) => {
+    variables->Dict.set(key, value)
+  })
+
+  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let lambda = Lambda.Function.make(
+    ~name,
+    ~args={
+      handler: "index.handler"->Pulumi.Input.make,
+      runtime: "nodejs22.x"->Pulumi.Input.make,
+      code: code->Pulumi.Input.make,
+      sourceCodeHash: sourceCodeHash->Pulumi.Input.make,
+      role: lambdaRole.arn->Pulumi.Output.asInput,
+      memorySize: memorySize->Pulumi.Input.make,
+      timeout: timeout->Pulumi.Input.make,
+      reservedConcurrentExecutions: ?reservedConcurrency->Option.map(Pulumi.Input.make),
+      ephemeralStorage: ?ephemeralStorageMb->Option.map(mb =>
+        ({size: mb->Pulumi.Input.make}: Lambda.Function.ephemeralStorage)->Pulumi.Input.make
+      ),
+      layers,
+      tags,
+      environment: ({Lambda.Function.variables: variables}: Lambda.Function.functionEnvironment)
+        ->Pulumi.Input.make,
+    },
+    ~opts?,
+  )
+
+  // Optional CloudWatch log-group with explicit retention. When not set, Lambda
+  // auto-creates a log group with no retention (logs accumulate indefinitely).
+  logRetentionDays->Option.forEach(days => {
+    let logGroup = Cloudwatch.LogGroup.make(
+      ~name=`${name}LogGroup`,
+      ~args={
+        name: `/aws/lambda/${name}`->Pulumi.Input.make,
+        retentionInDays: days->Pulumi.Input.make,
+      },
+      ~opts?,
+    )
+
+    // DCB command-handler Lambdas: extract the provider-neutral metric lines
+    // emitted by StateChangeSlice_Callback (`{reventlessMetric, slice, value}`)
+    // into CloudWatch metrics. Attached to the managed log group above so there
+    // is no race against Lambda's lazy auto-created group. Namespace/dimension
+    // are CloudWatch-specific and live here, not in core (provider-neutral).
+    if dcbMetrics {
+      ["AppendRetry", "AppendConflict"]->Array.forEach(metricName => {
+        let _ = Cloudwatch.LogMetricFilter.make(
+          ~name=`${name}${metricName}Filter`,
+          ~args={
+            pattern: `{ $.reventlessMetric = "${metricName}" }`->Pulumi.Input.make,
+            logGroupName: logGroup.name->Pulumi.Output.asInput,
+            metricTransformation: ({
+              name: metricName->Pulumi.Input.make,
+              namespace: "Reventless/DCB"->Pulumi.Input.make,
+              value: "$.value"->Pulumi.Input.make,
+              defaultValue: "0"->Pulumi.Input.make,
+              unit: "Count"->Pulumi.Input.make,
+              dimensions: Dict.fromArray([("slice", "$.slice")])->Pulumi.Input.make,
+            }: Cloudwatch.LogMetricFilter.metricTransformation)->Pulumi.Input.make,
+          },
+          ~opts?,
+        )
+      })
+    }
+  })
+
+  {
+    parts: {lambda: lambda->Pulumi.Output.make, lambdaRole},
+    resources: [
+      lambda->Util.Lambda.functionToResource(~tags=tags->Pulumi.Output.fromInput),
+      Util_IAM_Role.toResource(lambdaRole),
+    ],
+  }
+}
+
+let groupBySource = (event: event) => {
+  let dict: dict<event> = Dict.make()
+  event.records->Array.forEach(record => {
+    let eventSourceArn = record.eventSourceARN
+    let currentEvent = dict->Dict.get(eventSourceArn)->Option.getOr({records: []})
+    dict->Dict.set(eventSourceArn, {records: currentEvent.records->Array.concat([record])})
+  })
+  dict
+}
+
+// SQS records carry a `body` string field not included in the minimal record type.
+@get external recordBody: PulumiAws.Lambda.CallbackFunction.record => option<string> = "body"
+
+let extractCorrelationId = (event: event) =>
+  event.records
+  ->Array.get(0)
+  ->Option.flatMap(r =>
+    r
+    ->recordBody
+    ->Option.flatMap(body => {
+      try body->JSON.parseOrThrow->JSON.Decode.object catch {
+      | _ => None
+      }
+    })
+  )
+  ->Option.flatMap(obj => obj->Dict.get("meta"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(meta => meta->Dict.get("correlationId"))
+  ->Option.flatMap(JSON.Decode.string)
+
+external asEventHandler: 'a => ReventlessCore.Runtime.eventHandler<event, context, 'result> =
+  "%identity"
+external asEffectHandler: 'a => ReventlessCore.Runtime.effectHandler<
+  event,
+  context,
+  'result,
+  'error,
+> = "%identity"

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

@@ -0,0 +1,169 @@
+// 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_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Adapter.res.mjs";
+import * as Runtime$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/Runtime.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_Lambda$ReventlessAws from "../../util/Util_Lambda.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as Util_IAM_Role$ReventlessAws from "../../util/Util_IAM_Role.res.mjs";
+
+let additionalEnvVars = {};
+
+let additionalIamPolicies = [];
+
+function make(name, handler, memorySizeOpt, timeoutOpt, opts) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), opts$1);
+  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let lambda = handler.apply(handler => new (Aws.lambda.CallbackFunction)(name, Lambda$PulumiAws.CallbackFunction.Args.make(handler, lambdaRole, undefined, undefined, undefined, memorySize, timeout, undefined, undefined, undefined, tags, undefined), opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined));
+  return {
+    parts: {
+      lambda: lambda,
+      lambdaRole: lambdaRole
+    },
+    resources: [
+      Adapter$ReventlessCore.outputToResource(lambda.apply(lambda => Util_Lambda$ReventlessAws.toResource(tags, lambda))),
+      Util_IAM_Role$ReventlessAws.toResource(lambdaRole)
+    ]
+  };
+}
+
+function makeFromCodeAsset(name, code, sourceCodeHash, envVarsOpt, memorySizeOpt, timeoutOpt, reservedConcurrency, ephemeralStorageMb, logRetentionDays, dcbMetricsOpt, opts) {
+  let envVars = envVarsOpt !== undefined ? envVarsOpt : ({});
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : Runtime$ReventlessCore.CommandHandlerDefaults.memorySize;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : Runtime$ReventlessCore.CommandHandlerDefaults.timeout;
+  let dcbMetrics = dcbMetricsOpt !== undefined ? dcbMetricsOpt : false;
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), opts$1);
+  additionalIamPolicies.forEach(param => {
+    let actions = param.actions;
+    let suffix = param.suffix;
+    param.resourceArn.apply(arn => {
+      new (Aws.iam.RolePolicy)(name + suffix, {
+        policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + suffix + `Policy`, [{
+            Sid: `Allow` + suffix,
+            Effect: "Allow",
+            Action: actions,
+            Resource: arn
+          }])),
+        role: lambdaRole.id
+      });
+    });
+  });
+  let layers = Stdlib_Option.getOr(Stdlib_Option.map(Lambda$PulumiAws.reventlessLayerArn, arn => [arn]), []);
+  let variables = Object.fromEntries([[
+      "Environment",
+      Pulumi.getStack()
+    ]]);
+  Stdlib_Dict.forEachWithKey(envVars, (value, key) => {
+    variables[key] = value;
+  });
+  Stdlib_Dict.forEachWithKey(additionalEnvVars, (value, key) => {
+    variables[key] = value;
+  });
+  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let lambda = new (Aws.lambda.Function)(name, {
+    handler: "index.handler",
+    runtime: "nodejs22.x",
+    code: code,
+    role: lambdaRole.arn,
+    memorySize: memorySize,
+    timeout: timeout,
+    layers: layers,
+    tags: tags,
+    environment: {
+      variables: variables
+    },
+    sourceCodeHash: sourceCodeHash,
+    reservedConcurrentExecutions: Stdlib_Option.map(reservedConcurrency, prim => prim),
+    ephemeralStorage: Stdlib_Option.map(ephemeralStorageMb, mb => ({
+      size: mb
+    }))
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  Stdlib_Option.forEach(logRetentionDays, days => {
+    let logGroup = new (Aws.cloudwatch.LogGroup)(name + `LogGroup`, {
+      name: `/aws/lambda/` + name,
+      retentionInDays: days
+    }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+    if (dcbMetrics) {
+      [
+        "AppendRetry",
+        "AppendConflict"
+      ].forEach(metricName => {
+        new (Aws.cloudwatch.LogMetricFilter)(name + metricName + `Filter`, {
+          pattern: `{ $.reventlessMetric = "` + metricName + `" }`,
+          logGroupName: logGroup.name,
+          metricTransformation: {
+            name: metricName,
+            namespace: "Reventless/DCB",
+            value: "$.value",
+            defaultValue: "0",
+            unit: "Count",
+            dimensions: Object.fromEntries([[
+                "slice",
+                "$.slice"
+              ]])
+          }
+        }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+      });
+      return;
+    }
+  });
+  return {
+    parts: {
+      lambda: Pulumi.output(lambda),
+      lambdaRole: lambdaRole
+    },
+    resources: [
+      Util_Lambda$ReventlessAws.functionToResource(tags, lambda),
+      Util_IAM_Role$ReventlessAws.toResource(lambdaRole)
+    ]
+  };
+}
+
+function groupBySource(event) {
+  let dict = {};
+  event.Records.forEach(record => {
+    let eventSourceArn = record.eventSourceARN;
+    let currentEvent = Stdlib_Option.getOr(dict[eventSourceArn], {
+      Records: []
+    });
+    dict[eventSourceArn] = {
+      Records: currentEvent.Records.concat([record])
+    };
+  });
+  return dict;
+}
+
+function extractCorrelationId(event) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(event.Records[0], r => Stdlib_Option.flatMap(r.body, body => {
+    try {
+      return Stdlib_JSON.Decode.object(JSON.parse(body));
+    } catch (exn) {
+      return;
+    }
+  })), obj => obj["meta"]), Stdlib_JSON.Decode.object), meta => meta["correlationId"]), Stdlib_JSON.Decode.string);
+}
+
+export {
+  additionalEnvVars,
+  additionalIamPolicies,
+  make,
+  makeFromCodeAsset,
+  groupBySource,
+  extractCorrelationId,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/Runtime/SideEffectEntryPoint.mjs

@@ -0,0 +1,81 @@
+// SideEffectHandler Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports SideEffect modules,
+// wires SideEffectHandler_Callback.Make, builds handler map keyed by source URN.
+
+import * as Effect from "effect/Effect";
+import { log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { Make as sideEffectHandlerCallbackMake } from "@reventlessdev/reventless-core/src/components/SideEffectHandler/SideEffectHandler_Callback.res.mjs";
+import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// 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;
+}
+
+async function buildAllHandlers() {
+  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
+  const config = JSON.parse(configStr);
+  const handlers = {};
+
+  await Promise.all(config.handlers.map(async h => {
+    const sideEffectModules = await Promise.all(
+      h.sideEffectModules.map(async modPath => await dynamicImport(modPath))
+    );
+    const noOpQueryEngine = { scan: async () => [], query: async () => [] };
+    const callback = sideEffectHandlerCallbackMake({ sideEffects: sideEffectModules, queryEngine: noOpQueryEngine });
+    const handler = (event, context) => handleStreamEvent(callback.handleJsonEvents, event, context);
+    // Multiple side-effect handlers can share one source stream. Accumulate all
+    // per source ARN; a plain assignment collapses them to one (Promise.all
+    // race), silently dropping the rest.
+    (handlers[h.sourceUrn] ||= []).push(handler);
+  }));
+
+  return handlers;
+}
+
+const initPromise = buildAllHandlers();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const handlers = await initPromise;
+  const records = event.Records || [];
+  const grouped = groupBySource(records);
+
+  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
+    const streamHandlers = handlers[arn];
+    if (streamHandlers !== undefined && streamHandlers.length > 0) {
+      log.debug("found " + streamHandlers.length + " handler(s) for " + arn, { comp: "SideEffectRuntime" });
+      await Promise.all(streamHandlers.map(h =>
+        runEffect(undefined, h({ Records: subRecords }, context))
+      ));
+    } else {
+      log.warn("no handler found: " + arn, { comp: "SideEffectRuntime" });
+    }
+  }));
+
+  return "";
+}