@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/EventCollectorRuntime_Builder_PerEventCollector.res

@@ -0,0 +1,122 @@
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+type readModelInfo = {
+  specModulePath: string,
+  mappingsModulePath: string,
+  queryDbTableName: Pulumi.Output.t<string>,
+}
+
+let readModelInfos: dict<readModelInfo> = Dict.make()
+
+let registerReadModel = (
+  ~readModelName,
+  ~specModulePath,
+  ~mappingsModulePath,
+  ~queryDbTableName,
+) =>
+  readModelInfos->Dict.set(
+    readModelName,
+    {specModulePath, mappingsModulePath, queryDbTableName},
+  )
+
+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")
+
+    switch readModelInfos->Dict.get(parentName) {
+    | Some(info) =>
+      let sourceUrns =
+        (eventCollector->ReventlessCore.Component.outputs).resources
+        ->Array.map(({urn}) => urn)
+        ->Pulumi.Output.all
+
+      let name = eventCollectorResource.name->ReventlessCore.ComponentType.nameOpt(
+        ReventlessCore.EventCollector.componentType,
+      )
+      let opts = {Pulumi.ComponentResource.parent: eventCollectorResource}
+
+      // Build HANDLER_CONFIG with single handler
+      let specModule =
+        info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+      let mappingsModule =
+        info.mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
+
+      let handlerConfigOutput =
+        Pulumi.Output.all2((info.queryDbTableName, sourceUrns))
+        ->Pulumi.Output.apply(((tableName, urns)) => {
+          let sourceUrn = urns->Array.getUnsafe(0)
+          `{"handlers":[{"specModule":${specModule},"mappingsModule":${mappingsModule},"queryDbTableName":"${tableName}","sourceUrn":"${sourceUrn}"}]}`
+        })
+
+      let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+      envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+
+      // Collect user packages
+      let packageDirs: dict<string> = Dict.make()
+      let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+      let mappingsPkg = Util_Bundle.extractPackageName(info.mappingsModulePath)
+      packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+      packageDirs->Dict.set(mappingsPkg, Util_Bundle.resolvePackageRoot(mappingsPkg))
+
+      // Build AssetArchive: static re-export + user packages
+      let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+        ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/ReadModelEntryPoint.mjs",
+        ~packageDirs,
+      )
+
+      let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+        ~name,
+        ~code,
+        ~sourceCodeHash,
+        ~envVars,
+        ~memorySize,
+        ~timeout,
+        ~opts,
+      )
+
+      let _connectResources = EventCollectorChannel.connect(
+        ~name,
+        ~channelSpecs=[{channel, eventTopics, resources}],
+        ~runtime,
+        ~opts,
+      )
+    | None =>
+      log.warn(
+        ~comp="EventCollectorRuntime_Builder_PerEventCollector",
+        `no bundled info registered for ${parentName}`,
+      )
+    }
+  | None =>
+    JsError.throwWithMessage(
+      `forEventCollector(bundled): eventCollector ${eventCollectorName} has no parent`,
+    )
+  }
+}
+
+let finish = () => ()

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

