@reventlessdev/reventless-aws 3.0.0-alpha.232 → 3.0.0-alpha.234

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res

@@ -0,0 +1,206 @@
+// Typed cold-start core for the StateViewSlice Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// StateViewSliceEntryPoint.mjs keeps only the inherently-untyped seam — the
+// dynamic `import()` of spec/projection modules named in HANDLER_CONFIG and the
+// reads of their exports. HANDLER_CONFIG parsing (including the compact-v2
+// expansion), the QueryDb operation assembly, and the whole projection stream
+// pipeline (envelope decode → sury event parse → project → handleAction) live
+// here, fully type-checked; the QueryDb backend branch is shared with the
+// ReadModel entry point in ProjectionEntryPoint_Ops and the routed dispatch
+// boundary lives in StreamRoutedEntryPoint_Ops.
+
+type handlerEntry = {
+  specModule: string,
+  projectionModule: string,
+  queryDbTableName: string,
+  sourceUrn: string,
+  // B3.3: per-slice AppSync Events channel root (list field name). Present only
+  // for subscription-enabled (Stream) Postgres view slices.
+  stateTopicName: option<string>,
+  pgConnection: option<PgConnection.connectionConfig>,
+}
+
+// The builder writes `pgConnection` via PgConnection.connectionConfigToJson, so
+// the parsed object IS the record shape — cast at the documented JSON contract
+// (the AggregateEntryPoint_Ops.asConnectionConfig pattern).
+external asPgConnection: JSON.t => PgConnection.connectionConfig = "%identity"
+
+let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
+  obj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
+
+let pgConnectionOf = (obj: dict<JSON.t>): option<PgConnection.connectionConfig> =>
+  obj
+  ->Dict.get("pgConnection")
+  ->Option.filter(j => j != JSON.Null)
+  ->Option.map(asPgConnection)
+
+// HANDLER_CONFIG is emitted compact (StateViewSliceRuntime_Builder_Single) to
+// stay under AWS Lambda's 4KB env-var limit: a shared module-path `base`, a
+// shared `sourceUrn`, and a shared `pgConnection` are hoisted out (all of a
+// plugin's slices follow the platform backend toggle), and per-handler keys are
+// shortened to s/p/q/u/t. Expand back to the full handlerEntry shape. Legacy
+// full-key entries pass through with their own per-entry fields.
+let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
+  rawJson == ""
+    ? []
+    : {
+        let obj =
+          rawJson
+          ->JSON.parseOrThrow
+          ->JSON.Decode.object
+          ->Option.getOr(Dict.make())
+        let base = obj->strOf("base")->Option.getOr("")
+        let sharedUrn = obj->strOf("sourceUrn")->Option.getOr("")
+        let sharedPgConnection = obj->pgConnectionOf
+        obj
+        ->Dict.get("handlers")
+        ->Option.flatMap(JSON.Decode.array)
+        ->Option.getOr([])
+        ->Array.filterMap(item =>
+          item
+          ->JSON.Decode.object
+          ->Option.map(h =>
+            switch h->strOf("specModule") {
+            | Some(specModule) => {
+                specModule,
+                projectionModule: h->strOf("projectionModule")->Option.getOr(""),
+                queryDbTableName: h->strOf("queryDbTableName")->Option.getOr(""),
+                sourceUrn: h->strOf("sourceUrn")->Option.getOr(""),
+                stateTopicName: h->strOf("stateTopicName"),
+                pgConnection: h->pgConnectionOf,
+              }
+            | None => {
+                specModule: base ++ h->strOf("s")->Option.getOr(""),
+                projectionModule: base ++ h->strOf("p")->Option.getOr(""),
+                queryDbTableName: h->strOf("q")->Option.getOr(""),
+                sourceUrn: h->strOf("u")->Option.getOr(sharedUrn),
+                stateTopicName: h->strOf("t"),
+                pgConnection: sharedPgConnection,
+              }
+            }
+          )
+        )
+      }
+
+// ── Projection stream pipeline ──────────────────────────────────────────────
+
+// Events arrive as `{id, meta, recordedAt, event}` envelopes
+// (Util_DynamoDbStream_Runtime.buildJsonEvent' / PgChangeFeedRelay). Surface
+// `meta` + `recordedAt` to the projection as the `consumed` envelope;
+// `recordedAt` defaults to "" if a producer omitted it. `meta` is already
+// schema-shaped JSON written by the producer — cast at the documented contract
+// (absent maps to undefined, exactly what the former JS passed through).
+external asMeta: option<JSON.t> => Reventless.Message.meta = "%identity"
+
+type envelope<'event> = {
+  event: JSON.t,
+  meta: Reventless.Message.meta,
+  recordedAt: string,
+}
+
+let decodeEnvelope = (json: JSON.t): envelope<'event> => {
+  let fields = json->JSON.Decode.object
+  {
+    event: switch fields->Option.flatMap(f => f->Dict.get("event")) {
+    | Some(JSON.Null) | None => json
+    | Some(event) => event
+    },
+    meta: fields->Option.flatMap(f => f->Dict.get("meta"))->asMeta,
+    recordedAt: fields
+    ->Option.flatMap(f => f->Dict.get("recordedAt"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr(""),
+  }
+}
+
+let exnMessage = StreamRoutedEntryPoint_Ops.exnMessage
+
+// The typed core of buildJsonEventsHandler: decode each envelope, parse the
+// event against the slice's consumed-event schema, project, and run every
+// resulting action against the view table. A decode failure logs and yields no
+// actions (the batch continues — at-least-once delivery would otherwise wedge
+// the whole source on one malformed record).
+let makeJsonEventsHandler = (
+  ~sliceName: string,
+  ~eventSchema: S.t<'event>,
+  ~project: Reventless.StateViewSlice.consumed<'event> => array<
+    Reventless.Projection.action<string, JSON.t>,
+  >,
+  ~queryDbOps: ReventlessCore.QueryDb_Adapter.operations,
+  ~subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+): ReventlessCore.EventCollector.jsonEventsHandler =>
+  stream =>
+    stream
+    ->Stream.mapEffect(json =>
+      Effect.sync(() =>
+        try {
+          let {event, meta, recordedAt} = decodeEnvelope(json)
+          project({event: event->S.parseJsonOrThrow(eventSchema), meta, recordedAt})
+        } catch {
+        | exn =>
+          StreamRoutedEntryPoint_Ops.logError(
+            "failed to decode event",
+            {comp: "StateViewSliceRuntime", detail: exnMessage(exn)},
+          )
+          []
+        }
+      )
+    )
+    ->Stream.flatMap(actions => Stream.fromIterable(actions))
+    ->Stream.runForEach(action =>
+      // Thread the slice's `subIdConfig` (generated from `@subId`) so
+      // sub-id-dependent actions like `UpdateMultiState` can resolve the sort
+      // key. Dropping it here made every such action hit the
+      // `MissingSubIdConfig` guard and silently write nothing, while the
+      // test-harness callback path (which threads it) stayed green. `None` for
+      // slices without an `@subId` is correct — those never emit sub-id
+      // actions. `~comp` is the slice's spec name — attribution for
+      // Projection.handleAction's debug-lazy action log.
+      Effect.promise(() =>
+        ReventlessCore.Projection.handleAction(~comp=sliceName, action, queryDbOps, subIdConfig)
+      )->Effect.map(_ => ())
+    )
+
+// ── Handler assembly (called by the shell per HANDLER_CONFIG entry) ─────────
+// `sliceModules` types the shell's reads off the two dynamically imported
+// modules: the spec module exports `name` / `consumedEventSchema` / `config` /
+// `subIdConfig`; the `project` function lives in the sibling projection module
+// (`<Name>_Projection.res`).
+
+type sliceModules<'event> = {
+  name: string,
+  consumedEventSchema: S.t<'event>,
+  project: Reventless.StateViewSlice.consumed<'event> => array<
+    Reventless.Projection.action<string, JSON.t>,
+  >,
+  config: option<ProjectionEntryPoint_Ops.specConfig>,
+  subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+}
+
+let makeRegisteredHandler = (
+  entry: handlerEntry,
+  modules: sliceModules<'event>,
+): StreamRoutedEntryPoint_Ops.registeredHandler => {
+  let queryDbOps = ProjectionEntryPoint_Ops.makeQueryDbOps(
+    ~queryDbTableName=entry.queryDbTableName,
+    ~pgConnection=entry.pgConnection,
+    ~stateTopicName=entry.stateTopicName,
+    ~indexes=ProjectionEntryPoint_Ops.indexesOf(modules.config),
+    ~subIdField=ProjectionEntryPoint_Ops.subIdFieldOf(modules.subIdConfig),
+  )
+  {
+    handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
+      makeJsonEventsHandler(
+        ~sliceName=modules.name,
+        ~eventSchema=modules.consumedEventSchema,
+        ~project=modules.project,
+        ~queryDbOps,
+        ~subIdConfig=modules.subIdConfig,
+      ),
+    ),
+    // Matches the `StateViewSlice(<name>)` shape the rest of the framework
+    // logs under.
+    comp: `StateViewSlice(${modules.name})`,
+  }
+}

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

