@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/adapter/Auth/Auth_Adapter.res

@@ -0,0 +1,42 @@
+// Provider-agnostic authentication adapter contract.
+//
+// `Provider` is implemented once per identity provider (in-memory headers,
+// AWS Cognito, future Auth0/AzureAD/ApiKey…). The runtime path —
+// `authenticate` — runs on every request and turns transport headers into
+// an `Identity.authResult`. The deploy-time path — `make` — provisions
+// whatever infrastructure the provider needs (a Cognito UserPool, a YAML
+// store path, an API-key table, …) and returns a provider-specific
+// `authConfig` for the rest of the platform stack to consume.
+
+/**
+Minimal transport-agnostic envelope handed to `authenticate`. Both GraphQL
+(graphql-yoga on the in-memory platform and AppSync resolver context on
+AWS) and MCP Streamable HTTP requests collapse into this shape so a single
+`Provider` implementation serves every entry point.
+*/
+type requestContext = {
+  headers: dict<string>,
+  sourceIp?: string,
+  correlationId?: string,
+  userAgent?: string,
+}
+
+module type Provider = {
+  /** Provider-specific deploy-time output (e.g. `{userPoolId, clientId}`
+      for Cognito, `{usersFilePath}` for in-memory). Consumed by the platform
+      stack to wire downstream resources such as the AppSync auth config. */
+  type authConfig
+
+  /** Read an identity (or anonymous / error) from a request. Pure
+      function from the provider's perspective: no side effects beyond
+      whatever HTTP fetches the provider issues (JWKS, etc.). */
+  let authenticate: requestContext => promise<Reventless.Identity.authResult>
+
+  /** Deploy-time: provision any infrastructure the provider depends on
+      and return its config. In-memory implementations return a constant
+      Output. */
+  let make: (
+    ~name: string,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => Pulumi.Output.t<authConfig>
+}

package/src/adapter/Auth/Auth_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/adapter/Runtime/AggregateRuntime_Builder.res

@@ -0,0 +1,22 @@
+module type T = {
+  type context
+  type runtimeParts
+  module CommandTopicChannel: CommandTopic_Adapter.Channel
+  module EventCollectorChannel: EventCollector_Adapter.Channel
+
+  let forCommandGenerator: Runtime.forComponent<
+    CommandGenerator.effectEventHandler<context>,
+    runtimeParts,
+    CommandGenerator.component,
+  >
+  let forCommandTopic: Runtime.forComponent<
+    Runtime.effectHandler<CommandTopicChannel.callbackEvent, context, unit, string>,
+    runtimeParts,
+    CommandTopic.component<'op>,
+  >
+  let forEventCollector: Runtime.forEventCollector<
+    Runtime.effectHandler<EventCollectorChannel.callbackEvent, context, unit, string>,
+    EventCollector.component,
+  >
+  let finish: unit => unit
+}

package/src/adapter/Runtime/AggregateRuntime_Builder.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/adapter/Runtime/AggregateRuntime_Builder_Common.res

@@ -0,0 +1,259 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  CommandTopicChannel: CommandTopic_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+) => {
+  let log = Logger.fromEnv()
+  type context = RuntimeEnvironment.context
+  type runtimeParts = RuntimeEnvironment.parts
+  module CommandTopicChannel = CommandTopicChannel
+  module EventCollectorChannel = EventCollectorChannel
+
+  type runtimeSpec = {
+    aggregate: Pulumi.Resource.t,
+    connects: array<Runtime.connect<runtimeParts>>,
+    eventCollectorChannelSpec: option<
+      EventCollector_Adapter.channelSpec<
+        EventCollectorChannel.callbackEvent,
+        context,
+        EventCollectorChannel.channelParts,
+      >,
+    >,
+    memorySize: int,
+    timeout: int,
+  }
+  type effectHandler = Runtime.effectHandler<RuntimeEnvironment.event, context, unit, string>
+
+  let runtimeSpecs: dict<runtimeSpec> = Dict.make()
+  let commandGeneratorHandlers: dict<CommandGenerator.effectEventHandler<context>> = Dict.make()
+  let commandTopicHandlers: dict<effectHandler> = Dict.make()
+  let eventCollectorHandlers: dict<array<effectHandler>> = Dict.make()
+
+  let runEffect = (~correlationId=?, effect) => {
+    let cid = correlationId->Option.getOr("unknown")
+    effect
+    // Annotate the request scope so every EffectLogger call inside the handler
+    // carries correlationId as a top-level JSON field (decoded in install()).
+    ->Effect.annotateLogs("correlationId", cid)
+    ->Effect.provideService(RequestContext.tag, RequestContext.test(~correlationId=cid))
+    ->Effect.runPromise
+  }
+
+  let aggregateHandler = aggregateName =>
+    async (event: RuntimeEnvironment.event, context) => {
+      let correlationId = event->RuntimeEnvironment.extractCorrelationId
+      let comp = `AggregateRuntime(${aggregateName})`
+      switch event->CommandGenerator.metaInfo {
+      | Some(info) =>
+        switch commandGeneratorHandlers->Dict.get(info) {
+        | Some(handler) =>
+          EffectLogger.logDebug(~comp, `found CommandGenerator handler for ${info}`)->Effect.runSync
+          let _ = await runEffect(~correlationId?, handler(event->CommandGenerator.asPayload, context))
+        | None =>
+          let available = commandGeneratorHandlers->Dict.keysToArray->Array.join(",")
+          EffectLogger.logWarn(
+            ~comp,
+            `no handler found: ${info} available=[${available}]`,
+          )->Effect.runSync
+        }
+      | _ =>
+        let _ = await event
+        ->RuntimeEnvironment.groupBySource
+        ->Dict.toArray
+        ->Array.map(async ((urn, event)) => {
+          switch commandTopicHandlers->Dict.get(urn) {
+          | Some(handler) =>
+            EffectLogger.logDebug(~comp, `found CommandTopic handler for ${urn}`)->Effect.runSync
+            await runEffect(~correlationId?, handler(event, context))
+          | None =>
+            switch eventCollectorHandlers->Dict.get(urn) {
+            | Some(handlers) =>
+              let count = handlers->Array.length->Int.toString
+              EffectLogger.logDebug(
+                ~comp,
+                `found ${count} EventCollector handler(s) for ${urn}`,
+              )->Effect.runSync
+              let _ = await handlers
+              ->Array.map(handler => runEffect(~correlationId?, handler(event, context)))
+              ->Promise.all
+            | None =>
+              let available =
+                Array.concat(
+                  commandTopicHandlers->Dict.keysToArray,
+                  eventCollectorHandlers->Dict.keysToArray,
+                )->Array.join(",")
+              EffectLogger.logWarn(
+                ~comp,
+                `no handler found: ${urn} available=[${available}]`,
+              )->Effect.runSync
+            }
+          }
+        })
+        ->Promise.all
+      }
+    }
+
+  let getRuntimeSpec = (aggregate: Pulumi.Resource.t) =>
+    runtimeSpecs
+    ->Dict.get(aggregate.name->Option.getOr("Unnamed"))
+    ->Option.getOr({
+      aggregate,
+      connects: [],
+      eventCollectorChannelSpec: None,
+      memorySize: 0,
+      timeout: 0,
+    })
+  let setRuntimeSpec = (aggregate: Pulumi.Resource.t, runtimeSpec) =>
+    runtimeSpecs->Dict.set(aggregate.name->Option.getOr("Unnamed"), runtimeSpec)
+
+  let registerRuntimeSpec = (~connect, ~memorySize, ~timeout, aggregate: Pulumi.Resource.t) => {
+    let spec = aggregate->getRuntimeSpec
+    aggregate->setRuntimeSpec({
+      ...spec,
+      connects: spec.connects->Array.concat([connect]),
+      memorySize: Math.Int.max(spec.memorySize, memorySize),
+      timeout: Math.Int.max(spec.timeout, timeout),
+    })
+  }
+
+  let registerEventCollectorRuntimeSpec = (
+    ~channel,
+    ~eventTopics,
+    ~resources,
+    ~memorySize,
+    ~timeout,
+    aggregate: Pulumi.Resource.t,
+  ) => {
+    let spec = aggregate->getRuntimeSpec
+    aggregate->setRuntimeSpec({
+      ...spec,
+      eventCollectorChannelSpec: Some({
+        channel,
+        eventTopics,
+        resources,
+      }),
+      memorySize: Math.Int.max(spec.memorySize, memorySize),
+      timeout: Math.Int.max(spec.timeout, timeout),
+    })
+  }
+
+  let forCommandGenerator = (
+    ~handler: Pulumi.Output.t<CommandGenerator.effectEventHandler<context>>,
+    ~connect,
+    ~memorySize=1024,
+    ~timeout=30,
+    commandGenerator: CommandGenerator.component,
+  ) => {
+    let commandGeneratorResource = commandGenerator->Component.toPulumiResource
+    let commandGeneratorName = commandGeneratorResource.name->Option.getOr("Unnamed")
+    switch commandGeneratorResource.parent {
+    | Some(aggregateResource) =>
+      aggregateResource->registerRuntimeSpec(~connect, ~memorySize, ~timeout)
+      let infos =
+        (commandGenerator->Component.outputs).resources
+        ->Array.map(resource => resource.resourceInfo)
+        ->Pulumi.Output.all
+      let _ =
+        (infos, handler)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((infos, handler)) => {
+          let infoStrs = infos->Array.filterMap(ri => switch ri {
+            | ReventlessInfra.Adapter.ApiResolver({typeName, fieldName}) => Some(`${typeName}.${fieldName}`)
+            | _ => None
+          })
+          log.debug(
+            ~comp="AggregateRuntime",
+            `forCommandGenerator ${commandGeneratorName}: set handler for ${infoStrs->Array.join(", ")}`,
+          )
+          infoStrs->Array.map(info => commandGeneratorHandlers->Dict.set(info, handler))
+        })
+
+    | None =>
+      JsError.throwWithMessage(
+        `forCommandGenerator: commandGenerator ${commandGeneratorName} has no Aggregate parent`,
+      )
+    }
+  }
+
+  let forCommandTopic = (
+    ~handler: Pulumi.Output.t<
+      Runtime.effectHandler<CommandTopicChannel.callbackEvent, context, unit, string>,
+    >,
+    ~connect,
+    ~memorySize=1024,
+    ~timeout=30,
+    commandTopic: CommandTopic.component<'op>,
+  ) => {
+    let commandTopicResource = commandTopic->Component.toPulumiResource
+    let commandTopicName = commandTopicResource.name->Option.getOr("Unnamed")
+    switch commandTopicResource.parent {
+    | Some(aggregateResource) =>
+      aggregateResource->registerRuntimeSpec(~connect, ~memorySize, ~timeout)
+      let urn = ((commandTopic->Component.outputs).resources->Array.getUnsafe(0)).urn
+      let _ =
+        (urn, handler)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((urn, handler)) => {
+          log.debug(
+            ~comp="AggregateRuntime",
+            `forCommandTopic ${commandTopicName}: set handler for ${urn}`,
+          )
+          commandTopicHandlers->Dict.set(urn, handler->RuntimeEnvironment.asEffectHandler)
+        })
+    | None =>
+      JsError.throwWithMessage(
+        `forCommandTopic: commandTopic ${commandTopicName} has no Aggregate parent`,
+      )
+    }
+  }
+  let forEventCollector = (
+    ~handler: Pulumi.Output.t<
+      Runtime.effectHandler<EventCollectorChannel.callbackEvent, context, unit, string>,
+    >,
+    ~eventTopics: EventTopic.allOutputs,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    ~memorySize=1024,
+    ~timeout=30,
+    eventCollector: EventCollector.component,
+  ) => {
+    let eventCollectorResource = eventCollector->Component.toPulumiResource
+    let eventCollectorName = eventCollectorResource.name->Option.getOr("Unnamed")
+    let channel = eventCollector->EventCollector_Adapter.channel
+    switch eventCollectorResource.parent->Option.flatMap(parent => parent.parent) {
+    | Some(aggregateResource) =>
+      aggregateResource->registerEventCollectorRuntimeSpec(
+        ~channel,
+        ~eventTopics,
+        ~resources,
+        ~memorySize,
+        ~timeout,
+      )
+      let urns =
+        (eventCollector->Component.outputs).resources
+        ->Array.map(({urn}) => urn)
+        ->Pulumi.Output.all
+      let _ =
+        (urns, handler)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply(((urns, handler)) => {
+          log.debug(
+            ~comp="AggregateRuntime",
+            `forEventCollector ${eventCollectorName}: set handler for ${urns->Array.join(", ")}`,
+          )
+          urns->Array.map(urn => {
+            let handlers = eventCollectorHandlers->Dict.get(urn)->Option.getOr([])
+            eventCollectorHandlers->Dict.set(
+              urn,
+              handlers->Array.concat([handler->RuntimeEnvironment.asEffectHandler]),
+            )
+          })
+        })
+    | None =>
+      JsError.throwWithMessage(
+        `forEventCollector: eventCollector ${eventCollectorName} has no Aggregate parent`,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,190 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Component$ReventlessCore from "../../components/Component.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as RequestContext$ReventlessCore from "../../RequestContext.res.mjs";
+import * as CommandGenerator$ReventlessCore from "../../components/CommandGenerator/CommandGenerator.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return CommandTopicChannel => (EventCollectorChannel => {
+    let log = Logger$ReventlessCore.fromEnv();
+    let runtimeSpecs = {};
+    let commandGeneratorHandlers = {};
+    let commandTopicHandlers = {};
+    let eventCollectorHandlers = {};
+    let runEffect = (correlationId, effect) => {
+      let cid = Stdlib_Option.getOr(correlationId, "unknown");
+      return Effect.runPromise(Effect.provideService(Effect.annotateLogs(effect, "correlationId", cid), RequestContext$ReventlessCore.tag, RequestContext$ReventlessCore.test(cid, undefined, undefined)));
+    };
+    let aggregateHandler = aggregateName => (async (event, context) => {
+      let correlationId = RuntimeEnvironment.extractCorrelationId(event);
+      let comp = `AggregateRuntime(` + aggregateName + `)`;
+      let info = CommandGenerator$ReventlessCore.metaInfo(event);
+      if (info !== undefined) {
+        let handler = commandGeneratorHandlers[info];
+        if (handler !== undefined) {
+          Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `found CommandGenerator handler for ` + info));
+          await runEffect(correlationId, handler(event, context));
+          return;
+        }
+        let available = Object.keys(commandGeneratorHandlers).join(",");
+        return Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `no handler found: ` + info + ` available=[` + available + `]`));
+      }
+      await Promise.all(Object.entries(RuntimeEnvironment.groupBySource(event)).map(async param => {
+        let event = param[1];
+        let urn = param[0];
+        let handler = commandTopicHandlers[urn];
+        if (handler !== undefined) {
+          Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `found CommandTopic handler for ` + urn));
+          return await runEffect(correlationId, handler(event, context));
+        }
+        let handlers = eventCollectorHandlers[urn];
+        if (handlers !== undefined) {
+          let count = handlers.length.toString();
+          Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `found ` + count + ` EventCollector handler(s) for ` + urn));
+          await Promise.all(handlers.map(handler => runEffect(correlationId, handler(event, context))));
+          return;
+        }
+        let available = Object.keys(commandTopicHandlers).concat(Object.keys(eventCollectorHandlers)).join(",");
+        return Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `no handler found: ` + urn + ` available=[` + available + `]`));
+      }));
+    });
+    let getRuntimeSpec = aggregate => Stdlib_Option.getOr(runtimeSpecs[Stdlib_Option.getOr(aggregate.__name, "Unnamed")], {
+      aggregate: aggregate,
+      connects: [],
+      eventCollectorChannelSpec: undefined,
+      memorySize: 0,
+      timeout: 0
+    });
+    let setRuntimeSpec = (aggregate, runtimeSpec) => {
+      runtimeSpecs[Stdlib_Option.getOr(aggregate.__name, "Unnamed")] = runtimeSpec;
+    };
+    let registerRuntimeSpec = (connect, memorySize, timeout, aggregate) => {
+      let spec = getRuntimeSpec(aggregate);
+      setRuntimeSpec(aggregate, {
+        aggregate: spec.aggregate,
+        connects: spec.connects.concat([connect]),
+        eventCollectorChannelSpec: spec.eventCollectorChannelSpec,
+        memorySize: Math.max(spec.memorySize, memorySize),
+        timeout: Math.max(spec.timeout, timeout)
+      });
+    };
+    let registerEventCollectorRuntimeSpec = (channel, eventTopics, resources, memorySize, timeout, aggregate) => {
+      let spec = getRuntimeSpec(aggregate);
+      setRuntimeSpec(aggregate, {
+        aggregate: spec.aggregate,
+        connects: spec.connects,
+        eventCollectorChannelSpec: {
+          channel: channel,
+          eventTopics: eventTopics,
+          resources: resources
+        },
+        memorySize: Math.max(spec.memorySize, memorySize),
+        timeout: Math.max(spec.timeout, timeout)
+      });
+    };
+    let forCommandGenerator = (handler, connect, memorySizeOpt, timeoutOpt, commandGenerator) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+      let commandGeneratorResource = Component$ReventlessCore.toPulumiResource(commandGenerator);
+      let commandGeneratorName = Stdlib_Option.getOr(commandGeneratorResource.__name, "Unnamed");
+      let aggregateResource = commandGeneratorResource.__parentResource;
+      if (aggregateResource === undefined) {
+        return Stdlib_JsError.throwWithMessage(`forCommandGenerator: commandGenerator ` + commandGeneratorName + ` has no Aggregate parent`);
+      }
+      registerRuntimeSpec(connect, memorySize, timeout, aggregateResource);
+      let infos = Pulumi.all(Component$ReventlessCore.outputs(commandGenerator).resources.map(resource => resource.resourceInfo));
+      Pulumi.all([
+        infos,
+        handler
+      ]).apply(param => {
+        let handler = param[1];
+        let infoStrs = Stdlib_Array.filterMap(param[0], ri => {
+          if (typeof ri !== "object" || ri.TAG !== "ApiResolver") {
+            return;
+          } else {
+            return ri.typeName + `.` + ri.fieldName;
+          }
+        });
+        log.debug("AggregateRuntime", undefined, `forCommandGenerator ` + commandGeneratorName + `: set handler for ` + infoStrs.join(", "));
+        return infoStrs.map(info => {
+          commandGeneratorHandlers[info] = handler;
+        });
+      });
+    };
+    let forCommandTopic = (handler, connect, memorySizeOpt, timeoutOpt, commandTopic) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+      let commandTopicResource = Component$ReventlessCore.toPulumiResource(commandTopic);
+      let commandTopicName = Stdlib_Option.getOr(commandTopicResource.__name, "Unnamed");
+      let aggregateResource = commandTopicResource.__parentResource;
+      if (aggregateResource === undefined) {
+        return Stdlib_JsError.throwWithMessage(`forCommandTopic: commandTopic ` + commandTopicName + ` has no Aggregate parent`);
+      }
+      registerRuntimeSpec(connect, memorySize, timeout, aggregateResource);
+      let urn = Component$ReventlessCore.outputs(commandTopic).resources[0].urn;
+      Pulumi.all([
+        urn,
+        handler
+      ]).apply(param => {
+        let urn = param[0];
+        log.debug("AggregateRuntime", undefined, `forCommandTopic ` + commandTopicName + `: set handler for ` + urn);
+        commandTopicHandlers[urn] = RuntimeEnvironment.asEffectHandler(param[1]);
+      });
+    };
+    let forEventCollector = (handler, eventTopics, resources, memorySizeOpt, timeoutOpt, eventCollector) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+      let eventCollectorResource = Component$ReventlessCore.toPulumiResource(eventCollector);
+      let eventCollectorName = Stdlib_Option.getOr(eventCollectorResource.__name, "Unnamed");
+      let channel = eventCollector.channel;
+      let aggregateResource = Stdlib_Option.flatMap(eventCollectorResource.__parentResource, parent => parent.__parentResource);
+      if (aggregateResource === undefined) {
+        return Stdlib_JsError.throwWithMessage(`forEventCollector: eventCollector ` + eventCollectorName + ` has no Aggregate parent`);
+      }
+      registerEventCollectorRuntimeSpec(channel, eventTopics, resources, memorySize, timeout, aggregateResource);
+      let urns = Pulumi.all(Component$ReventlessCore.outputs(eventCollector).resources.map(param => param.urn));
+      Pulumi.all([
+        urns,
+        handler
+      ]).apply(param => {
+        let handler = param[1];
+        let urns = param[0];
+        log.debug("AggregateRuntime", undefined, `forEventCollector ` + eventCollectorName + `: set handler for ` + urns.join(", "));
+        return urns.map(urn => {
+          let handlers = Stdlib_Option.getOr(eventCollectorHandlers[urn], []);
+          eventCollectorHandlers[urn] = handlers.concat([RuntimeEnvironment.asEffectHandler(handler)]);
+        });
+      });
+    };
+    return {
+      log: log,
+      CommandTopicChannel: CommandTopicChannel,
+      EventCollectorChannel: EventCollectorChannel,
+      runtimeSpecs: runtimeSpecs,
+      commandGeneratorHandlers: commandGeneratorHandlers,
+      commandTopicHandlers: commandTopicHandlers,
+      eventCollectorHandlers: eventCollectorHandlers,
+      runEffect: runEffect,
+      aggregateHandler: aggregateHandler,
+      getRuntimeSpec: getRuntimeSpec,
+      setRuntimeSpec: setRuntimeSpec,
+      registerRuntimeSpec: registerRuntimeSpec,
+      registerEventCollectorRuntimeSpec: registerEventCollectorRuntimeSpec,
+      forCommandGenerator: forCommandGenerator,
+      forCommandTopic: forCommandTopic,
+      forEventCollector: forEventCollector
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/adapter/Runtime/AggregateRuntime_Builder_Micro.res

@@ -0,0 +1,92 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  CommandTopicChannel: CommandTopic_Adapter.Channel,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+): (
+  AggregateRuntime_Builder.T
+    with type context = RuntimeEnvironment.context
+    and type runtimeParts = RuntimeEnvironment.parts
+    and module CommandTopicChannel = CommandTopicChannel
+    and module EventCollectorChannel = EventCollectorChannel
+) => {
+  type context = RuntimeEnvironment.context
+  type runtimeParts = RuntimeEnvironment.parts
+  module CommandTopicChannel = CommandTopicChannel
+  module EventCollectorChannel = EventCollectorChannel
+
+  let forCommandGenerator = (
+    ~handler: Pulumi.Output.t<CommandGenerator.effectEventHandler<context>>,
+    ~connect,
+    ~memorySize=1024,
+    ~timeout=30,
+    commandGenerator,
+  ) => {
+    let resource = commandGenerator->Component.toPulumiResource
+    let runtime = RuntimeEnvironment.make(
+      ~name=resource.name->ComponentType.nameOpt(CommandGenerator.componentType),
+      ~handler=handler->Pulumi.Output.apply(handler =>
+        handler->RuntimeEnvironment.asEffectHandler->Runtime.runEffectHandler
+      ),
+      ~memorySize,
+      ~timeout,
+      ~opts={Pulumi.ComponentResource.parent: resource},
+    )
+    connect(~runtime)
+  }
+  let forCommandTopic = (
+    ~handler: Pulumi.Output.t<
+      Runtime.effectHandler<CommandTopicChannel.callbackEvent, context, unit, string>,
+    >,
+    ~connect,
+    ~memorySize=1024,
+    ~timeout=30,
+    commandTopic,
+  ) => {
+    let resource = commandTopic->Component.toPulumiResource
+    let runtime = RuntimeEnvironment.make(
+      ~name=resource.name->ComponentType.nameOpt(CommandTopic.componentType),
+      ~handler=handler->Pulumi.Output.apply(handler =>
+        handler->RuntimeEnvironment.asEffectHandler->Runtime.runEffectHandler
+      ),
+      ~memorySize,
+      ~timeout,
+      ~opts={Pulumi.ComponentResource.parent: resource},
+    )
+    connect(~runtime)
+  }
+
+  let forEventCollector = (
+    ~handler: Pulumi.Output.t<
+      Runtime.effectHandler<EventCollectorChannel.callbackEvent, context, unit, string>,
+    >,
+    ~eventTopics: EventTopic.allOutputs,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    ~memorySize=1024,
+    ~timeout=30,
+    eventCollector,
+  ) => {
+    let resource = eventCollector->Component.toPulumiResource
+    let name = resource.name->ComponentType.nameOpt(EventCollector.componentType)
+    let opts = {Pulumi.ComponentResource.parent: resource}
+    let runtime = RuntimeEnvironment.make(
+      ~name,
+      ~handler=handler->Pulumi.Output.apply(handler =>
+        handler->RuntimeEnvironment.asEffectHandler->Runtime.runEffectHandler
+      ),
+      ~memorySize,
+      ~timeout,
+      ~opts,
+    )
+    let _connectResources = EventCollectorChannel.connect(
+      ~name,
+      ~channelSpecs=[
+        {channel: eventCollector->EventCollector_Adapter.channel, eventTopics, resources},
+      ],
+      ~runtime,
+      ~opts,
+    )
+  }
+
+  let finish = () => ()
+}

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

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Runtime$ReventlessCore from "./Runtime.res.mjs";
+import * as Component$ReventlessCore from "../../components/Component.res.mjs";
+import * as CommandTopic$ReventlessCore from "../../components/CommandTopic/CommandTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "../../components/EventCollector/EventCollector.res.mjs";
+import * as CommandGenerator$ReventlessCore from "../../components/CommandGenerator/CommandGenerator.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return CommandTopicChannel => (EventCollectorChannel => {
+    let forCommandGenerator = (handler, connect, memorySizeOpt, timeoutOpt, commandGenerator) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+      let resource = Component$ReventlessCore.toPulumiResource(commandGenerator);
+      return connect(RuntimeEnvironment.make(ComponentType$ReventlessCore.nameOpt(resource.__name, CommandGenerator$ReventlessCore.componentType), handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, {
+        parent: resource
+      }));
+    };
+    let forCommandTopic = (handler, connect, memorySizeOpt, timeoutOpt, commandTopic) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+      let resource = Component$ReventlessCore.toPulumiResource(commandTopic);
+      return connect(RuntimeEnvironment.make(ComponentType$ReventlessCore.nameOpt(resource.__name, CommandTopic$ReventlessCore.componentType), handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, {
+        parent: resource
+      }));
+    };
+    let forEventCollector = (handler, eventTopics, resources, memorySizeOpt, timeoutOpt, eventCollector) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+      let resource = Component$ReventlessCore.toPulumiResource(eventCollector);
+      let name = ComponentType$ReventlessCore.nameOpt(resource.__name, EventCollector$ReventlessCore.componentType);
+      let opts_parent = resource;
+      let opts = {
+        parent: opts_parent
+      };
+      let runtime = RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, opts);
+      EventCollectorChannel.connect(name, [{
+          channel: eventCollector.channel,
+          eventTopics: eventTopics,
+          resources: resources
+        }], runtime, opts);
+    };
+    let finish = () => {};
+    return {
+      CommandTopicChannel: CommandTopicChannel,
+      EventCollectorChannel: EventCollectorChannel,
+      forCommandGenerator: forCommandGenerator,
+      forCommandTopic: forCommandTopic,
+      forEventCollector: forEventCollector,
+      finish: finish
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Runtime-ReventlessCore Not a pure module */