@reventlessdev/reventless-aws 3.0.0-alpha.167

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

@@ -0,0 +1,242 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.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 Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.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();
+
+function commonPrefix(strings) {
+  let first = strings[0];
+  if (first !== undefined) {
+    return Stdlib_Array.reduce(strings, first, (prefix, s) => {
+      let p = prefix;
+      while (p !== "" && !s.startsWith(p)) {
+        p = p.slice(0, p.length - 1 | 0);
+      };
+      return p;
+    });
+  } else {
+    return "";
+  }
+}
+
+let sliceInfos = {};
+
+function registerStateViewSlice(name, specModulePath, projectionModulePath, queryDbTableName, queryDbResourcesOpt) {
+  let queryDbResources = queryDbResourcesOpt !== undefined ? queryDbResourcesOpt : [];
+  sliceInfos[name] = {
+    specModulePath: specModulePath,
+    projectionModulePath: projectionModulePath,
+    queryDbTableName: queryDbTableName,
+    queryDbResources: queryDbResources
+  };
+}
+
+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("StateViewSliceRuntime_Builder_Single", undefined, `registered ` + eventCollectorName + ` for ` + parentName);
+}
+
+let finished = {
+  contents: false
+};
+
+function buildLambda(parent, handlerOutputs, packageDirs, channelSpecs, memorySizeOpt, timeoutOpt) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let opts_parent = parent;
+  let opts = {
+    parent: opts_parent
+  };
+  let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => {
+    let paths = [];
+    handlers.forEach(h => {
+      paths.push(h.specModule);
+      paths.push(h.projectionModule);
+    });
+    let base = commonPrefix(paths);
+    let baseLen = base.length;
+    let firstUrn = Stdlib_Option.map(handlers[0], h => h.sourceUrn);
+    let sharedUrn = handlers.every(h => Primitive_object.equal(h.sourceUrn, firstUrn)) ? Stdlib_Option.getOr(firstUrn, "") : "";
+    let entries = handlers.map(h => {
+      let s = Stdlib_Option.getOr(JSON.stringify(h.specModule.slice(baseLen, h.specModule.length)), `""`);
+      let p = Stdlib_Option.getOr(JSON.stringify(h.projectionModule.slice(baseLen, h.projectionModule.length)), `""`);
+      let q = Stdlib_Option.getOr(JSON.stringify(h.queryDbTableName), `""`);
+      if (sharedUrn !== "") {
+        return `{"s":` + s + `,"p":` + p + `,"q":` + q + `}`;
+      }
+      let u = Stdlib_Option.getOr(JSON.stringify(h.sourceUrn), `""`);
+      return `{"s":` + s + `,"p":` + p + `,"q":` + q + `,"u":` + u + `}`;
+    }).join(",");
+    let baseJson = Stdlib_Option.getOr(JSON.stringify(base), `""`);
+    let urnJson = Stdlib_Option.getOr(JSON.stringify(sharedUrn), `""`);
+    return `{"v":2,"base":` + baseJson + `,"sourceUrn":` + urnJson + `,"handlers":[` + entries + `]}`;
+  });
+  let envVars = {};
+  envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+  packageDirs["@reventlessdev/reventless-aws"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-aws");
+  packageDirs["@reventlessdev/reventless-core"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-core");
+  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs", packageDirs, undefined);
+  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllStateViewSlices", match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, opts);
+  EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllStateViewSlices", channelSpecs, runtime, opts);
+}
+
+function finishWithDcbEventLog(dcbEventLog) {
+  if (finished.contents) {
+    return;
+  }
+  let infoCount = Object.keys(sliceInfos).length;
+  if (infoCount > 0) {
+    let dcbResource = Component$ReventlessCore.toPulumiResource(dcbEventLog);
+    let parent = dcbResource.__parentResource;
+    if (parent !== undefined) {
+      let dcbOutputs = Component$ReventlessCore.outputs(dcbEventLog);
+      let eventTopics = Object.fromEntries([[
+          "DcbEventLog",
+          dcbOutputs.eventTopic
+        ]]);
+      let channel = EventCollectorChannel_DynamoDbStream$ReventlessAws.make("AllStateViewSlices", eventTopics, {
+        parent: parent
+      });
+      let handlerOutputs = [];
+      let packageDirs = {};
+      let allQueryDbResources = [];
+      Stdlib_Dict.forEachWithKey(sliceInfos, (info, _name) => {
+        info.queryDbResources.forEach(r => {
+          allQueryDbResources.push(r);
+        });
+        let specPkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+        packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+        let projectionPkg = Util_Bundle$ReventlessAws.extractPackageName(info.projectionModulePath);
+        packageDirs[projectionPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(projectionPkg);
+        let etResources = dcbOutputs.eventTopic.resources;
+        let sourceUrn = etResources[0];
+        let sourceUrn$1 = sourceUrn.urn;
+        let handlerJson = Pulumi.all([
+          info.queryDbTableName,
+          sourceUrn$1
+        ]).apply(param => ({
+          specModule: info.specModulePath,
+          projectionModule: info.projectionModulePath,
+          queryDbTableName: param[0],
+          sourceUrn: param[1]
+        }));
+        handlerOutputs.push(handlerJson);
+      });
+      buildLambda(parent, handlerOutputs, packageDirs, [{
+          channel: channel,
+          eventTopics: eventTopics,
+          resources: allQueryDbResources
+        }], undefined, undefined);
+    } else {
+      log.warn("StateViewSliceRuntime_Builder_Single", undefined, "finishWithDcbEventLog: DCB EventLog has no parent");
+    }
+  }
+  finished.contents = true;
+}
+
+function finish() {
+  if (finished.contents) {
+    return;
+  }
+  log.info("StateViewSliceRuntime_Builder_Single", undefined, `finish: ` + storedSpecs.length.toString() + ` storedSpecs, ` + Object.keys(sliceInfos).length.toString() + ` sliceInfos, grandParent=` + Stdlib_Option.getOr(Stdlib_Option.map(grandParent.contents, param => "Some"), "None"));
+  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 handlerOutputs = [];
+      let packageDirs = {};
+      storedSpecs.forEach(spec => {
+        let info = sliceInfos[spec.componentName];
+        if (info === undefined) {
+          return log.warn("StateViewSliceRuntime_Builder_Single", undefined, `no handler registered for ` + spec.componentName);
+        }
+        let specPkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+        packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+        let projectionPkg = Util_Bundle$ReventlessAws.extractPackageName(info.projectionModulePath);
+        packageDirs[projectionPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(projectionPkg);
+        let handlerJson = Pulumi.all([
+          info.queryDbTableName,
+          spec.sourceUrns
+        ]).apply(param => ({
+          specModule: info.specModulePath,
+          projectionModule: info.projectionModulePath,
+          queryDbTableName: param[0],
+          sourceUrn: param[1][0]
+        }));
+        handlerOutputs.push(handlerJson);
+      });
+      buildLambda(parent, handlerOutputs, packageDirs, storedSpecs.map(param => param.channelSpec), match[0], match[1]);
+    } else {
+      log.warn("StateViewSliceRuntime_Builder_Single", undefined, `finish: grandParent not set`);
+    }
+  }
+  finished.contents = true;
+}
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  commonPrefix,
+  sliceInfos,
+  registerStateViewSlice,
+  storedSpecs,
+  grandParent,
+  forEventCollector,
+  finished,
+  buildLambda,
+  finishWithDcbEventLog,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/TaskBucketEntryPoint.mjs

@@ -0,0 +1,150 @@
+// 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";
+
+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 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 "";
+  };
+}
+
+const initPromise = buildHandler();
+
+export async function handler(event, context) {
+  const s3Handler = await initPromise;
+  return await s3Handler(event, context);
+}