@@ -0,0 +1,105 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Projection$ReventlessCore from "@reventlessdev/reventless-core/src/Projection.res.mjs";
+import * as ProjectionEntryPoint_Ops$ReventlessAws from "./ProjectionEntryPoint_Ops.res.mjs";
+import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
+
+function strOf(obj, key) {
+  return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+}
+
+function pgConnectionOf(obj) {
+  return Stdlib_Option.map(Stdlib_Option.filter(obj["pgConnection"], j => j !== null), prim => prim);
+}
+
+function parseHandlerConfig(rawJson) {
+  if (rawJson === "") {
+    return [];
+  }
+  let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(rawJson)), {});
+  let base = Stdlib_Option.getOr(strOf(obj, "base"), "");
+  let sharedUrn = Stdlib_Option.getOr(strOf(obj, "sourceUrn"), "");
+  let sharedPgConnection = pgConnectionOf(obj);
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["handlers"], Stdlib_JSON.Decode.array), []), item => Stdlib_Option.map(Stdlib_JSON.Decode.object(item), h => {
+    let specModule = strOf(h, "specModule");
+    if (specModule !== undefined) {
+      return {
+        specModule: specModule,
+        projectionModule: Stdlib_Option.getOr(strOf(h, "projectionModule"), ""),
+        queryDbTableName: Stdlib_Option.getOr(strOf(h, "queryDbTableName"), ""),
+        sourceUrn: Stdlib_Option.getOr(strOf(h, "sourceUrn"), ""),
+        stateTopicName: strOf(h, "stateTopicName"),
+        pgConnection: pgConnectionOf(h)
+      };
+    } else {
+      return {
+        specModule: base + Stdlib_Option.getOr(strOf(h, "s"), ""),
+        projectionModule: base + Stdlib_Option.getOr(strOf(h, "p"), ""),
+        queryDbTableName: Stdlib_Option.getOr(strOf(h, "q"), ""),
+        sourceUrn: Stdlib_Option.getOr(strOf(h, "u"), sharedUrn),
+        stateTopicName: strOf(h, "t"),
+        pgConnection: sharedPgConnection
+      };
+    }
+  }));
+}
+
+function decodeEnvelope(json) {
+  let fields = Stdlib_JSON.Decode.object(json);
+  let event = Stdlib_Option.flatMap(fields, f => f["event"]);
+  let tmp;
+  tmp = event !== undefined && event !== null ? event : json;
+  return {
+    event: tmp,
+    meta: Stdlib_Option.flatMap(fields, f => f["meta"]),
+    recordedAt: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(fields, f => f["recordedAt"]), Stdlib_JSON.Decode.string), "")
+  };
+}
+
+function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subIdConfig) {
+  return stream => Stream.runForEach(Stream.flatMap(Stream.mapEffect(stream, json => Effect.sync(() => {
+    try {
+      let match = decodeEnvelope(json);
+      return project({
+        event: S.parseJsonOrThrow(match.event, eventSchema),
+        meta: match.meta,
+        recordedAt: match.recordedAt
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      StreamRoutedEntryPoint_Ops$ReventlessAws.logError("failed to decode event", {
+        comp: "StateViewSliceRuntime",
+        detail: StreamRoutedEntryPoint_Ops$ReventlessAws.exnMessage(exn)
+      });
+      return [];
+    }
+  })), actions => Stream.fromIterable(actions)), action => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(sliceName, action, queryDbOps, subIdConfig)), param => {}));
+}
+
+function makeRegisteredHandler(entry, modules) {
+  let queryDbOps = ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(modules.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(modules.subIdConfig));
+  return {
+    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeJsonEventsHandler(modules.name, modules.consumedEventSchema, modules.project, queryDbOps, modules.subIdConfig)),
+    comp: `StateViewSlice(` + modules.name + `)`
+  };
+}
+
+let exnMessage = StreamRoutedEntryPoint_Ops$ReventlessAws.exnMessage;
+
+export {
+  strOf,
+  pgConnectionOf,
+  parseHandlerConfig,
+  decodeEnvelope,
+  exnMessage,
+  makeJsonEventsHandler,
+  makeRegisteredHandler,
+}
+/* S Not a pure module */

