@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/adapter/Runtime/AggregateRuntime_Builder_PerAggregate.res

@@ -0,0 +1,52 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  CommandTopicChannel: CommandTopic_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  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
+) => {
+  include AggregateRuntime_Builder_Common.Make(
+    RuntimeEnvironment,
+    CommandTopicChannel,
+    EventCollectorChannel,
+  )
+
+  let finished = ref(false)
+
+  let finish = () =>
+    if !finished.contents {
+      let _ =
+        runtimeSpecs
+        ->Dict.toArray
+        ->Array.map(((
+          aggregateName,
+          {aggregate, connects, eventCollectorChannelSpec, memorySize, timeout},
+        )) => {
+          let opts = {Pulumi.ComponentResource.parent: aggregate}
+          let runtime = RuntimeEnvironment.make(
+            ~name=aggregateName->ComponentType.name(Aggregate.componentType),
+            ~handler=aggregateHandler(aggregateName)->Pulumi.Output.make,
+            ~memorySize,
+            ~timeout,
+            ~opts,
+          )
+          connects->Array.forEach(connect => connect(~runtime))
+          let _connectResources =
+            eventCollectorChannelSpec->Option.map(channelSpec =>
+              EventCollectorChannel.connect(
+                ~name="AllReadModels",
+                ~channelSpecs=[channelSpec],
+                ~runtime,
+                ~opts,
+              )
+            )
+        })
+      finished := true
+    }
+}

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

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Aggregate$ReventlessCore from "../../components/Aggregate/Aggregate.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as AggregateRuntime_Builder_Common$ReventlessCore from "./AggregateRuntime_Builder_Common.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return CommandTopicChannel => (EventCollectorChannel => {
+    let include = AggregateRuntime_Builder_Common$ReventlessCore.Make(RuntimeEnvironment)(CommandTopicChannel)(EventCollectorChannel);
+    let EventCollectorChannel$1 = include.EventCollectorChannel;
+    let runtimeSpecs = include.runtimeSpecs;
+    let aggregateHandler = include.aggregateHandler;
+    let finished = {
+      contents: false
+    };
+    let finish = () => {
+      if (!finished.contents) {
+        Object.entries(runtimeSpecs).map(param => {
+          let match = param[1];
+          let aggregateName = param[0];
+          let opts_parent = match.aggregate;
+          let opts = {
+            parent: opts_parent
+          };
+          let runtime = RuntimeEnvironment.make(ComponentType$ReventlessCore.name(aggregateName, Aggregate$ReventlessCore.componentType), Pulumi.output(aggregateHandler(aggregateName)), match.memorySize, match.timeout, opts);
+          match.connects.forEach(connect => connect(runtime));
+          Stdlib_Option.map(match.eventCollectorChannelSpec, channelSpec => EventCollectorChannel$1.connect("AllReadModels", [channelSpec], runtime, opts));
+        });
+        finished.contents = true;
+        return;
+      }
+    };
+    return {
+      CommandTopicChannel: include.CommandTopicChannel,
+      EventCollectorChannel: EventCollectorChannel$1,
+      forCommandGenerator: include.forCommandGenerator,
+      forCommandTopic: include.forCommandTopic,
+      forEventCollector: include.forEventCollector,
+      finish: finish
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/adapter/Runtime/AggregateRuntime_Builder_Single.res

@@ -0,0 +1,64 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  CommandTopicChannel: CommandTopic_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  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
+) => {
+  include AggregateRuntime_Builder_Common.Make(
+    RuntimeEnvironment,
+    CommandTopicChannel,
+    EventCollectorChannel,
+  )
+
+  let finished = ref(false)
+
+  let finish = () =>
+    if !finished.contents {
+      let specs = runtimeSpecs->Dict.valuesToArray
+      let (parent, memorySize, timeout) = specs->Array.reduce((None, 0, 0), (
+        (_, accMemorySize, accTimeout),
+        {aggregate, memorySize, timeout},
+      ) => {
+        (
+          aggregate.parent,
+          Math.Int.max(accMemorySize, memorySize),
+          Math.Int.max(accTimeout, timeout),
+        )
+      })
+      switch parent {
+      | Some(parent) =>
+        let opts = {Pulumi.ComponentResource.parent: parent}
+        let runtime = RuntimeEnvironment.make(
+          ~name="AllAggregatesCmdHandler",
+          ~handler=aggregateHandler("AllAggregatesCmdHandler")->Pulumi.Output.make,
+          ~memorySize,
+          ~timeout,
+          ~opts,
+        )
+
+        let _ = specs->Array.map(({connects}) => {
+          connects->Array.forEach(connect => connect(~runtime))
+        })
+
+        let channelSpecs =
+          specs
+          ->Array.map(({eventCollectorChannelSpec}) => eventCollectorChannelSpec)
+          ->Array.keepSome
+        let _connectResources = EventCollectorChannel.connect(
+          ~name="AllAggregates",
+          ~channelSpecs,
+          ~runtime,
+          ~opts,
+        )
+      | None => ()
+      }
+      finished := true
+    }
+}

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

@@ -0,0 +1,59 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as AggregateRuntime_Builder_Common$ReventlessCore from "./AggregateRuntime_Builder_Common.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return CommandTopicChannel => (EventCollectorChannel => {
+    let include = AggregateRuntime_Builder_Common$ReventlessCore.Make(RuntimeEnvironment)(CommandTopicChannel)(EventCollectorChannel);
+    let EventCollectorChannel$1 = include.EventCollectorChannel;
+    let runtimeSpecs = include.runtimeSpecs;
+    let aggregateHandler = include.aggregateHandler;
+    let finished = {
+      contents: false
+    };
+    let finish = () => {
+      if (finished.contents) {
+        return;
+      }
+      let specs = Object.values(runtimeSpecs);
+      let match = Stdlib_Array.reduce(specs, [
+        undefined,
+        0,
+        0
+      ], (param, param$1) => [
+        param$1.aggregate.__parentResource,
+        Math.max(param[1], param$1.memorySize),
+        Math.max(param[2], param$1.timeout)
+      ]);
+      let parent = match[0];
+      if (parent !== undefined) {
+        let opts_parent = parent;
+        let opts = {
+          parent: opts_parent
+        };
+        let runtime = RuntimeEnvironment.make("AllAggregatesCmdHandler", Pulumi.output(aggregateHandler("AllAggregatesCmdHandler")), match[1], match[2], opts);
+        specs.map(param => {
+          param.connects.forEach(connect => connect(runtime));
+        });
+        let channelSpecs = Stdlib_Array.keepSome(specs.map(param => param.eventCollectorChannelSpec));
+        EventCollectorChannel$1.connect("AllAggregates", channelSpecs, runtime, opts);
+      }
+      finished.contents = true;
+    };
+    return {
+      CommandTopicChannel: include.CommandTopicChannel,
+      EventCollectorChannel: EventCollectorChannel$1,
+      forCommandGenerator: include.forCommandGenerator,
+      forCommandTopic: include.forCommandTopic,
+      forEventCollector: include.forEventCollector,
+      finish: finish
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/adapter/Runtime/EventCollectorRuntime_Builder.res

@@ -0,0 +1,11 @@
+module type T = {
+  type context
+  type runtimeParts
+  module EventCollectorChannel: EventCollector_Adapter.Channel
+
+  let forEventCollector: Runtime.forEventCollector<
+    Runtime.effectHandler<EventCollectorChannel.callbackEvent, context, unit, string>,
+    EventCollector.component,
+  >
+  let finish: unit => unit
+}

package/src/adapter/Runtime/EventCollectorRuntime_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/EventCollectorRuntime_Builder_PerEventCollector.res

@@ -0,0 +1,46 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+): (
+  EventCollectorRuntime_Builder.T
+    with type context = RuntimeEnvironment.context
+    and type runtimeParts = RuntimeEnvironment.parts
+    and module EventCollectorChannel = EventCollectorChannel
+) => {
+  type context = RuntimeEnvironment.context
+  type runtimeParts = RuntimeEnvironment.parts
+  module EventCollectorChannel = EventCollectorChannel
+
+  let forEventCollector = (
+    ~handler,
+    ~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={Pulumi.ComponentResource.parent: resource},
+    )
+    let _connectResources = EventCollectorChannel.connect(
+      ~name,
+      ~channelSpecs=[
+        {channel: eventCollector->EventCollector_Adapter.channel, eventTopics, resources},
+      ],
+      ~runtime,
+      ~opts,
+    )
+  }
+
+  let finish = () => ()
+}

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

@@ -0,0 +1,40 @@
+// 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 ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "../../components/EventCollector/EventCollector.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return EventCollectorChannel => {
+    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, {
+        parent: resource
+      });
+      EventCollectorChannel.connect(name, [{
+          channel: eventCollector.channel,
+          eventTopics: eventTopics,
+          resources: resources
+        }], runtime, opts);
+    };
+    let finish = () => {};
+    return {
+      EventCollectorChannel: EventCollectorChannel,
+      forEventCollector: forEventCollector,
+      finish: finish
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* Runtime-ReventlessCore Not a pure module */

package/src/adapter/Runtime/EventCollectorRuntime_Builder_Single.res

@@ -0,0 +1,204 @@
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+): (
+  EventCollectorRuntime_Builder.T
+    with type context = RuntimeEnvironment.context
+    and type runtimeParts = RuntimeEnvironment.parts
+    and module EventCollectorChannel = EventCollectorChannel
+) => {
+  type context = RuntimeEnvironment.context
+  type runtimeParts = RuntimeEnvironment.parts
+  module EventCollectorChannel = EventCollectorChannel
+
+  type runtimeSpec = {
+    channelSpecs: array<
+      EventCollector_Adapter.channelSpec<
+        EventCollectorChannel.callbackEvent,
+        context,
+        EventCollectorChannel.channelParts,
+      >,
+    >,
+    maxMemorySize: int,
+    maxTimeout: int,
+  }
+
+  let log = Logger.fromEnv()
+  let grandParent = ref(None)
+  let parentType = ref(None)
+
+  let runtimeSpec = ref({
+    channelSpecs: [],
+    maxMemorySize: 0,
+    maxTimeout: 0,
+  })
+  type effectHandler = Runtime.effectHandler<RuntimeEnvironment.event, context, unit, string>
+  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 eventCollectorHandler = parentName =>
+    async (event: RuntimeEnvironment.event, context) => {
+      let correlationId = event->RuntimeEnvironment.extractCorrelationId
+      let comp = `EventCollectorRuntime(${parentName})`
+      let _ = await event
+      ->RuntimeEnvironment.groupBySource
+      ->Dict.toArray
+      ->Array.map(async ((urn, event)) => {
+        switch eventCollectorHandlers->Dict.get(urn) {
+        | Some(handlers) =>
+          let count = handlers->Array.length->Int.toString
+          EffectLogger.logDebug(
+            ~comp,
+            `found ${count} handler(s) for ${urn}`,
+          )->Effect.runSync
+          let _ = await handlers
+          ->Array.map(handler => runEffect(~correlationId?, handler(event, context)))
+          ->Promise.all
+        | None => EffectLogger.logWarn(~comp, `no handler found: ${urn}`)->Effect.runSync
+        }
+      })
+      ->Promise.all
+    }
+
+  let validateParent = (parent: Pulumi.Resource.t) => {
+    let parentName = parent.name->Option.getOr("UnnamedParent")
+    // Set grandParent synchronously so finish() can create resources
+    // during the same build phase. Type validation defers to Output.apply.
+    if grandParent.contents == None {
+      grandParent := parent.parent
+    }
+    parent.urn->Pulumi.Output.apply(urn => {
+      let pulumiType =
+        (urn->String.split("::"))[2]
+        ->Option.map(fullType => {
+          let parts = fullType->String.split(":")
+          parts->Array.getUnsafe(parts->Array.length - 1)
+        })
+        ->Option.getOr("Unknown")
+      log.debug(~comp="EventCollectorRuntime", `validateParent: parent ${parentName} type: ${pulumiType}`)
+      switch (parentType.contents) {
+      | None =>
+        parentType := Some(pulumiType)
+      | Some(existingType) if existingType != pulumiType =>
+        JsError.throwWithMessage(
+          `registerRuntimeSpec: parent ${parentName} has different type ${pulumiType} than ${existingType}`,
+        )
+      | _ => ()
+      }
+      switch grandParent.contents {
+      | Some(grandParent) if Some(grandParent) != parent.parent =>
+        let grandParentName = grandParent.name->Option.getOr("UnnamedGrandParent")
+        JsError.throwWithMessage(
+          `registerRuntimeSpec: parent ${parentName} has different parent than ${grandParentName}`,
+        )
+      | _ => ()
+      }
+    })
+  }
+
+  let registerRuntimeSpec = (
+    ~channel,
+    ~eventTopics,
+    ~resources,
+    ~memorySize,
+    ~timeout,
+    parent: Pulumi.Resource.t,
+  ) => {
+    parent
+    ->validateParent
+    ->Pulumi.Output.apply(_ => {
+      let {channelSpecs, maxMemorySize, maxTimeout} = runtimeSpec.contents
+      runtimeSpec := {
+          channelSpecs: channelSpecs->Array.concat([{channel, eventTopics, resources}]),
+          maxMemorySize: Math.Int.max(maxMemorySize, memorySize),
+          maxTimeout: Math.Int.max(maxTimeout, timeout),
+        }
+    })
+  }
+
+  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 {
+    | Some(parentResource) =>
+      let registered =
+        parentResource->registerRuntimeSpec(
+          ~channel,
+          ~eventTopics,
+          ~resources,
+          ~memorySize,
+          ~timeout,
+        )
+      let urns =
+        (eventCollector->Component.outputs).resources
+        ->Array.map(({urn}) => urn)
+        ->Pulumi.Output.all
+      let _ =
+        (registered, urns, handler)
+        ->Pulumi.Output.all3
+        ->Pulumi.Output.apply(((_, urns, handler)) => {
+          log.debug(
+            ~comp="EventCollectorRuntime",
+            `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 parent`,
+      )
+    }
+  }
+
+  let finished = ref(false)
+
+  let finish = () =>
+    if !finished.contents {
+      switch grandParent.contents {
+      | Some(grandParent) =>
+        let name = `All${parentType.contents->Option.getOr("EventCollector")}s`
+        let {channelSpecs, maxMemorySize, maxTimeout} = runtimeSpec.contents
+        let runtime = RuntimeEnvironment.make(
+          ~name,
+          ~handler=eventCollectorHandler(name)->Pulumi.Output.make,
+          ~memorySize=maxMemorySize,
+          ~timeout=maxTimeout,
+          ~opts={Pulumi.ComponentResource.parent: grandParent},
+        )
+        let opts = {Pulumi.ComponentResource.parent: grandParent}
+
+        let _connectResources = EventCollectorChannel.connect(~name, ~channelSpecs, ~runtime, ~opts)
+      | _ =>
+        // grandParent/parentType not set — either no handlers were registered
+        // (e.g. all StateViewSlices went through Bundled path) or Pulumi outputs
+        // haven't resolved yet. Skip silently.
+        ()
+      }
+      finished := true
+    }
+}

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

@@ -0,0 +1,150 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.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";
+
+function Make(RuntimeEnvironment) {
+  return EventCollectorChannel => {
+    let log = Logger$ReventlessCore.fromEnv();
+    let grandParent = {
+      contents: undefined
+    };
+    let parentType = {
+      contents: undefined
+    };
+    let runtimeSpec = {
+      contents: {
+        channelSpecs: [],
+        maxMemorySize: 0,
+        maxTimeout: 0
+      }
+    };
+    let eventCollectorHandlers = {};
+    let eventCollectorHandler = parentName => (async (event, context) => {
+      let correlationId = RuntimeEnvironment.extractCorrelationId(event);
+      let comp = `EventCollectorRuntime(` + parentName + `)`;
+      await Promise.all(Object.entries(RuntimeEnvironment.groupBySource(event)).map(async param => {
+        let event = param[1];
+        let urn = param[0];
+        let handlers = eventCollectorHandlers[urn];
+        if (handlers === undefined) {
+          return Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `no handler found: ` + urn));
+        }
+        let count = handlers.length.toString();
+        Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `found ` + count + ` handler(s) for ` + urn));
+        await Promise.all(handlers.map(handler => {
+          let effect = handler(event, context);
+          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 validateParent = parent => {
+      let parentName = Stdlib_Option.getOr(parent.__name, "UnnamedParent");
+      if (grandParent.contents === undefined) {
+        grandParent.contents = parent.__parentResource;
+      }
+      return parent.urn.apply(urn => {
+        let pulumiType = Stdlib_Option.getOr(Stdlib_Option.map(urn.split("::")[2], fullType => {
+          let parts = fullType.split(":");
+          return parts[parts.length - 1 | 0];
+        }), "Unknown");
+        log.debug("EventCollectorRuntime", undefined, `validateParent: parent ` + parentName + ` type: ` + pulumiType);
+        let existingType = parentType.contents;
+        if (existingType !== undefined) {
+          if (existingType !== pulumiType) {
+            Stdlib_JsError.throwWithMessage(`registerRuntimeSpec: parent ` + parentName + ` has different type ` + pulumiType + ` than ` + existingType);
+          }
+        } else {
+          parentType.contents = pulumiType;
+        }
+        let grandParent$1 = grandParent.contents;
+        if (grandParent$1 === undefined) {
+          return;
+        }
+        if (!Primitive_object.notequal(grandParent$1, parent.__parentResource)) {
+          return;
+        }
+        let grandParentName = Stdlib_Option.getOr(grandParent$1.__name, "UnnamedGrandParent");
+        Stdlib_JsError.throwWithMessage(`registerRuntimeSpec: parent ` + parentName + ` has different parent than ` + grandParentName);
+      });
+    };
+    let registerRuntimeSpec = (channel, eventTopics, resources, memorySize, timeout, parent) => validateParent(parent).apply(() => {
+      let match = runtimeSpec.contents;
+      runtimeSpec.contents = {
+        channelSpecs: match.channelSpecs.concat([{
+            channel: channel,
+            eventTopics: eventTopics,
+            resources: resources
+          }]),
+        maxMemorySize: Math.max(match.maxMemorySize, memorySize),
+        maxTimeout: Math.max(match.maxTimeout, timeout)
+      };
+    });
+    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 parentResource = eventCollectorResource.__parentResource;
+      if (parentResource === undefined) {
+        return Stdlib_JsError.throwWithMessage(`forEventCollector: eventCollector ` + eventCollectorName + ` has no parent`);
+      }
+      let registered = registerRuntimeSpec(channel, eventTopics, resources, memorySize, timeout, parentResource);
+      let urns = Pulumi.all(Component$ReventlessCore.outputs(eventCollector).resources.map(param => param.urn));
+      Pulumi.all([
+        registered,
+        urns,
+        handler
+      ]).apply(param => {
+        let handler = param[2];
+        let urns = param[1];
+        log.debug("EventCollectorRuntime", 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)]);
+        });
+      });
+    };
+    let finished = {
+      contents: false
+    };
+    let finish = () => {
+      if (finished.contents) {
+        return;
+      }
+      let grandParent$1 = grandParent.contents;
+      if (grandParent$1 !== undefined) {
+        let name = `All` + Stdlib_Option.getOr(parentType.contents, "EventCollector") + `s`;
+        let match = runtimeSpec.contents;
+        let runtime = RuntimeEnvironment.make(name, Pulumi.output(eventCollectorHandler(name)), match.maxMemorySize, match.maxTimeout, {
+          parent: grandParent$1
+        });
+        let opts_parent = grandParent$1;
+        let opts = {
+          parent: opts_parent
+        };
+        EventCollectorChannel.connect(name, match.channelSpecs, runtime, opts);
+      }
+      finished.contents = true;
+    };
+    return {
+      EventCollectorChannel: EventCollectorChannel,
+      forEventCollector: forEventCollector,
+      finish: finish
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */