@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/admin/UIFragmentRegistryProjection.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
+import * as PluginSpec$ReventlessCore from "../plugin/lifecycle/PluginSpec.res.mjs";
+import * as UIFragmentRegistryReadModelSpec$ReventlessCore from "./UIFragmentRegistryReadModelSpec.res.mjs";
+
+let moduleUrl = import.meta.url;
+
+function project(param) {
+  let event = param.event;
+  let time = param.meta.time;
+  let id = param.id;
+  switch (event.TAG) {
+    case "UIFragmentRegistered" :
+      let manifest = event._0.manifest;
+      return {
+        TAG: "Set",
+        _0: id,
+        _1: {
+          pluginId: id,
+          remoteEntryUrl: manifest.remoteEntryUrl,
+          panels: manifest.panels,
+          pages: manifest.pages,
+          registeredAt: time,
+          updatedAt: time
+        }
+      };
+    case "UIFragmentUpdated" :
+      let newManifest = event._0.newManifest;
+      return {
+        TAG: "Update",
+        _0: id,
+        _1: state => ({
+          pluginId: state.pluginId,
+          remoteEntryUrl: newManifest.remoteEntryUrl,
+          panels: newManifest.panels,
+          pages: newManifest.pages,
+          registeredAt: state.registeredAt,
+          updatedAt: time
+        })
+      };
+    case "UIFragmentDeregistered" :
+      return {
+        TAG: "Delete",
+        _0: id
+      };
+    default:
+      return "Ignore";
+  }
+}
+
+let UIFragmentRegistryMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: PluginSpec$ReventlessCore.name,
+  eventSchema: PluginSpec$ReventlessCore.eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: UIFragmentRegistryReadModelSpec$ReventlessCore.name,
+  stateSchema: UIFragmentRegistryReadModelSpec$ReventlessCore.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+let Mappings = Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: UIFragmentRegistryReadModelSpec$ReventlessCore.name,
+  stateSchema: UIFragmentRegistryReadModelSpec$ReventlessCore.stateSchema,
+  subIdConfig: undefined
+});
+
+let mappings = [UIFragmentRegistryMapping];
+
+export {
+  moduleUrl,
+  UIFragmentRegistryMapping,
+  Mappings,
+  mappings,
+}
+/* moduleUrl Not a pure module */

package/src/admin/UIFragmentRegistryReadModelSpec.res

@@ -0,0 +1,13 @@
+@@reventless.spec("UIFragmentRegistry")
+
+open Reventless.Plugin
+
+@schema
+type state = {
+  pluginId: string,
+  remoteEntryUrl: string,
+  panels: array<panelManifestEntry>,
+  pages: array<pageManifestEntry>,
+  registeredAt: string,
+  updatedAt: string,
+}

