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

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);
 }

package/src/adapter/Runtime/TaskBucketEntryPoint_Ops.res

@@ -0,0 +1,198 @@
+// Typed cold-start core for the TaskBucket Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// TaskBucketEntryPoint.mjs keeps only the inherently-untyped seam — the
+// dynamic `import()` of the task callback module named in HANDLER_CONFIG and
+// the read of its `callback` export. HANDLER_CONFIG parsing, the S3-event →
+// task-action dispatch (an exhaustive match over Reventless.Task.taskAction —
+// the former JS `switch (action.TAG)` with its unreachable "unknown TAG" arm), the
+// per-aggregate command publishing, and the CloudWatch Events scheduler ops
+// live here, fully type-checked.
+//
+// The former `.mjs` carried a hand-maintained mirror of
+// `toScheduleExpression` ("kept in sync manually"); typed code calls
+// ScheduledPublisher_CloudWatchEvents_Runtime directly — the layer ships it —
+// so the mirror is gone.
+
+@val @scope("process") external processEnv: dict<string> = "env"
+@module("./HandlerFactoryHelpers.mjs") @scope("log")
+external logWarn: (string, StreamRoutedEntryPoint_Ops.dispatchOpts) => unit = "warn"
+
+// ── HANDLER_CONFIG ──────────────────────────────────────────────────────────
+// Written by TaskRuntime_Builder_PerBucket.
+
+type schedulerEnvConfig = {
+  roleArnEnv: string,
+  targetArnEnv: string,
+  targetNameEnv: string,
+}
+type handlerConfig = {
+  callbackModule: string,
+  // aggregateName → env-var name holding the aggregate's cmd-topic SQS URL.
+  publishToAggregates: dict<string>,
+  scheduler: option<schedulerEnvConfig>,
+}
+
+let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
+  obj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
+
+let parseHandlerConfig = (rawJson: string): handlerConfig => {
+  let obj =
+    (rawJson == "" ? "{}" : rawJson)
+    ->JSON.parseOrThrow
+    ->JSON.Decode.object
+    ->Option.getOr(Dict.make())
+  {
+    callbackModule: obj->strOf("callbackModule")->Option.getOr(""),
+    publishToAggregates: obj
+    ->Dict.get("publishToAggregates")
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.getOr(Dict.make())
+    ->Dict.toArray
+    ->Array.filterMap(((k, v)) => v->JSON.Decode.string->Option.map(s => (k, s)))
+    ->Dict.fromArray,
+    scheduler: obj
+    ->Dict.get("scheduler")
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.map(s => {
+      roleArnEnv: s->strOf("roleArnEnv")->Option.getOr(""),
+      targetArnEnv: s->strOf("targetArnEnv")->Option.getOr(""),
+      targetNameEnv: s->strOf("targetNameEnv")->Option.getOr(""),
+    }),
+  }
+}
+
+// ── Command publishing ──────────────────────────────────────────────────────
+// aggregateName → publishJsons, resolving each queue URL via the env-var name
+// carried in HANDLER_CONFIG; entries with an unset or empty URL are skipped
+// (same as the former JS `if (queueUrl !== "")`).
+
+let buildPublishCommands = (map: dict<string>): dict<ReventlessCore.CommandTopic.publishJsons> =>
+  map
+  ->Dict.toArray
+  ->Array.filterMap(((aggName, envVarName)) =>
+    processEnv
+    ->Dict.get(envVarName)
+    ->Option.filter(queueUrl => queueUrl != "")
+    ->Option.map(queueUrl => {
+      let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+      (aggName, queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO))
+    })
+  )
+  ->Dict.fromArray
+
+// ── Scheduler ops (CloudWatch Events) ───────────────────────────────────────
+// Resolved lazily on the first schedule action (tasks without schedules never
+// touch the CloudWatch client) and cached for the container lifetime.
+
+type schedulerOps = {
+  createSchedule: Reventless.Schedule.schedule => promise<unit>,
+  deleteSchedule: string => promise<unit>,
+}
+
+let schedulerOpsCache: ref<option<schedulerOps>> = ref(None)
+
+let makeSchedulerOps = (config: option<schedulerEnvConfig>): option<schedulerOps> =>
+  switch (schedulerOpsCache.contents, config) {
+  | (Some(ops), _) => Some(ops)
+  | (None, None) => None
+  | (None, Some(cfg)) =>
+    switch (
+      processEnv->Dict.get(cfg.roleArnEnv),
+      processEnv->Dict.get(cfg.targetArnEnv),
+      processEnv->Dict.get(cfg.targetNameEnv),
+    ) {
+    | (Some(roleArn), Some(targetArn), Some(targetName))
+      if roleArn != "" && targetArn != "" && targetName != "" =>
+      // The single resolved resource the shared CloudWatch Events runtime
+      // targets: `urn` is the PutTargets ARN, `name` the target id.
+      let resources: array<ReventlessInfra.Adapter.resolvedResource> = [
+        {
+          name: targetName,
+          id: targetName,
+          urn: targetArn,
+          service: "unknown",
+          resourceInfo: ReventlessInfra.Adapter.NoInfo,
+          role: "",
+          region: "",
+          resourceType: "",
+          configuration: Dict.make(),
+          tags: Dict.make(),
+        },
+      ]
+      let ops = {
+        createSchedule: schedule =>
+          ScheduledPublisher_CloudWatchEvents_Runtime.createSchedule(~roleArn)(resources, schedule),
+        deleteSchedule: name =>
+          ScheduledPublisher_CloudWatchEvents_Runtime.deleteSchedule(resources, name),
+      }
+      schedulerOpsCache := Some(ops)
+      Some(ops)
+    | _ =>
+      logWarn("scheduler env vars missing — schedules will no-op", {comp: "TaskBucketRuntime"})
+      None
+    }
+  }
+
+// ── Task-action dispatch ────────────────────────────────────────────────────
+
+let dispatchTaskActions = async (
+  ~actions: array<Reventless.Task.taskAction>,
+  ~publishCommands: dict<ReventlessCore.CommandTopic.publishJsons>,
+  ~schedulerOps: unit => option<schedulerOps>,
+): unit => {
+  let _ =
+    await actions
+    ->Array.map(async action =>
+      switch action {
+      | Reventless.Task.PublishCommands(aggregateName, cmdJsons) =>
+        switch publishCommands->Dict.get(aggregateName) {
+        | Some(publish) => await publish(cmdJsons)
+        | None =>
+          logWarn(
+            `no publish function for aggregate "${aggregateName}"`,
+            {comp: "TaskBucketRuntime"},
+          )
+        }
+      | CreateSchedule(schedule) =>
+        switch schedulerOps() {
+        | Some(ops) => await ops.createSchedule(schedule)
+        | None =>
+          logWarn(
+            "CreateSchedule skipped — no scheduler configured for this Task (add sideEffects to setup)",
+            {comp: "TaskBucketRuntime"},
+          )
+        }
+      | DeleteSchedule(name) =>
+        switch schedulerOps() {
+        | Some(ops) => await ops.deleteSchedule(name)
+        | None =>
+          logWarn(
+            "DeleteSchedule skipped — no scheduler configured for this Task (add sideEffects to setup)",
+            {comp: "TaskBucketRuntime"},
+          )
+        }
+      }
+    )
+    ->Promise.all
+}
+
+// ── Exported Lambda handler ─────────────────────────────────────────────────
+// The shell reads `callback` off the dynamically imported task module and
+// hands it here; from this point everything is typed
+// (TaskBucket_S3_Runtime.handleBucketEvent decodes the S3 records and invokes
+// the callback per object).
+
+let makeHandler = (~callback: ReventlessCore.Task.bucketCallback, ~config: handlerConfig) => {
+  let handleEvents = TaskBucket_S3_Runtime.handleBucketEvent(callback)
+  let publishCommands = buildPublishCommands(config.publishToAggregates)
+  async (event: PulumiAws.S3.Bucket.event, context: PulumiAws.Lambda.context) => {
+    let actions = await handleEvents(event, context)
+    await dispatchTaskActions(
+      ~actions,
+      ~publishCommands,
+      ~schedulerOps=() => makeSchedulerOps(config.scheduler),
+    )
+    ""
+  }
+}

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

