@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -0,0 +1,134 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.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_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as Projection$ReventlessCore from "../../Projection.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as StateViewSlice$ReventlessCore from "./StateViewSlice.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "../QueryDb/QueryDb_Builder.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventCollector_Builder.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => {
+    let Make = Spec => (Projection => {
+      let moduleUrl = import.meta.url;
+      let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make({
+        Id: Id$Reventless.$$String,
+        name: Spec.name,
+        moduleUrl: moduleUrl,
+        stateSchema: Spec.stateSchema,
+        config: Spec.config,
+        subIdConfig: Spec.subIdConfig,
+        authorization: Spec.authorization,
+        visibility: Spec.visibility
+      })(QueryDbStorage)(QueryDbResolvers);
+      let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+      let toProjectionOps = ops => ({
+        load: id => ops.load(Id$Reventless.$$String.makeFromString(id)),
+        loadStream: id => ops.loadStream(Id$Reventless.$$String.makeFromString(id)),
+        save: (id, s, sm, ttl) => ops.save(Id$Reventless.$$String.makeFromString(id), s, sm, ttl),
+        saveBatch: batch => ops.saveBatch(batch.map(param => [
+          Id$Reventless.$$String.makeFromString(param[0]),
+          param[1],
+          param[2]
+        ])),
+        count: (id, f, n) => ops.count(Id$Reventless.$$String.makeFromString(id), f, n),
+        delete: (id, sub) => ops.delete(Id$Reventless.$$String.makeFromString(id), sub),
+        deleteBatch: ids => ops.deleteBatch(ids.map(param => [
+          Id$Reventless.$$String.makeFromString(param[0]),
+          param[1]
+        ]))
+      });
+      let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+      let make = (dcbEventLog, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(StateViewSlice$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+        let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts = {
+          parent: opts_parent
+        };
+        let queryDb = SpecificQueryDb.make(Api.api(), Api.apiRole(), undefined, opts);
+        let dcbEventTopicOutputs = Component$ReventlessCore.outputs(dcbEventLog).eventTopic;
+        let allEventTopics = Object.fromEntries([[
+            Spec.name,
+            dcbEventTopicOutputs
+          ]]);
+        let eventCollector = Component$ReventlessCore.operations(queryDb).apply(queryDbOps => {
+          let projectionOps = toProjectionOps(queryDbOps);
+          let ec = SpecificEventCollector.make(Spec.name, allEventTopics, opts);
+          let comp = `StateViewSlice(` + Spec.name + `)`;
+          let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(stream), events => {
+            let total = events.length.toString();
+            return Stdlib_Array.reduce(events.map((json, i) => {
+              let rawEvent = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["event"]), json);
+              let match = Message$ReventlessCore.splitMessage(rawEvent);
+              let dataDict = match[1];
+              let eventType = match[0];
+              let event = decoder.decode(eventType, dataDict);
+              if (event === undefined) {
+                return [];
+              }
+              let actions;
+              try {
+                actions = Projection.project(Primitive_option.valFromOption(event));
+              } catch (raw_exn) {
+                let exn = Primitive_exceptions.internalToException(raw_exn);
+                let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+                Effect.runSync(EffectLogger$ReventlessCore.logError(comp, undefined, `project failed for ` + eventType + `: ` + errMsg));
+                actions = [];
+              }
+              let idxStr = (i + 1 | 0).toString();
+              let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
+              let f = Object.entries(dataDict).map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
+              let fieldsStr = f === "" ? "" : `({` + f + `})`;
+              Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, dataDict, `handling event ` + idxStr + `/` + total + `: ` + LogFormat$ReventlessCore.bold(eventType) + fieldsStr + ` ` + actionsStr));
+              return actions;
+            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(action, projectionOps, Spec.subIdConfig)), param => {})));
+          });
+          let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
+          let resources = Component$ReventlessCore.outputs(queryDb).resources;
+          EventCollectorRuntimeBuilder.forEventCollector(handler, allEventTopics, resources, undefined, undefined, ec);
+          return ec;
+        });
+        Component$ReventlessCore.setOperations(extra, Output$Pulumi.flatMap(eventCollector, Component$ReventlessCore.operations).apply(param => ({
+          enqueueEvent: param.enqueueEvent
+        })));
+        let outputs_resources = dcbEventTopicOutputs.resources;
+        let outputs_queryDb = Component$ReventlessCore.outputs(queryDb);
+        let outputs = {
+          resources: outputs_resources,
+          queryDb: outputs_queryDb
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+      return {
+        Spec: Spec,
+        Projection: Projection,
+        make: make
+      };
+    });
+    return {
+      finish: EventCollectorRuntimeBuilder.finish,
+      Make: Make
+    };
+  }))));
+}
+
+let FrameworkProjection;
+
+export {
+  FrameworkProjection,
+  Make,
+}
+/* Stream Not a pure module */

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -0,0 +1,64 @@
+// Capture the framework's Projection module before the functor arg shadows it.
+module FrameworkProjection = Projection
+
+module type T = {
+  module Spec: Reventless.StateViewSlice.Spec
+  module Projection: Reventless.StateViewSlice.Projection with module Spec := Spec
+  type queryDbOperations
+
+  let eventsHandler: (
+    queryDbOperations,
+    array<ReventlessInfra.DcbEventLog.rawSequencedEvent>,
+  ) => promise<unit>
+}
+
+module Make = (
+  Spec: Reventless.StateViewSlice.Spec,
+  Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
+): (T with module Spec = Spec and module Projection := Projection) => {
+  module Spec = Spec
+  module Projection = Projection
+
+  type queryDbOperations = QueryDb.operations<string, Spec.state>
+
+  let comp = `StateViewSlice(${Spec.name})`
+  let decoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
+
+  let eventsHandler = async (
+    queryDbOps: queryDbOperations,
+    rawEvents: array<ReventlessInfra.DcbEventLog.rawSequencedEvent>,
+  ) => {
+    let count = rawEvents->Array.length->Int.toString
+    let idx = ref(0)
+    let allActions = []
+    let events = rawEvents->Array.filterMap(raw => {
+      let decoded = decoder.decode(
+        ~eventType=raw.eventType,
+        ~data=raw.data->JSON.Decode.object->Option.getOr(Dict.make()),
+      )
+      switch decoded {
+      | Some(event) =>
+        idx := idx.contents + 1
+        let id = raw.tags->Array.get(0)->Option.map(tag => tag.value)->Option.getOr("?")
+        let actions = Projection.project(event)
+        let actionsStr = LogFormat.actionNames(actions)
+        EffectLogger.logInfo(
+          ~comp,
+          ~detail=raw.data,
+          `handling event ${idx.contents->Int.toString}/${count}: ${LogFormat.bold(raw.eventType)}(${id}) ${actionsStr}`,
+        )->Effect.runSync
+        allActions->Array.pushMany(actions)
+        Some(event)
+      | None => None
+      }
+    })
+    let skipped = rawEvents->Array.length - events->Array.length
+    if skipped > 0 {
+      EffectLogger.logWarn(
+        ~comp,
+        `skipped=${skipped->Int.toString} events (decode mismatch)`,
+      )->Effect.runSync
+    }
+    await FrameworkProjection.handleActions(allActions, queryDbOps, Spec.subIdConfig)
+  }
+}

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -0,0 +1,56 @@
+// 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 Effect from "effect/Effect";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as Projection$ReventlessCore from "../../Projection.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+function Make(Spec) {
+  return Projection => {
+    let comp = `StateViewSlice(` + Spec.name + `)`;
+    let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+    let eventsHandler = async (queryDbOps, rawEvents) => {
+      let count = rawEvents.length.toString();
+      let idx = {
+        contents: 0
+      };
+      let allActions = [];
+      let events = Stdlib_Array.filterMap(rawEvents, raw => {
+        let decoded = decoder.decode(raw.eventType, Stdlib_Option.getOr(Stdlib_JSON.Decode.object(raw.data), {}));
+        if (decoded === undefined) {
+          return;
+        }
+        let event = Primitive_option.valFromOption(decoded);
+        idx.contents = idx.contents + 1 | 0;
+        let id = Stdlib_Option.getOr(Stdlib_Option.map(raw.tags[0], tag => tag.value), "?");
+        let actions = Projection.project(event);
+        let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
+        Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
+        allActions.push(...actions);
+        return Primitive_option.some(event);
+      });
+      let skipped = rawEvents.length - events.length | 0;
+      if (skipped > 0) {
+        Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `skipped=` + skipped.toString() + ` events (decode mismatch)`));
+      }
+      return await Projection$ReventlessCore.handleActions(allActions, queryDbOps, Spec.subIdConfig);
+    };
+    return {
+      Spec: Spec,
+      eventsHandler: eventsHandler
+    };
+  };
+}
+
+let FrameworkProjection;
+
+export {
+  FrameworkProjection,
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/components/Task/Task.res

@@ -0,0 +1,81 @@
+let componentType = ComponentType.Task
+
+type t
+type outputs = ReventlessInfra.Task.outputs
+
+type publishCommands = (/* ~aggregateName: */ string, array<Message.commandJson>) => promise<unit>
+type queryBucketName = ReventlessInfra.Task.queryBucketName
+
+type operations = ReventlessInfra.Task.operations
+type component = Component.t<t, outputs, operations>
+
+type taskAction = Reventless.Task.taskAction =
+  | PublishCommands(string, array<Message.commandJson>)
+  | CreateSchedule(Reventless.Schedule.schedule)
+  | DeleteSchedule(string)
+type bucketCallback = Reventless.Task.bucketCallback
+type bucketMode = Reventless.Task.bucketMode = Read | Write | ReadWrite
+type bucketSpec = Reventless.Task.bucketSpec
+type sideEffects = Reventless.Task.sideEffects
+type config = Reventless.Task.config
+type setup = ReventlessInfra.Task.setup
+
+module type Spec = ReventlessInfra.Task.Spec
+
+type maker = (
+  ~queryBucketName: queryBucketName,
+  ~scheduler: Scheduler.operations,
+  ~schedulerRoleUrn: Pulumi.Output.t<string>,
+  ~publishToAggregates: dict<CommandTopic.publishJsons>,
+  ~queryEngine: Reventless.QueryEngine.operations,
+  ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+  ~allAggregates: dict<Aggregate.outputs>,
+  ~opts: option<Pulumi.ComponentResource.options>,
+) => component
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.Task.resolvedOutputs> =>
+  switch (outputs.bucketNames, outputs.sideEffectSources) {
+  | (Some(bucketNames), Some(sideEffectSources)) =>
+    bucketNames
+    ->Dict.toArray
+    ->Array.map(((k, v)) => v->Pulumi.Output.apply(resolved => (k, resolved)))
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(pairs => {
+      let resolved: ReventlessInterop.Task.resolvedOutputs = {
+        name: outputs.name,
+        bucketNames: pairs->Dict.fromArray,
+        sideEffectSources,
+      }
+      resolved
+    })
+  | (Some(bucketNames), None) =>
+    bucketNames
+    ->Dict.toArray
+    ->Array.map(((k, v)) => v->Pulumi.Output.apply(resolved => (k, resolved)))
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(pairs => {
+      let resolved: ReventlessInterop.Task.resolvedOutputs = {
+        name: outputs.name,
+        bucketNames: pairs->Dict.fromArray,
+      }
+      resolved
+    })
+  | (None, Some(sideEffectSources)) =>
+    Pulumi.Output.make({
+      ReventlessInterop.Task.name: outputs.name,
+      sideEffectSources,
+    })
+  | (None, None) =>
+    Pulumi.Output.make({
+      ReventlessInterop.Task.name: outputs.name,
+    })
+  }
+
+module type T = {
+  module Spec: Spec
+  type component = Component.t<t, outputs, operations>
+  let make: maker
+  let outputs: component => outputs
+}

package/src/components/Task/Task.res.mjs

@@ -0,0 +1,51 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+
+function toResolvedOutputs(outputs) {
+  let match = outputs.bucketNames;
+  let match$1 = outputs.sideEffectSources;
+  if (match !== undefined) {
+    if (match$1 !== undefined) {
+      return Pulumi.all(Object.entries(match).map(param => {
+        let k = param[0];
+        return param[1].apply(resolved => [
+          k,
+          resolved
+        ]);
+      })).apply(pairs => ({
+        name: outputs.name,
+        bucketNames: Object.fromEntries(pairs),
+        sideEffectSources: match$1
+      }));
+    } else {
+      return Pulumi.all(Object.entries(match).map(param => {
+        let k = param[0];
+        return param[1].apply(resolved => [
+          k,
+          resolved
+        ]);
+      })).apply(pairs => ({
+        name: outputs.name,
+        bucketNames: Object.fromEntries(pairs)
+      }));
+    }
+  } else if (match$1 !== undefined) {
+    return Pulumi.output({
+      name: outputs.name,
+      sideEffectSources: match$1
+    });
+  } else {
+    return Pulumi.output({
+      name: outputs.name
+    });
+  }
+}
+
+let componentType = "Task";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/Task/Task_Adapter.res

@@ -0,0 +1,31 @@
+type bucket<'bucketParts> = {resources: array<ReventlessInfra.Adapter.resource>, parts: 'bucketParts}
+
+type connect<'bucketParts, 'runtimeParts> = (
+  ~name: string,
+  ~bucket: bucket<'bucketParts>,
+  ~bucketMode: Task.bucketMode,
+  ~commandTopics: Pulumi.Output.t<CommandTopic.allOutputs>,
+  ~runtime: Runtime.environment<'runtimeParts>,
+  ~opts: Pulumi.ComponentResource.options,
+) => unit // array<ReventlessInfra.Adapter.resource>
+
+type bucketMaker<'parts> = (
+  ~name: string,
+  ~opts: Pulumi.ComponentResource.options,
+) => bucket<'parts>
+
+module type Bucket = {
+  type runtimeParts
+  type callbackEvent
+  type context
+  type bucketParts
+
+  let connect: connect<bucketParts, runtimeParts>
+  let makeHandler: Task.bucketCallback => Runtime.eventHandler<
+    callbackEvent,
+    context,
+    array<Task.taskAction>,
+  >
+
+  let make: bucketMaker<bucketParts>
+}