package/src/admin/UIFragmentRegistryReadModelSpec.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+let stateSchema = S.schema(s => ({
+  pluginId: s.m(S.string),
+  remoteEntryUrl: s.m(S.string),
+  panels: s.m(S.array(Plugin$Reventless.panelManifestEntrySchema)),
+  pages: s.m(S.array(Plugin$Reventless.pageManifestEntrySchema)),
+  registeredAt: s.m(S.string),
+  updatedAt: s.m(S.string)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "UIFragmentRegistry";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UIFragmentRegistryReadModelSpec.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  stateSchema,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* stateSchema Not a pure module */

package/src/components/Aggregate/Aggregate.res

@@ -0,0 +1,96 @@
+open ReventlessInfra.Aggregate
+
+let componentType = ComponentType.Aggregate
+
+type t
+type outputs = ReventlessInfra.Aggregate.outputs
+type addEventMapper = ReventlessInfra.Aggregate.addEventMapper
+type allOutputs = ReventlessInfra.Aggregate.allOutputs
+type operations = ReventlessInfra.Aggregate.operations
+type component = Component.t<t, outputs, operations>
+
+type name = string
+
+let allEventTopics = allAggregates =>
+  Dict.mapValues(allAggregates, aggregate => aggregate.eventLog.eventTopic)
+let allCommandTopics = allAggregates =>
+  Dict.mapValues(allAggregates, aggregate => aggregate.commandTopic)->Pulumi.Output.allDict
+
+let filterEventTopics = (allAggregates, aggregateNames) =>
+  aggregateNames
+  ->Belt.Set.String.toArray
+  ->Array.filterMap(aggregateName =>
+    allAggregates
+    ->Dict.get(aggregateName)
+    ->Option.map(aggregateOutput => (aggregateName, aggregateOutput.eventLog.eventTopic))
+  )
+  ->Dict.fromArray
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.Aggregate.resolvedOutputs> => {
+  let commandGeneratorResolved =
+    outputs.commandGenerator->Pulumi.Output.flatMap((cg: ReventlessInfra.CommandGenerator.outputs) =>
+      cg.resources
+      ->Adapter.resourcesToInterop
+      ->Pulumi.Output.apply(resources => {
+        let resolved: ReventlessInterop.CommandGenerator.resolvedOutputs = {
+          resources: resources,
+        }
+        resolved
+      })
+    )
+  let commandTopicResolved =
+    outputs.commandTopic->Pulumi.Output.flatMap(CommandTopic.toResolvedOutputs)
+  let eventLogResolved =
+    (
+      outputs.eventLog.resources->Adapter.resourcesToInterop,
+      outputs.eventLog.eventTopic.resources->Adapter.resourcesToInterop,
+    )
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((resources, eventTopicResources)) => {
+      let resolved: ReventlessInterop.EventLog.resolvedOutputs = {
+        resources: resources,
+        eventTopic: {resources: eventTopicResources},
+      }
+      resolved
+    })
+  let eventMapperResolved = switch outputs.eventMapper {
+  | Some(emOutput) =>
+    emOutput
+    ->Pulumi.Output.flatMap(EventMapper.toResolvedOutputs)
+    ->Pulumi.Output.apply(resolved => Some(resolved))
+  | None => Pulumi.Output.make(None)
+  }
+  (commandGeneratorResolved, commandTopicResolved, eventLogResolved, eventMapperResolved)
+  ->Pulumi.Output.all4
+  ->Pulumi.Output.apply(((commandGenerator, commandTopic, eventLog, eventMapper)) =>
+    switch eventMapper {
+    | Some(em) => {
+        ReventlessInterop.Aggregate.name: outputs.name,
+        commandGenerator,
+        commandTopic,
+        eventLog,
+        eventMapper: em,
+      }
+    | None => {
+        name: outputs.name,
+        commandGenerator,
+        commandTopic,
+        eventLog,
+      }
+    }
+  )
+}
+
+module type T = {
+  module Spec: Reventless.Aggregate.Spec
+  module AggregateRuntimeBuilder: AggregateRuntime_Builder.T
+
+  type api
+  type component = Component.t<t, outputs, operations>
+  let make: (~api: api, ~opts: Pulumi.ComponentResource.options=?) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+  let finish: unit => unit
+}

package/src/components/Aggregate/Aggregate.res.mjs

@@ -0,0 +1,82 @@
+// 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 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 Pulumi from "@pulumi/pulumi";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+import * as EventMapper$ReventlessCore from "../EventMapper/EventMapper.res.mjs";
+import * as CommandTopic$ReventlessCore from "../CommandTopic/CommandTopic.res.mjs";
+
+function allEventTopics(allAggregates) {
+  return Stdlib_Dict.mapValues(allAggregates, aggregate => aggregate.eventLog.eventTopic);
+}
+
+function allCommandTopics(allAggregates) {
+  return Pulumi.all(Stdlib_Dict.mapValues(allAggregates, aggregate => aggregate.commandTopic));
+}
+
+function filterEventTopics(allAggregates, aggregateNames) {
+  return Object.fromEntries(Stdlib_Array.filterMap(Belt_SetString.toArray(aggregateNames), aggregateName => Stdlib_Option.map(allAggregates[aggregateName], aggregateOutput => [
+    aggregateName,
+    aggregateOutput.eventLog.eventTopic
+  ])));
+}
+
+function toResolvedOutputs(outputs) {
+  let commandGeneratorResolved = Output$Pulumi.flatMap(outputs.commandGenerator, cg => Adapter$ReventlessCore.resourcesToInterop(cg.resources).apply(resources => ({
+    resources: resources
+  })));
+  let commandTopicResolved = Output$Pulumi.flatMap(outputs.commandTopic, CommandTopic$ReventlessCore.toResolvedOutputs);
+  let eventLogResolved = Pulumi.all([
+    Adapter$ReventlessCore.resourcesToInterop(outputs.eventLog.resources),
+    Adapter$ReventlessCore.resourcesToInterop(outputs.eventLog.eventTopic.resources)
+  ]).apply(param => ({
+    resources: param[0],
+    eventTopic: {
+      resources: param[1]
+    }
+  }));
+  let emOutput = outputs.eventMapper;
+  let eventMapperResolved = emOutput !== undefined ? Output$Pulumi.flatMap(emOutput, EventMapper$ReventlessCore.toResolvedOutputs).apply(resolved => resolved) : Pulumi.output(undefined);
+  return Pulumi.all([
+    commandGeneratorResolved,
+    commandTopicResolved,
+    eventLogResolved,
+    eventMapperResolved
+  ]).apply(param => {
+    let eventMapper = param[3];
+    let eventLog = param[2];
+    let commandTopic = param[1];
+    let commandGenerator = param[0];
+    if (eventMapper !== undefined) {
+      return {
+        name: outputs.name,
+        commandGenerator: commandGenerator,
+        commandTopic: commandTopic,
+        eventLog: eventLog,
+        eventMapper: eventMapper
+      };
+    } else {
+      return {
+        name: outputs.name,
+        commandGenerator: commandGenerator,
+        commandTopic: commandTopic,
+        eventLog: eventLog
+      };
+    }
+  });
+}
+
+let componentType = "Aggregate";
+
+export {
+  componentType,
+  allEventTopics,
+  allCommandTopics,
+  filterEventTopics,
+  toResolvedOutputs,
+}
+/* Output-Pulumi Not a pure module */

package/src/components/Aggregate/Aggregate_Builder.res

@@ -0,0 +1,175 @@
+module Make = (
+  Spec: Reventless.Aggregate.Spec,
+  Behavior: Behavior.T with module Spec := Spec,
+  EventMappings: EventMapper.Mappings with module Target := Spec,
+  RuntimeEnvironment: Runtime.Environment,
+  CommandGeneratorResolvers: CommandGenerator_Adapter.Resolvers
+    with type runtimeParts = RuntimeEnvironment.parts,
+  CommandTopicChannel: CommandTopic_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventLogStorage: EventLog_Adapter.Storage,
+  EventTopicPublisher: EventTopic_Adapter.Publisher,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  AggregateRuntimeBuilder: AggregateRuntime_Builder.T
+    with module CommandTopicChannel = CommandTopicChannel
+    and module EventCollectorChannel = EventCollectorChannel
+    and type runtimeParts = RuntimeEnvironment.parts,
+  HooksConfig: Plugin_Helpers.HooksConfig,
+): (Aggregate.T with type api = CommandGeneratorResolvers.api and type component = Aggregate.component) => {
+  module Spec = Spec
+  module AggregateRuntimeBuilder = AggregateRuntimeBuilder
+
+  type api = CommandGeneratorResolvers.api
+  type component = Aggregate.component
+
+  module SpecificEventLog = EventLog_Builder.Make(Spec, EventLogStorage, EventTopicPublisher)
+  module SpecificCommandTopic = CommandTopic_Builder.Make(Spec, CommandTopicChannel)
+  module SpecificCommandGenerator = CommandGenerator_Builder.Make(
+    Spec,
+    CommandGeneratorResolvers,
+  )
+  module SpecificEventCollector = EventCollector_Builder.Make(
+    RuntimeEnvironment,
+    EventCollectorChannel,
+  )
+  module SpecificEventMapper = EventMapper_Builder.Make(
+    Spec,
+    SpecificEventCollector,
+    EventMappings,
+    AggregateRuntimeBuilder,
+  )
+
+  let addEventMapperFn = (aggregate: Aggregate.component, allEventTopics, queryEngine, ~opts) => {
+    if EventMappings.mappings->Array.length > 0 {
+      let eventMapper =
+        (aggregate->Component.operations, (aggregate->Component.outputs).commandTopic)
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply((({publishJsons}, commandTopic)) =>
+          SpecificEventMapper.make(
+            ~name=Spec.name->ComponentType.name(Aggregate.componentType),
+            ~allEventTopics,
+            ~queryEngine,
+            ~publishJsons,
+            ~resources=commandTopic.resources,
+            ~opts,
+          )
+        )
+      {
+        ...aggregate->Component.outputs,
+        eventMapper: eventMapper->Pulumi.Output.apply(eventMapper =>
+          eventMapper->Component.outputs
+        ),
+      }
+    } else {
+      aggregate->Component.outputs
+    }
+  }
+
+  let createCommandTopic = (eventLog: SpecificEventLog.component, name, opts) =>
+    eventLog
+    ->Component.operations
+    ->Pulumi.Output.apply(eventLogOps => {
+      module AggregateCallback = Aggregate_Callback.Make(
+        Spec,
+        Behavior,
+        {
+          module Spec = Spec
+          module EventLog = SpecificEventLog
+          let eventLog = eventLogOps
+        },
+      )
+      let commandTopic = SpecificCommandTopic.make(~name, ~opts)
+      let handler = SpecificCommandTopic.makeHandler(
+        ~commandTopic,
+        ~commandsHandler=AggregateCallback.handleCommands,
+      )
+      let eventLog = eventLog->Component.outputs
+      let resources = [eventLog.resources, eventLog.eventTopic.resources]->Array.flat
+      commandTopic->AggregateRuntimeBuilder.forCommandTopic(
+        ~handler,
+        ~connect=SpecificCommandTopic.connect(commandTopic, ~resources, ...),
+      )
+      commandTopic
+    })
+
+  let createCommandGenerator = (
+    commandTopic: Pulumi.Output.t<SpecificCommandTopic.component>,
+    ~api: CommandGeneratorResolvers.api,
+    name,
+    opts,
+  ) =>
+    commandTopic->Pulumi.Output.flatMap(commandTopic =>
+      commandTopic
+      ->Component.operations
+      ->Pulumi.Output.apply(({publishJsons, publishJsonsAndWait}) => {
+        let commandGenerator = SpecificCommandGenerator.make(~name, ~opts)
+        switch HooksConfig.hooks.mutationBindHook {
+        | Some(bindHandler) =>
+          // In-memory: bind generateCommand to resolver stubs directly,
+          // skipping the adapter-driven forCommandGenerator path.
+          let fields =
+            switch Plugin_Helpers.aggregateMutationFieldsRegistry->Dict.get(Spec.name) {
+            | Some(registeredFields) if registeredFields->Array.length > 0 => registeredFields
+            | _ => []
+            }
+          let generateCommand = CommandGenerator_Callback.makeGenerateCommand(
+            ~publishJsons,
+            ~publishJsonsAndWait=?publishJsonsAndWait,
+            ~serviceName=Spec.name,
+            ~commandSchema=Spec.commandSchema->S.castToUnknown,
+            ~componentKind=CommandGenerator_Callback.Aggregate,
+          )
+          fields->Array.forEach(field => bindHandler(~field, ~generateCommand))
+        | None =>
+          // AWS: use adapter-driven forCommandGenerator (creates Lambda + policies)
+          let resources = (commandTopic->Component.outputs).resources
+          commandGenerator->AggregateRuntimeBuilder.forCommandGenerator(
+            ~handler=SpecificCommandGenerator.makeHandler(~publishJsons, ~publishJsonsAndWait),
+            ~connect=SpecificCommandGenerator.connect(commandGenerator, ~api, ~resources, ...),
+          )
+        }
+        commandGenerator
+      })
+    )
+
+  let construct = (~api: CommandGeneratorResolvers.api, self, name) => {
+    let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+    let name = name->ComponentType.name(Aggregate.componentType)
+
+    let eventLog = SpecificEventLog.make(~name, ~opts)
+    let commandTopic = eventLog->createCommandTopic(name, opts)
+    let commandGenerator = commandTopic->createCommandGenerator(~api, name, opts)
+
+    self->Component.setOperations(
+      commandTopic->Pulumi.Output.flatMap(commandTopic =>
+        commandTopic
+        ->Component.operations
+        ->Pulumi.Output.apply(({publishJsons, publishJsonsStream}) => {
+          let ops: Aggregate.operations = {publishJsons, publishJsonsStream}
+          ops
+        })
+      ),
+    )
+    let aggOutputs: Aggregate.outputs = {
+      name: Spec.name,
+      commandGenerator: commandGenerator->Component.wrappedOutputs,
+      commandTopic: commandTopic->Component.wrappedOutputs,
+      eventLog: eventLog->Component.outputs,
+      addEventMapper: self->addEventMapperFn(~opts, ...),
+    }
+    self->Component.setOutputs(aggOutputs)
+  }
+
+  let make = (~api: CommandGeneratorResolvers.api, ~opts=?): Aggregate.component =>
+    Component.make(
+      ~componentType=Aggregate.componentType->ComponentType.toString,
+      ~name=Spec.name,
+      ~construct=construct(~api, ...),
+      ~opts,
+    )
+
+  let outputs = Component.outputs
+  let operations = Component.operations
+  let finish = () => AggregateRuntimeBuilder.finish()
+}

package/src/components/Aggregate/Aggregate_Builder.res.mjs

@@ -0,0 +1,119 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Aggregate$ReventlessCore from "./Aggregate.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "../../plugin/component/Plugin_Helpers.res.mjs";
+import * as EventLog_Builder$ReventlessCore from "../EventLog/EventLog_Builder.res.mjs";
+import * as Aggregate_Callback$ReventlessCore from "./Aggregate_Callback.res.mjs";
+import * as EventMapper_Builder$ReventlessCore from "../EventMapper/EventMapper_Builder.res.mjs";
+import * as CommandTopic_Builder$ReventlessCore from "../CommandTopic/CommandTopic_Builder.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventCollector_Builder.res.mjs";
+import * as CommandGenerator_Builder$ReventlessCore from "../CommandGenerator/CommandGenerator_Builder.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+function Make(Spec) {
+  return Behavior => (EventMappings => (RuntimeEnvironment => (CommandGeneratorResolvers => (CommandTopicChannel => (EventLogStorage => (EventTopicPublisher => (EventCollectorChannel => (AggregateRuntimeBuilder => (HooksConfig => {
+    let SpecificEventLog = EventLog_Builder$ReventlessCore.Make(Spec)(EventLogStorage)(EventTopicPublisher);
+    let SpecificCommandTopic = CommandTopic_Builder$ReventlessCore.Make({
+      Id: Spec.Id,
+      name: Spec.name,
+      commandSchema: Spec.commandSchema
+    })(CommandTopicChannel);
+    let SpecificCommandGenerator = CommandGenerator_Builder$ReventlessCore.Make(Spec)(CommandGeneratorResolvers);
+    let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+    let SpecificEventMapper = EventMapper_Builder$ReventlessCore.Make({
+      name: Spec.name,
+      Id: Spec.Id,
+      commandSchema: Spec.commandSchema
+    })(SpecificEventCollector)(EventMappings)(AggregateRuntimeBuilder);
+    let createCommandTopic = (eventLog, name, opts) => Component$ReventlessCore.operations(eventLog).apply(eventLogOps => {
+      let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Behavior)({
+        Spec: Spec,
+        EventLog: SpecificEventLog,
+        eventLog: eventLogOps
+      });
+      let commandTopic = SpecificCommandTopic.make(name, opts);
+      let handler = SpecificCommandTopic.makeHandler(commandTopic, AggregateCallback.handleCommands);
+      let eventLog$1 = Component$ReventlessCore.outputs(eventLog);
+      let resources = [
+        eventLog$1.resources,
+        eventLog$1.eventTopic.resources
+      ].flat();
+      AggregateRuntimeBuilder.forCommandTopic(handler, none => SpecificCommandTopic.connect(none, resources, commandTopic), undefined, undefined, commandTopic);
+      return commandTopic;
+    });
+    let createCommandGenerator = (commandTopic, api, name, opts) => Output$Pulumi.flatMap(commandTopic, commandTopic => Component$ReventlessCore.operations(commandTopic).apply(param => {
+      let publishJsonsAndWait = param.publishJsonsAndWait;
+      let publishJsons = param.publishJsons;
+      let commandGenerator = SpecificCommandGenerator.make(name, opts);
+      let bindHandler = HooksConfig.hooks.mutationBindHook;
+      if (bindHandler !== undefined) {
+        let registeredFields = Plugin_Helpers$ReventlessCore.aggregateMutationFieldsRegistry[Spec.name];
+        let fields = registeredFields !== undefined ? (
+            registeredFields.length !== 0 ? registeredFields : []
+          ) : [];
+        let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, publishJsonsAndWait, Spec.name, Spec.commandSchema, "Aggregate", undefined);
+        fields.forEach(field => bindHandler(field, generateCommand));
+      } else {
+        let resources = Component$ReventlessCore.outputs(commandTopic).resources;
+        AggregateRuntimeBuilder.forCommandGenerator(SpecificCommandGenerator.makeHandler(publishJsons, publishJsonsAndWait), none => SpecificCommandGenerator.connect(api, resources, none, commandGenerator), undefined, undefined, commandGenerator);
+      }
+      return commandGenerator;
+    }));
+    let make = (api, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Aggregate$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+      let opts = {
+        parent: opts_parent
+      };
+      let name = ComponentType$ReventlessCore.name(extra$1, Aggregate$ReventlessCore.componentType);
+      let eventLog = SpecificEventLog.make(name, opts);
+      let commandTopic = createCommandTopic(eventLog, name, opts);
+      let commandGenerator = createCommandGenerator(commandTopic, api, name, opts);
+      Component$ReventlessCore.setOperations(extra, Output$Pulumi.flatMap(commandTopic, commandTopic => Component$ReventlessCore.operations(commandTopic).apply(param => ({
+        publishJsons: param.publishJsons,
+        publishJsonsStream: param.publishJsonsStream
+      }))));
+      let aggOutputs_name = Spec.name;
+      let aggOutputs_commandGenerator = Component$ReventlessCore.wrappedOutputs(commandGenerator);
+      let aggOutputs_commandTopic = Component$ReventlessCore.wrappedOutputs(commandTopic);
+      let aggOutputs_eventLog = Component$ReventlessCore.outputs(eventLog);
+      let aggOutputs_addEventMapper = (none, none$1) => {
+        if (EventMappings.mappings.length === 0) {
+          return Component$ReventlessCore.outputs(extra);
+        }
+        let eventMapper = Pulumi.all([
+          Component$ReventlessCore.operations(extra),
+          Component$ReventlessCore.outputs(extra).commandTopic
+        ]).apply(param => SpecificEventMapper.make(ComponentType$ReventlessCore.name(Spec.name, Aggregate$ReventlessCore.componentType), none, none$1, param[0].publishJsons, param[1].resources, undefined, undefined, opts));
+        let newrecord = {...Component$ReventlessCore.outputs(extra)};
+        newrecord.eventMapper = eventMapper.apply(Component$ReventlessCore.outputs);
+        return newrecord;
+      };
+      let aggOutputs = {
+        name: aggOutputs_name,
+        commandGenerator: aggOutputs_commandGenerator,
+        commandTopic: aggOutputs_commandTopic,
+        eventLog: aggOutputs_eventLog,
+        addEventMapper: aggOutputs_addEventMapper
+      };
+      return Component$ReventlessCore.setOutputs(extra, aggOutputs);
+    }, opts);
+    let finish = () => AggregateRuntimeBuilder.finish();
+    return {
+      Spec: Spec,
+      AggregateRuntimeBuilder: AggregateRuntimeBuilder,
+      make: make,
+      outputs: Component$ReventlessCore.outputs,
+      operations: Component$ReventlessCore.operations,
+      finish: finish
+    };
+  })))))))));
+}
+
+export {
+  Make,
+}
+/* Output-Pulumi Not a pure module */