@@ -0,0 +1,155 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
+import * as TaskBucket_S3_Runtime$ReventlessAws from "../Task/TaskBucket_S3_Runtime.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws from "../ScheduledPublisher/ScheduledPublisher_CloudWatchEvents_Runtime.res.mjs";
+
+function logWarn(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.warn(prim0, prim1);
+}
+
+function strOf(obj, key) {
+  return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+}
+
+function parseHandlerConfig(rawJson) {
+  let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(rawJson === "" ? "{}" : rawJson)), {});
+  return {
+    callbackModule: Stdlib_Option.getOr(strOf(obj, "callbackModule"), ""),
+    publishToAggregates: Object.fromEntries(Stdlib_Array.filterMap(Object.entries(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["publishToAggregates"], Stdlib_JSON.Decode.object), {})), param => {
+      let k = param[0];
+      return Stdlib_Option.map(Stdlib_JSON.Decode.string(param[1]), s => [
+        k,
+        s
+      ]);
+    })),
+    scheduler: Stdlib_Option.map(Stdlib_Option.flatMap(obj["scheduler"], Stdlib_JSON.Decode.object), s => ({
+      roleArnEnv: Stdlib_Option.getOr(strOf(s, "roleArnEnv"), ""),
+      targetArnEnv: Stdlib_Option.getOr(strOf(s, "targetArnEnv"), ""),
+      targetNameEnv: Stdlib_Option.getOr(strOf(s, "targetNameEnv"), "")
+    }))
+  };
+}
+
+function buildPublishCommands(map) {
+  return Object.fromEntries(Stdlib_Array.filterMap(Object.entries(map), param => {
+    let aggName = param[0];
+    return Stdlib_Option.map(Stdlib_Option.filter(process.env[param[1]], queueUrl => queueUrl !== ""), queueUrl => {
+      let queue = {
+        id: queueUrl,
+        name: queueUrl,
+        arn: ""
+      };
+      return [
+        aggName,
+        CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO")
+      ];
+    });
+  }));
+}
+
+let schedulerOpsCache = {
+  contents: undefined
+};
+
+function makeSchedulerOps(config) {
+  let match = schedulerOpsCache.contents;
+  if (match !== undefined) {
+    return match;
+  }
+  if (config === undefined) {
+    return;
+  }
+  let match$1 = process.env[config.roleArnEnv];
+  let match$2 = process.env[config.targetArnEnv];
+  let match$3 = process.env[config.targetNameEnv];
+  if (match$1 !== undefined && match$2 !== undefined && match$3 !== undefined && match$1 !== "" && match$2 !== "" && match$3 !== "") {
+    let resources = [{
+        name: match$3,
+        id: match$3,
+        urn: match$2,
+        resourceInfo: "NoInfo",
+        service: "unknown",
+        role: "",
+        region: "",
+        resourceType: "",
+        configuration: {},
+        tags: {}
+      }];
+    let ops_createSchedule = schedule => ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws.createSchedule(match$1)(resources, schedule);
+    let ops_deleteSchedule = name => ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws.deleteSchedule(resources, name);
+    let ops = {
+      createSchedule: ops_createSchedule,
+      deleteSchedule: ops_deleteSchedule
+    };
+    schedulerOpsCache.contents = ops;
+    return ops;
+  }
+  HandlerFactoryHelpersMjs.log.warn("scheduler env vars missing — schedules will no-op", {
+    comp: "TaskBucketRuntime"
+  });
+}
+
+async function dispatchTaskActions(actions, publishCommands, schedulerOps) {
+  await Promise.all(actions.map(async action => {
+    switch (action.TAG) {
+      case "PublishCommands" :
+        let aggregateName = action._0;
+        let publish = publishCommands[aggregateName];
+        if (publish !== undefined) {
+          return await publish(action._1);
+        } else {
+          HandlerFactoryHelpersMjs.log.warn(`no publish function for aggregate "` + aggregateName + `"`, {
+            comp: "TaskBucketRuntime"
+          });
+          return;
+        }
+      case "CreateSchedule" :
+        let ops = schedulerOps();
+        if (ops !== undefined) {
+          return await ops.createSchedule(action._0);
+        } else {
+          HandlerFactoryHelpersMjs.log.warn("CreateSchedule skipped — no scheduler configured for this Task (add sideEffects to setup)", {
+            comp: "TaskBucketRuntime"
+          });
+          return;
+        }
+      case "DeleteSchedule" :
+        let ops$1 = schedulerOps();
+        if (ops$1 !== undefined) {
+          return await ops$1.deleteSchedule(action._0);
+        } else {
+          HandlerFactoryHelpersMjs.log.warn("DeleteSchedule skipped — no scheduler configured for this Task (add sideEffects to setup)", {
+            comp: "TaskBucketRuntime"
+          });
+          return;
+        }
+    }
+  }));
+}
+
+function makeHandler(callback, config) {
+  let handleEvents = TaskBucket_S3_Runtime$ReventlessAws.handleBucketEvent(callback);
+  let publishCommands = buildPublishCommands(config.publishToAggregates);
+  return async (event, context) => {
+    let actions = await handleEvents(event, context);
+    await dispatchTaskActions(actions, publishCommands, () => makeSchedulerOps(config.scheduler));
+    return "";
+  };
+}
+
+export {
+  logWarn,
+  strOf,
+  parseHandlerConfig,
+  buildPublishCommands,
+  schedulerOpsCache,
+  makeSchedulerOps,
+  dispatchTaskActions,
+  makeHandler,
+}
+/* ./HandlerFactoryHelpers.mjs Not a pure module */