package/src/adapter/Runtime/TaskRuntime_Builder_PerBucket.res

@@ -0,0 +1,123 @@
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+module TaskBucket = TaskBucket.S3
+
+type context = PulumiAws.Lambda.context
+type callbackEvent = TaskBucket.callbackEvent
+type runtimeParts = Util.Lambda.runtimeParts
+
+let forBucketCallback = (
+  ~handler as _,
+  ~connect,
+  ~memorySize=4096,
+  ~timeout=600,
+  ~name,
+  ~callbackModulePath,
+  ~publishToAggregatesQueueUrls,
+  ~schedulerConfig: option<ReventlessCore.TaskRuntime_Builder.schedulerConfig>,
+  task: ReventlessCore.Task.component,
+) => {
+  let resource = task->ReventlessCore.Component.toPulumiResource
+  // `name` is the PascalCase bucket stem (empty for the default bucket); the
+  // SideEffectHandler Lambda for this task bucket reads `<Task><Bucket>SideEffectHandler`.
+  let fullName = resource.name->Option.getOr("UnnamedTask") ++ name ++ "SideEffectHandler"
+
+  let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+
+  // Build publishToAggregates env var mapping.
+  // Task Lambdas use PUBLISH_<Agg>_QUEUE_URL; Extension Point Lambdas use PTA_<Agg>_QUEUE_URL.
+  // The prefix difference is intentional — they are distinct feature areas with separate builders.
+  // Each entry point reads whichever prefix its own builder writes, so the two sets never clash.
+  let publishToAggregatesEnvVars: dict<string> = Dict.make()
+  publishToAggregatesQueueUrls->Dict.forEachWithKey((queueUrlOutput, aggName) => {
+    let envVar = `PUBLISH_${aggName}_QUEUE_URL`
+    envVars->Dict.set(envVar, queueUrlOutput->Pulumi.Output.asInput)
+    publishToAggregatesEnvVars->Dict.set(aggName, envVar)
+  })
+
+  // Build HANDLER_CONFIG JSON
+  let callbackModule =
+    callbackModulePath->JSON.stringifyAny->Option.getOr(`""`)
+  let publishToAggregatesJson =
+    publishToAggregatesEnvVars
+    ->Dict.toArray
+    ->Array.map(((aggName, envVar)) =>
+      `${aggName->JSON.stringifyAny->Option.getOr(`""`)}: ${envVar->JSON.stringifyAny->Option.getOr(`""`)}`
+    )
+    ->Array.join(",")
+
+  // Encode scheduler config (CloudWatch Events role + side-effect target queue)
+  // into HANDLER_CONFIG so the bundled Lambda can call PutRule/PutTargets at
+  // runtime. None for tasks without a side-effect handler.
+  let handlerConfigJson = switch schedulerConfig {
+  | None =>
+    `{"callbackModule":${callbackModule},"publishToAggregates":{${publishToAggregatesJson}}}`
+    ->Pulumi.Output.make
+  | Some({schedulerRoleUrn, targetUrn, targetName}) =>
+    envVars->Dict.set("SCHEDULER_ROLE_ARN", schedulerRoleUrn->Pulumi.Output.asInput)
+    envVars->Dict.set("SCHEDULER_TARGET_ARN", targetUrn->Pulumi.Output.asInput)
+    envVars->Dict.set("SCHEDULER_TARGET_NAME", targetName->Pulumi.Output.asInput)
+    `{"callbackModule":${callbackModule},"publishToAggregates":{${publishToAggregatesJson}},"scheduler":{"roleArnEnv":"SCHEDULER_ROLE_ARN","targetArnEnv":"SCHEDULER_TARGET_ARN","targetNameEnv":"SCHEDULER_TARGET_NAME"}}`
+    ->Pulumi.Output.make
+  }
+  envVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
+
+  // Build code asset
+  let packageDirs: dict<string> = Dict.make()
+  let pkg = Util_Bundle.extractPackageName(callbackModulePath)
+  packageDirs->Dict.set(pkg, Util_Bundle.resolvePackageRoot(pkg))
+
+  let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+    ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/TaskBucketEntryPoint.mjs",
+    ~packageDirs,
+  )
+
+  let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+    ~name=fullName,
+    ~code,
+    ~sourceCodeHash,
+    ~envVars,
+    ~memorySize,
+    ~timeout,
+    ~opts={Pulumi.ComponentResource.parent: resource},
+  )
+
+  // Grant the Task Lambda role permission to manage CloudWatch Events rules
+  // and pass the scheduler role to events. Only needed when a schedulerConfig
+  // is present (Tasks with side effects).
+  switch schedulerConfig {
+  | None => ()
+  | Some({schedulerRoleUrn}) =>
+    let lambdaRole = runtime.parts.lambdaRole
+    let _ = schedulerRoleUrn->Pulumi.Output.apply(arn => {
+      let _ = PulumiAws.IAM.RolePolicy.make(
+        ~name=`${fullName}SchedulerPolicy`,
+        ~args={
+          policy: PulumiAws.PolicyDocument.make(
+            ~id=`${fullName}SchedulerPolicy`,
+            ~statements=[
+              {
+                sid: "AllowCloudWatchEvents",
+                effect: Allow,
+                actions: Action("events:*"),
+                resources: AllResources,
+              },
+              {
+                sid: "AllowPassSchedulerRole",
+                effect: Allow,
+                actions: Action("iam:PassRole"),
+                resources: Resource(arn),
+              },
+            ],
+          )
+          ->PulumiAws.PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: lambdaRole.id->Pulumi.Output.asInput,
+        },
+      )
+    })
+  }
+
+  connect(~runtime)
+}
+
+let finish = () => ()

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