@@ -0,0 +1,89 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.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 readModelInfos = {};
+
+function registerReadModel(readModelName, specModulePath, mappingsModulePath, queryDbTableName) {
+  readModelInfos[readModelName] = {
+    specModulePath: specModulePath,
+    mappingsModulePath: mappingsModulePath,
+    queryDbTableName: queryDbTableName
+  };
+}
+
+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(bundled): eventCollector ` + eventCollectorName + ` has no parent`);
+  }
+  let parentName = Stdlib_Option.getOr(parentResource.__name, "Unnamed");
+  let info = readModelInfos[parentName];
+  if (info === undefined) {
+    return log.warn("EventCollectorRuntime_Builder_PerEventCollector", undefined, `no bundled info registered for ` + parentName);
+  }
+  let sourceUrns = Pulumi.all(Component$ReventlessCore.outputs(eventCollector).resources.map(param => param.urn));
+  let name = ComponentType$ReventlessCore.nameOpt(eventCollectorResource.__name, EventCollector$ReventlessCore.componentType);
+  let opts_parent = eventCollectorResource;
+  let opts = {
+    parent: opts_parent
+  };
+  let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+  let mappingsModule = Stdlib_Option.getOr(JSON.stringify(info.mappingsModulePath), `""`);
+  let handlerConfigOutput = Pulumi.all([
+    info.queryDbTableName,
+    sourceUrns
+  ]).apply(param => {
+    let sourceUrn = param[1][0];
+    return `{"handlers":[{"specModule":` + specModule + `,"mappingsModule":` + mappingsModule + `,"queryDbTableName":"` + param[0] + `","sourceUrn":"` + sourceUrn + `"}]}`;
+  });
+  let envVars = {};
+  envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+  let packageDirs = {};
+  let specPkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+  let mappingsPkg = Util_Bundle$ReventlessAws.extractPackageName(info.mappingsModulePath);
+  packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+  packageDirs[mappingsPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(mappingsPkg);
+  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/ReadModelEntryPoint.mjs", packageDirs, undefined);
+  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, opts);
+  EventCollectorChannel_DynamoDbStream$ReventlessAws.connect(name, [{
+      channel: channel,
+      eventTopics: eventTopics,
+      resources: resources
+    }], runtime, opts);
+}
+
+function finish() {
+  
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  readModelInfos,
+  registerReadModel,
+  forEventCollector,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/EventCollectorRuntime_Builder_Single.res

@@ -0,0 +1,193 @@
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+type readModelInfo = {
+  specModulePath: string,
+  mappingsModulePath: string,
+  queryDbTableName: Pulumi.Output.t<string>,
+}
+
+let readModelInfos: dict<readModelInfo> = Dict.make()
+
+let registerReadModel = (
+  ~readModelName,
+  ~specModulePath,
+  ~mappingsModulePath,
+  ~queryDbTableName,
+) =>
+  readModelInfos->Dict.set(
+    readModelName,
+    {specModulePath, mappingsModulePath, 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="EventCollectorRuntime_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()
+
+        // Sort by componentName before serializing so the resulting
+        // HANDLER_CONFIG.handlers array is stable across deploys. Without
+        // this, the push order depends on platform-init order which can vary
+        // between Node.js runs, producing pointless Lambda env-var "updates"
+        // on every `pulumi up` even when nothing meaningful changed.
+        let sortedSpecs =
+          storedSpecs->Array.toSorted((a, b) => String.compare(a.componentName, b.componentName))
+
+        sortedSpecs->Array.forEach(spec => {
+          switch readModelInfos->Dict.get(spec.componentName) {
+          | Some(info) =>
+            // Collect unique user packages for the code asset
+            let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+            let mappingsPkg = Util_Bundle.extractPackageName(info.mappingsModulePath)
+            packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+            packageDirs->Dict.set(mappingsPkg, Util_Bundle.resolvePackageRoot(mappingsPkg))
+
+            let specModule =
+              info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let mappingsModule =
+              info.mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
+
+            let handlerJson =
+              Pulumi.Output.all2((info.queryDbTableName, spec.sourceUrns))
+              ->Pulumi.Output.apply(((tableName, urns)) => {
+                let sourceUrn = urns->Array.getUnsafe(0)
+                `{"specModule":${specModule},"mappingsModule":${mappingsModule},"queryDbTableName":"${tableName}","sourceUrn":"${sourceUrn}"}`
+              })
+            let _ = handlerOutputs->Array.push(handlerJson)
+          | None =>
+            log.warn(
+              ~comp="EventCollectorRuntime_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)
+
+        let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+          ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/ReadModelEntryPoint.mjs",
+          ~packageDirs,
+        )
+
+        let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+          ~name="AllReadModels",
+          ~code,
+          ~sourceCodeHash,
+          ~envVars,
+          ~memorySize=maxMemorySize,
+          ~timeout=maxTimeout,
+          ~opts,
+        )
+
+        let channelSpecs = storedSpecs->Array.map(({channelSpec}) => channelSpec)
+        let _connectResources = EventCollectorChannel.connect(
+          ~name="AllReadModels",
+          ~channelSpecs,
+          ~runtime,
+          ~opts,
+        )
+      | None =>
+        log.warn(
+          ~comp="EventCollectorRuntime_Builder_Single",
+          `finish: grandParent not set`,
+        )
+      }
+    }
+    finished := true
+  }

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

@@ -0,0 +1,137 @@
+// 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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.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 readModelInfos = {};
+
+function registerReadModel(readModelName, specModulePath, mappingsModulePath, queryDbTableName) {
+  readModelInfos[readModelName] = {
+    specModulePath: specModulePath,
+    mappingsModulePath: mappingsModulePath,
+    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("EventCollectorRuntime_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 sortedSpecs = storedSpecs.toSorted((a, b) => Primitive_string.compare(a.componentName, b.componentName));
+      sortedSpecs.forEach(spec => {
+        let info = readModelInfos[spec.componentName];
+        if (info === undefined) {
+          return log.warn("EventCollectorRuntime_Builder_Single", undefined, `no handler registered for ` + spec.componentName);
+        }
+        let specPkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+        let mappingsPkg = Util_Bundle$ReventlessAws.extractPackageName(info.mappingsModulePath);
+        packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+        packageDirs[mappingsPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(mappingsPkg);
+        let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+        let mappingsModule = Stdlib_Option.getOr(JSON.stringify(info.mappingsModulePath), `""`);
+        let handlerJson = Pulumi.all([
+          info.queryDbTableName,
+          spec.sourceUrns
+        ]).apply(param => {
+          let sourceUrn = param[1][0];
+          return `{"specModule":` + specModule + `,"mappingsModule":` + mappingsModule + `,"queryDbTableName":"` + param[0] + `","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/ReadModelEntryPoint.mjs", packageDirs, undefined);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllReadModels", 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("AllReadModels", channelSpecs, runtime, opts);
+    } else {
+      log.warn("EventCollectorRuntime_Builder_Single", undefined, `finish: grandParent not set`);
+    }
+  }
+  finished.contents = true;
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  readModelInfos,
+  registerReadModel,
+  storedSpecs,
+  grandParent,
+  forEventCollector,
+  finished,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/EventMapperEntryPoint.mjs

