@reventlessdev/reventless-aws 3.0.0-alpha.231 → 3.0.0-alpha.233

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 */

package/src/adapter/Runtime/TaskBucketEntryPoint.mjs

@@ -1,150 +1,30 @@
 // TaskBucket Lambda entry point.
-// At cold start: reads HANDLER_CONFIG, dynamically imports callback module,
-// wires TaskBucket_S3_Runtime.handleBucketEvent, dispatches task actions to SQS.
-
-import { makeQueueRef, log } from "./HandlerFactoryHelpers.mjs";
-import { handleBucketEvent } from "@reventlessdev/reventless-aws/src/adapter/Task/TaskBucket_S3_Runtime.res.mjs";
-import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
-import {
-  CloudWatchEventsClient,
-  PutRuleCommand,
-  PutTargetsCommand,
-  RemoveTargetsCommand,
-  DeleteRuleCommand,
-} from "@aws-sdk/client-cloudwatch-events";
+// At cold start: reads HANDLER_CONFIG, dynamically imports the task callback
+// module, and dispatches the resulting task actions (command publishing, CW
+// Events schedules).
+//
+// Thin untyped shell ("typed core, thin shell" —
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md): this file owns ONLY the
+// inherently-untyped seam — the dynamic `import()` of the callback module named
+// in HANDLER_CONFIG and the read of its `callback` export. Everything else
+// (HANDLER_CONFIG parsing, S3-event handling via TaskBucket_S3_Runtime, the
+// exhaustive task-action dispatch, per-aggregate command publishing, the
+// CloudWatch Events scheduler ops) lives type-checked in
+// TaskBucketEntryPoint_Ops.res.
+
+import * as Ops from "./TaskBucketEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
-// Mirrors ScheduledPublisher_CloudWatchEvents_Runtime.toScheduleExpression — kept
-// in sync manually because that runtime helper isn't bundled in this Lambda.
-function toScheduleExpression(rate) {
-  // rate is a serialized variant from Reventless.Schedule.rate
-  switch (rate.TAG) {
-    case "Single": {
-      const [year, month, day, hour, minute] = [rate._0, rate._1, rate._2, rate._3, rate._4];
-      return `cron(${minute} ${hour} ${day} ${month} ? ${year})`;
-    }
-    case "Minutes": {
-      const n = rate._0;
-      return `rate(${n} minute${n === 1 ? "" : "s"})`;
-    }
-    case "Hours": {
-      const n = rate._0;
-      return `rate(${n} hour${n === 1 ? "" : "s"})`;
-    }
-    case "Days": {
-      const n = rate._0;
-      return `rate(${n} day${n === 1 ? "" : "s"})`;
-    }
-    case "Daily":
-      return `cron(${rate._1} ${rate._0} * * * *)`;
-    case "Weekdays":
-      return `cron(${rate._1} ${rate._0} ? * MON-FRI *)`;
-    case "WeekdaysAndSaturday":
-      return `cron(${rate._1} ${rate._0} ? * MON-SAT *)`;
-    default:
-      throw new Error(`TaskBucketEntryPoint: unknown schedule rate ${JSON.stringify(rate)}`);
-  }
-}
-
-let cachedScheduler = null;
-function makeSchedulerOps(schedulerCfg) {
-  if (!schedulerCfg) return null;
-  if (cachedScheduler) return cachedScheduler;
-  const roleArn = process.env[schedulerCfg.roleArnEnv];
-  const targetArn = process.env[schedulerCfg.targetArnEnv];
-  const targetName = process.env[schedulerCfg.targetNameEnv];
-  if (!roleArn || !targetArn || !targetName) {
-    log.warn("scheduler env vars missing — schedules will no-op", { comp: "TaskBucketRuntime" });
-    return null;
-  }
-  const client = new CloudWatchEventsClient({});
-  cachedScheduler = {
-    createSchedule: async (schedule) => {
-      await client.send(new PutRuleCommand({
-        Name: schedule.name,
-        ScheduleExpression: toScheduleExpression(schedule.rate),
-        RoleArn: roleArn,
-        State: "ENABLED",
-      }));
-      await client.send(new PutTargetsCommand({
-        Rule: schedule.name,
-        Targets: [{ Arn: targetArn, Id: targetName, Input: schedule.payload }],
-      }));
-    },
-    deleteSchedule: async (name) => {
-      await client.send(new RemoveTargetsCommand({ Rule: name, Ids: [targetName] }));
-      await client.send(new DeleteRuleCommand({ Name: name }));
-    },
-  };
-  return cachedScheduler;
-}
-
 async function buildHandler() {
-  const configStr = process.env["HANDLER_CONFIG"] || "{}";
-  const config = JSON.parse(configStr);
-
+  const config = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "");
   const callbackModule = await dynamicImport(config.callbackModule);
-  const bucketCallback = callbackModule.callback;
-  const handleEvents = handleBucketEvent(bucketCallback);
-
-  // Build publishCommands dict from env var queue URLs. The deploy-side builder
-  // writes HANDLER_CONFIG.publishToAggregates as { aggregateName: envVarName }
-  // (see TaskRuntime_Builder_PerBucket.res), so iterate accordingly.
-  const publishCommandsFns = {};
-  for (const [aggName, envVarName] of Object.entries(config.publishToAggregates || {})) {
-    const queueUrl = process.env[envVarName] || "";
-    if (queueUrl !== "") {
-      publishCommandsFns[aggName] = sqsPublishJsons(makeQueueRef(queueUrl), "SQS_FIFO");
-    }
-  }
-
-  return async (event, _context) => {
-    const taskActions = await handleEvents(event, _context);
-
-    await Promise.all(taskActions.map(async action => {
-      switch (action.TAG) {
-        case "PublishCommands": {
-          const aggregateName = action._0;
-          const cmdJsons = action._1;
-          const pub = publishCommandsFns[aggregateName];
-          if (pub !== undefined) {
-            await pub(cmdJsons);
-          } else {
-            log.warn(`no publish function for aggregate "${aggregateName}"`, { comp: "TaskBucketRuntime" });
-          }
-          break;
-        }
-        case "CreateSchedule": {
-          const ops = makeSchedulerOps(config.scheduler);
-          if (ops) {
-            await ops.createSchedule(action._0);
-          } else {
-            log.warn("CreateSchedule skipped — no scheduler configured for this Task (add sideEffects to setup)", { comp: "TaskBucketRuntime" });
-          }
-          break;
-        }
-        case "DeleteSchedule": {
-          const ops = makeSchedulerOps(config.scheduler);
-          if (ops) {
-            await ops.deleteSchedule(action._0);
-          } else {
-            log.warn("DeleteSchedule skipped — no scheduler configured for this Task (add sideEffects to setup)", { comp: "TaskBucketRuntime" });
-          }
-          break;
-        }
-        default:
-          log.warn(`unknown task action TAG ${action.TAG}`, { comp: "TaskBucketRuntime" });
-      }
-    }));
-
-    return "";
-  };
+  return Ops.makeHandler(callbackModule.callback, config);
 }
 
 const initPromise = buildHandler();
 
 export async function handler(event, context) {
-  const s3Handler = await initPromise;
-  return await s3Handler(event, context);
+  const bucketHandler = await initPromise;
+  return await bucketHandler(event, context);
 }