package/src/components/Task/Task_Adapter.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/Task/Task_Builder.res

@@ -0,0 +1,223 @@
+let log = Logger.fromEnv()
+
+// PascalCase a (possibly kebab/snake-case) bucket id for use as a resource-name
+// segment: "product-imports" -> "ProductImports". The raw id stays the runtime
+// lookup key; only the emitted resource name is sanitized.
+let pascalCase = s =>
+  s
+  ->String.split("-")
+  ->Array.flatMap(p => p->String.split("_"))
+  ->Array.filter(p => p->String.length > 0)
+  ->Array.map(p =>
+    p->String.slice(~start=0, ~end=1)->String.toUpperCase ++
+      p->String.slice(~start=1, ~end=p->String.length)
+  )
+  ->Array.join("")
+
+module Make = (
+  Spec: Task.Spec,
+  RuntimeEnvironment: Runtime.Environment,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+    with module EventCollectorChannel = EventCollectorChannel,
+  TaskRuntimeBuilder: TaskRuntime_Builder.T with type runtimeParts = RuntimeEnvironment.parts,
+  TaskBucket: Task_Adapter.Bucket
+    with type runtimeParts = RuntimeEnvironment.parts
+    and type callbackEvent = TaskRuntimeBuilder.callbackEvent
+    and type runtimeParts = RuntimeEnvironment.parts
+    and type context = TaskRuntimeBuilder.context,
+  SpecificSideEffectHandler: SideEffectHandler.T,
+): Task.T => {
+  module Spec = Spec
+  type component = Task.component
+  // type handler = Runtime.eventHandler<
+  //   TaskRuntimeBuilder.callbackEvent,
+  //   TaskRuntimeBuilder.context,
+  //   array<Task.taskAction>,
+  // >
+
+  let construct = (
+    ~queryBucketName,
+    ~scheduler,
+    ~schedulerRoleUrn,
+    ~publishToAggregates,
+    ~queryEngine,
+    ~resourceNaming: ReventlessInfra.ResourceNaming.operations,
+    ~allAggregates,
+    self,
+    taskName,
+  ) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let allCommandTopics = allAggregates->Aggregate.allCommandTopics
+
+    // Each adapter chooses what string the Task runtime should treat as the
+    // publish address for a target aggregate. By convention we expose the
+    // first command-topic resource's `id` — bundled adapters interpret it as
+    // their channel address; adapters that don't need it (e.g. in-memory)
+    // ignore the dict in their TaskRuntime_Builder.
+    let publishToAggregatesQueueUrls =
+      allAggregates->Dict.mapValues(agg =>
+        agg.commandTopic->Pulumi.Output.flatMap(ct =>
+          switch ct.resources->Array.get(0) {
+          | Some(r) => r.id
+          | None => Pulumi.Output.make("")
+          }
+        )
+      )
+
+    let publishCommands: Task.publishCommands = (aggregateName, cmdJsons) => {
+      (publishToAggregates->Dict.get(aggregateName)->Option.getOrThrow)(cmdJsons)
+    }
+
+    let config = Spec.setup(queryEngine, queryBucketName, opts)
+
+    let sideEffectHandler =
+      config.sideEffects->Option.map(sideEffects =>
+        SpecificSideEffectHandler.make(
+          ~name=taskName,
+          ~sideEffects,
+          ~allEventTopics=allAggregates->Aggregate.allEventTopics,
+          ~allCommandTopics,
+          ~queryEngine,
+          ~scheduler,
+          ~resourceNaming,
+          ~opts,
+        )
+      )
+
+    let taskActionsHandler = (taskActions, operations: option<SideEffectHandler.operations>) => {
+      taskActions
+      ->Array.map(async taskAction => {
+        switch taskAction {
+        | Task.PublishCommands(aggregateName, cmdJsons) =>
+          await publishCommands(aggregateName, cmdJsons)
+        | CreateSchedule(schedule) =>
+          switch operations {
+          | Some(operations) => await operations.createSchedule(schedule)
+          | None => log.info(~comp="Task", "No SideEffectHandler to create schedule")
+          }
+        | DeleteSchedule(scheduleId) =>
+          switch operations {
+          | Some(operations) => await operations.deleteSchedule(scheduleId)
+          | None => log.info(~comp="Task", "No SideEffectHandler to delete schedule")
+          }
+        }
+      })
+      ->Promise.all
+      ->Util.Promise.toUnit
+    }
+
+    let createHandler = (sideEffectHandler, callback) => {
+      let handler = callback->TaskBucket.makeHandler
+      switch sideEffectHandler {
+      | Some(sideEffectHandler) =>
+        sideEffectHandler
+        ->Component.operations
+        ->Pulumi.Output.apply(operations =>
+          async (event, context) => {
+            let taskActions = await handler(event, context)
+            await taskActions->taskActionsHandler(Some(operations))
+          }
+        )
+      | None =>
+        (
+          async (event, context) => {
+            let taskActions = await handler(event, context)
+            await taskActions->taskActionsHandler(None)
+          }
+        )->Pulumi.Output.make
+      }
+    }
+
+    // Build schedulerConfig from the side-effect handler's collector channel
+    // — the resource scheduled events fire into — paired with the platform
+    // scheduler's invoker URN. Bundled adapters thread these into the
+    // deployed handler so it can talk to the underlying scheduler service;
+    // adapters without a real scheduler ignore the dict.
+    let schedulerConfig: option<TaskRuntime_Builder.schedulerConfig> =
+      sideEffectHandler->Option.flatMap(seh => {
+        let sehOutputs = seh->Component.outputs
+        sehOutputs.eventCollector.resources
+        ->Array.get(0)
+        ->Option.map(r => {
+          TaskRuntime_Builder.schedulerRoleUrn: schedulerRoleUrn,
+          targetUrn: r.urn,
+          targetName: r.name,
+        })
+      })
+
+    let bucketNames = config.buckets->Option.map(buckets =>
+      buckets
+      ->Array.map(bucketSpec => {
+        let bucketName = bucketSpec.bucketName->Option.getOr("Bucket")
+        // `bucketStem` is the PascalCase resource-name segment (empty for the
+        // default unnamed bucket so the name stays `<Task>Bucket`, not
+        // `<Task>BucketBucket`). `bucketName` above remains the runtime key.
+        let bucketStem = bucketSpec.bucketName->Option.mapOr("", pascalCase)
+        let name = taskName ++ bucketStem ++ "Bucket"
+        let bucket = TaskBucket.make(~name, ~opts)
+        let opts = {Pulumi.ComponentResource.parent: bucket.parts->Pulumi.Resource.makeFromJs}
+
+        bucketSpec.callback->Option.forEach(
+          callback =>
+            self->TaskRuntimeBuilder.forBucketCallback(
+              ~handler=sideEffectHandler->createHandler(callback),
+              ~connect=TaskBucket.connect(
+                ~name,
+                ~bucket,
+                ~bucketMode=bucketSpec.bucketMode,
+                ~commandTopics=allCommandTopics,
+                ~opts,
+                ...
+              ),
+              ~memorySize=4096,
+              ~timeout=600,
+              ~name=bucketStem,
+              ~callbackModulePath=Spec.moduleUrl,
+              ~publishToAggregatesQueueUrls,
+              ~schedulerConfig,
+            ),
+        )
+
+        (bucketName, (bucket.resources->Array.getUnsafe(0)).id)
+      })
+      ->Dict.fromArray
+    )
+
+    let sideEffectSources =
+      config.sideEffects->Option.map(sideEffect =>
+        sideEffect->Array.map((module(SideEffect)) => SideEffect.Source.name)
+      )
+
+    self->Component.setOutputs({name: taskName, ?bucketNames, ?sideEffectSources})
+  }
+
+  let make = (
+    ~queryBucketName,
+    ~scheduler,
+    ~schedulerRoleUrn,
+    ~publishToAggregates,
+    ~queryEngine,
+    ~resourceNaming,
+    ~allAggregates,
+    ~opts,
+  ) =>
+    Component.make(
+      ~componentType=Task.componentType->ComponentType.toString,
+      ~name=Spec.name,
+      ~construct=construct(
+        ~queryBucketName,
+        ~scheduler,
+        ~schedulerRoleUrn,
+        ~publishToAggregates,
+        ~queryEngine,
+        ~resourceNaming,
+        ~allAggregates,
+        ...
+      ),
+      ~opts,
+    )
+
+  let outputs = Component.outputs
+}