package/src/adapter/Runtime/StreamRoutedEntryPoint_Ops.res

@@ -0,0 +1,156 @@
+// Typed routed dispatch boundary shared by the stream-routed Lambda entry
+// points (ReadModelEntryPoint.mjs, StateViewSliceEntryPoint.mjs,
+// AutomationSliceEntryPoint.mjs).
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// all three shells route DynamoDB-stream / SQS-feed records to per-source-URN
+// handler lists with per-handler log attribution — machinery the `.mjs` files
+// previously duplicated verbatim. It lives here so every co-hosted component
+// dispatches identically; the shells keep only their dynamic-import seams.
+//
+// Kept free of storage-backend imports (in particular the Postgres runtime,
+// which lives in ProjectionEntryPoint_Ops): the AutomationSlice Lambda routes
+// through this module but must not carry `pg`/PgRuntime in its cold-start
+// graph.
+//
+// Runtime-pure: no `open PulumiAws` values — Pulumi appears in type positions
+// only (erased).
+
+// ── Shim bindings (HandlerFactoryHelpers.mjs) ───────────────────────────────
+// The structured-log + Effect dispatch boundary shared by every deployed entry
+// point.
+
+type dispatchOpts = {
+  correlationId?: string,
+  causationId?: string,
+  comp?: string,
+  plugin?: string,
+  timestamp?: float,
+  retryCount?: int,
+  detail?: string,
+}
+
+@module("./HandlerFactoryHelpers.mjs")
+external setRequestId: string => unit = "setRequestId"
+@module("./HandlerFactoryHelpers.mjs")
+external runEffect: (Effect.t<'a, 'e, 'r>, dispatchOpts) => promise<unit> = "runEffect"
+@module("./HandlerFactoryHelpers.mjs")
+external extractMetaField: (
+  array<PulumiAws.Lambda.CallbackFunction.record>,
+  string,
+) => option<string> = "extractMetaField"
+@module("./HandlerFactoryHelpers.mjs")
+external extractSentTimestamp: array<PulumiAws.Lambda.CallbackFunction.record> => option<float> =
+  "extractSentTimestamp"
+@module("./HandlerFactoryHelpers.mjs")
+external extractRetryCount: array<PulumiAws.Lambda.CallbackFunction.record> => int =
+  "extractRetryCount"
+@module("./HandlerFactoryHelpers.mjs") @scope("log")
+external logDebug: (string, dispatchOpts) => unit = "debug"
+@module("./HandlerFactoryHelpers.mjs") @scope("log")
+external logWarn: (string, dispatchOpts) => unit = "warn"
+@module("./HandlerFactoryHelpers.mjs") @scope("log")
+external logError: (string, dispatchOpts) => unit = "error"
+
+let exnMessage = (exn: exn): string =>
+  exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown error")
+
+// ── Handler registry + routed dispatch boundary ─────────────────────────────
+
+type streamHandler = (
+  PulumiAws.Lambda.CallbackFunction.event,
+  PulumiAws.Lambda.context,
+) => Effect.t<unit, string, unit>
+
+// One Lambda hosts every component of its kind, so each handler carries the
+// comp of the component it runs (and, for read models, the owning plugin —
+// the shared Lambda's own name carries no single plugin identity).
+type registeredHandler = {
+  handler: streamHandler,
+  comp?: string,
+  plugin?: string,
+}
+
+let toStreamHandler = (
+  handleJsonEvents: ReventlessCore.EventCollector.jsonEventsHandler,
+): streamHandler =>
+  (event, context) =>
+    EventCollectorChannel_DynamoDbStream_Runtime.handleStreamEvent(handleJsonEvents, event, context)
+
+// Multiple components can share one source stream — e.g. every admin read
+// model (Plugins, PluginHistory, PlatformEventGraph, UIFragmentRegistry)
+// projects the Plugin aggregate's EventLog stream, and several automation
+// slices can react to the same DcbEventLog. Accumulate ALL handlers per source
+// URN; a plain `registry[urn] = handler` collapses them to one (whichever
+// async builder wins the Promise.all race), silently dropping the rest.
+let addToRegistry = (
+  registry: dict<array<registeredHandler>>,
+  sourceUrn: string,
+  handler: registeredHandler,
+) =>
+  switch registry->Dict.get(sourceUrn) {
+  | Some(handlers) => handlers->Array.push(handler)
+  | None => registry->Dict.set(sourceUrn, [handler])
+  }
+
+let groupBySource = (
+  records: array<PulumiAws.Lambda.CallbackFunction.record>,
+): dict<array<PulumiAws.Lambda.CallbackFunction.record>> => {
+  let grouped = Dict.make()
+  records->Array.forEach(record =>
+    switch grouped->Dict.get(record.eventSourceARN) {
+    | Some(existing) => existing->Array.push(record)
+    | None => grouped->Dict.set(record.eventSourceARN, [record])
+    }
+  )
+  grouped
+}
+
+// The exported Lambda handler: group the batch by source ARN and run every
+// handler registered for each source (independent storage, so concurrent is
+// safe). Each handler carries its own comp so the shared Lambda's log lines
+// stay separable per component.
+let makeRoutedHandler = (
+  ~comp: string,
+  registryPromise: promise<dict<array<registeredHandler>>>,
+) =>
+  async (event: PulumiAws.Lambda.CallbackFunction.event, context: PulumiAws.Lambda.context) => {
+    setRequestId(context.awsRequestId)
+    let registry = await registryPromise
+    let _ =
+      await groupBySource(event.records)
+      ->Dict.toArray
+      ->Array.map(async ((arn, subRecords)) =>
+        switch registry->Dict.get(arn)->Option.filter(hs => hs->Array.length > 0) {
+        | Some(streamHandlers) =>
+          logDebug(
+            `found ${streamHandlers->Array.length->Int.toString} handler(s) for ${arn}`,
+            {comp: comp},
+          )
+          let correlationId = extractMetaField(subRecords, "correlationId")
+          let causationId = extractMetaField(subRecords, "causationId")
+          let timestamp = extractSentTimestamp(subRecords)
+          let retryCount = extractRetryCount(subRecords)
+          let subEvent: PulumiAws.Lambda.CallbackFunction.event = {records: subRecords}
+          let _ =
+            await streamHandlers
+            ->Array.map(registered =>
+              runEffect(
+                registered.handler(subEvent, context),
+                {
+                  correlationId: ?correlationId,
+                  causationId: ?causationId,
+                  comp: ?registered.comp,
+                  plugin: ?registered.plugin,
+                  timestamp: ?timestamp,
+                  retryCount,
+                },
+              )
+            )
+            ->Promise.all
+        | None => logWarn("no handler found: " ++ arn, {comp: comp})
+        }
+      )
+      ->Promise.all
+    ""
+  }

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

@@ -0,0 +1,123 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
+import * as EventCollectorChannel_DynamoDbStream_Runtime$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+
+function setRequestId(prim) {
+  HandlerFactoryHelpersMjs.setRequestId(prim);
+}
+
+function runEffect(prim0, prim1) {
+  return HandlerFactoryHelpersMjs.runEffect(prim0, prim1);
+}
+
+function extractMetaField(prim0, prim1) {
+  return HandlerFactoryHelpersMjs.extractMetaField(prim0, prim1);
+}
+
+function extractSentTimestamp(prim) {
+  return HandlerFactoryHelpersMjs.extractSentTimestamp(prim);
+}
+
+function extractRetryCount(prim) {
+  return HandlerFactoryHelpersMjs.extractRetryCount(prim);
+}
+
+function logDebug(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.debug(prim0, prim1);
+}
+
+function logWarn(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.warn(prim0, prim1);
+}
+
+function logError(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.error(prim0, prim1);
+}
+
+function exnMessage(exn) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
+}
+
+function toStreamHandler(handleJsonEvents) {
+  return (event, context) => EventCollectorChannel_DynamoDbStream_Runtime$ReventlessAws.handleStreamEvent(handleJsonEvents, event, context);
+}
+
+function addToRegistry(registry, sourceUrn, handler) {
+  let handlers = registry[sourceUrn];
+  if (handlers !== undefined) {
+    handlers.push(handler);
+  } else {
+    registry[sourceUrn] = [handler];
+  }
+}
+
+function groupBySource(records) {
+  let grouped = {};
+  records.forEach(record => {
+    let existing = grouped[record.eventSourceARN];
+    if (existing !== undefined) {
+      existing.push(record);
+    } else {
+      grouped[record.eventSourceARN] = [record];
+    }
+  });
+  return grouped;
+}
+
+function makeRoutedHandler(comp, registryPromise) {
+  return async (event, context) => {
+    HandlerFactoryHelpersMjs.setRequestId(context.awsRequestId);
+    let registry = await registryPromise;
+    await Promise.all(Object.entries(groupBySource(event.Records)).map(async param => {
+      let subRecords = param[1];
+      let arn = param[0];
+      let streamHandlers = Stdlib_Option.filter(registry[arn], hs => hs.length !== 0);
+      if (streamHandlers !== undefined) {
+        let prim0 = `found ` + streamHandlers.length.toString() + ` handler(s) for ` + arn;
+        HandlerFactoryHelpersMjs.log.debug(prim0, {
+          comp: comp
+        });
+        let correlationId = HandlerFactoryHelpersMjs.extractMetaField(subRecords, "correlationId");
+        let causationId = HandlerFactoryHelpersMjs.extractMetaField(subRecords, "causationId");
+        let timestamp = HandlerFactoryHelpersMjs.extractSentTimestamp(subRecords);
+        let retryCount = HandlerFactoryHelpersMjs.extractRetryCount(subRecords);
+        let subEvent = {
+          Records: subRecords
+        };
+        await Promise.all(streamHandlers.map(registered => HandlerFactoryHelpersMjs.runEffect(registered.handler(subEvent, context), {
+          correlationId: correlationId,
+          causationId: causationId,
+          comp: registered.comp,
+          plugin: registered.plugin,
+          timestamp: timestamp,
+          retryCount: retryCount
+        })));
+        return;
+      }
+      HandlerFactoryHelpersMjs.log.warn("no handler found: " + arn, {
+        comp: comp
+      });
+    }));
+    return "";
+  };
+}
+
+export {
+  setRequestId,
+  runEffect,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+  logDebug,
+  logWarn,
+  logError,
+  exnMessage,
+  toStreamHandler,
+  addToRegistry,
+  groupBySource,
+  makeRoutedHandler,
+}
+/* Stdlib_JsExn Not a pure module */