@@ -0,0 +1,74 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
+
+function forBucketCallback(param, connect, memorySizeOpt, timeoutOpt, name, callbackModulePath, publishToAggregatesQueueUrls, schedulerConfig, task) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 4096;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 600;
+  let resource = Component$ReventlessCore.toPulumiResource(task);
+  let fullName = Stdlib_Option.getOr(resource.__name, "UnnamedTask") + name + "SideEffectHandler";
+  let envVars = {};
+  let publishToAggregatesEnvVars = {};
+  Stdlib_Dict.forEachWithKey(publishToAggregatesQueueUrls, (queueUrlOutput, aggName) => {
+    let envVar = `PUBLISH_` + aggName + `_QUEUE_URL`;
+    envVars[envVar] = queueUrlOutput;
+    publishToAggregatesEnvVars[aggName] = envVar;
+  });
+  let callbackModule = Stdlib_Option.getOr(JSON.stringify(callbackModulePath), `""`);
+  let publishToAggregatesJson = Object.entries(publishToAggregatesEnvVars).map(param => Stdlib_Option.getOr(JSON.stringify(param[0]), `""`) + `: ` + Stdlib_Option.getOr(JSON.stringify(param[1]), `""`)).join(",");
+  let handlerConfigJson = schedulerConfig !== undefined ? (envVars["SCHEDULER_ROLE_ARN"] = schedulerConfig.schedulerRoleUrn, envVars["SCHEDULER_TARGET_ARN"] = schedulerConfig.targetUrn, envVars["SCHEDULER_TARGET_NAME"] = schedulerConfig.targetName, Pulumi.output(`{"callbackModule":` + callbackModule + `,"publishToAggregates":{` + publishToAggregatesJson + `},"scheduler":{"roleArnEnv":"SCHEDULER_ROLE_ARN","targetArnEnv":"SCHEDULER_TARGET_ARN","targetNameEnv":"SCHEDULER_TARGET_NAME"}}`)) : Pulumi.output(`{"callbackModule":` + callbackModule + `,"publishToAggregates":{` + publishToAggregatesJson + `}}`);
+  envVars["HANDLER_CONFIG"] = handlerConfigJson;
+  let packageDirs = {};
+  let pkg = Util_Bundle$ReventlessAws.extractPackageName(callbackModulePath);
+  packageDirs[pkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(pkg);
+  let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/TaskBucketEntryPoint.mjs", packageDirs, undefined);
+  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(fullName, match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, {
+    parent: resource
+  });
+  if (schedulerConfig !== undefined) {
+    let lambdaRole = runtime.parts.lambdaRole;
+    schedulerConfig.schedulerRoleUrn.apply(arn => {
+      new (Aws.iam.RolePolicy)(fullName + `SchedulerPolicy`, {
+        policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, fullName + `SchedulerPolicy`, [
+          {
+            Sid: "AllowCloudWatchEvents",
+            Effect: "Allow",
+            Action: "events:*",
+            Resource: "*"
+          },
+          {
+            Sid: "AllowPassSchedulerRole",
+            Effect: "Allow",
+            Action: "iam:PassRole",
+            Resource: arn
+          }
+        ])),
+        role: lambdaRole.id
+      });
+    });
+  }
+  return connect(runtime);
+}
+
+function finish() {
+  
+}
+
+let RuntimeEnvironment;
+
+let TaskBucket;
+
+export {
+  RuntimeEnvironment,
+  TaskBucket,
+  forBucketCallback,
+  finish,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/ScheduledPublisher/ScheduledPublisher.res

@@ -0,0 +1,2 @@
+module CloudWatchEvents = ScheduledPublisher_CloudWatchEvents
+module CloudWatchEvents_Runtime = ScheduledPublisher_CloudWatchEvents_Runtime

package/src/adapter/ScheduledPublisher/ScheduledPublisher.res.mjs

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

package/src/adapter/ScheduledPublisher/ScheduledPublisher_CloudWatchEvents.res

@@ -0,0 +1,54 @@
+let make: ReventlessCore.Scheduler_Adapter.scheduledPublisherMaker = (~name, ~opts) => {
+  let role = PulumiAws.IAM.Role.makeWithDefaultPolicy(
+    ~name="CloudWatchEventsRole",
+    ~servicePrincipal=AWS.CloudwatchEventRule.principal->Pulumi.Output.make,
+    ~opts,
+  )
+
+  let _policy = PulumiAws.IAM.Policy.make(
+    ~name=name ++ "CloudWatchEventsPolicy",
+    ~args={
+      PulumiAws.IAM.Policy.policy: role.arn
+      ->Pulumi.Output.apply(roleArn => {
+        open PulumiAws.PolicyDocument
+        PulumiAws.PolicyDocument.make(
+          ~id=name ++ "CloudWatchEventsPolicy",
+          ~statements=[
+            {
+              sid: "AllowCloudWatchEvents",
+              effect: Allow,
+              actions: Action("events:*"),
+              resources: AllResources,
+            },
+            {
+              sid: "AllowPassRole",
+              effect: Allow,
+              actions: Action("iam:PassRole"),
+              resources: Resource(`${roleArn}`),
+            },
+          ],
+        )->toJsonString
+      })
+      ->Pulumi.Output.asInput,
+    },
+    ~opts,
+  )
+
+  {
+    resource: ReventlessInfra.Adapter.make(
+      // urn carries the CloudWatch Events role ARN — bundled Lambdas read it
+      // via Scheduler.outputs.resource.urn to call PutRule with the right roleArn.
+      ~name=role.name,
+      ~id=role.id,
+      ~urn=role.arn,
+      ~service="CloudWatchEvents"->Pulumi.Output.make,
+      ~resourceType="aws:cloudwatch:EventRule"->Pulumi.Output.make,
+    ),
+    operations: role.arn->Pulumi.Output.apply(roleArn => (
+      {
+        createSchedule: ScheduledPublisher_CloudWatchEvents_Runtime.createSchedule(~roleArn),
+        deleteSchedule: ScheduledPublisher_CloudWatchEvents_Runtime.deleteSchedule,
+      }: ReventlessInfra.Scheduler.operations
+    )),
+  }
+}