@@ -0,0 +1,97 @@
+// EventMapper Lambda entry point (Micro mode).
+// At cold start: reads HANDLER_CONFIG, dynamically imports Target Spec and Mappings,
+// wires EventMapper_Callback.MakeCounterHandler + MakeEventCollectorHandler.
+
+import * as Effect from "effect/Effect";
+import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import { patchSpecId, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { MakeCounterHandler, MakeEventCollectorHandler } from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
+import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_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);
+
+// Patch Source.Id on each mapping
+function patchMappingsSourceIds(mappingsModule) {
+  return {
+    ...mappingsModule,
+    mappings: (mappingsModule.mappings || []).map((mapping) => ({
+      ...mapping,
+      Source: {
+        ...mapping.Source,
+        Id: mapping.Source.Id || IdString,
+      },
+    })),
+  };
+}
+
+// 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 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 patchedMappings = patchMappingsSourceIds(mappingsModule);
+
+  const publishJsons = sqsPublishJsons(makeQueueRef(config.queueUrl), "SQS_FIFO");
+  const queryEngine = {
+    query: async () => { log.error("queryEngine not available in bundled mode", { comp: "EventMapperEntryPoint" }); return []; },
+    get: async () => { log.error("queryEngine not available in bundled mode", { comp: "EventMapperEntryPoint" }); return undefined; },
+  };
+
+  const counterHandler = MakeCounterHandler(patchedTarget)(patchedMappings)({ publishJsons, queryEngine });
+  const noopAsync = async (_) => {};
+  const eventCollectorHandler = MakeEventCollectorHandler({
+    publishJsons,
+    count: noopAsync,
+    addToCounterTarget: noopAsync,
+    commonEventsHandler: counterHandler.commonEventsHandler,
+  });
+
+  return (event, context) => handleStreamEvent(eventCollectorHandler.handleJsonEvents, event, context);
+}
+
+const initPromise = buildHandler();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const streamHandler = await initPromise;
+  const records = event.Records || [];
+  const grouped = groupBySource(records);
+
+  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
+    log.debug("processing " + arn, { comp: "EventMapperRuntime" });
+    await runEffect(undefined, streamHandler({ Records: subRecords }, context));
+  }));
+
+  return "";
+}