@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Builder_Helpers.res

@@ -0,0 +1,196 @@
+// Shared builder helpers used by both Plugin_Builder and Platform_Admin.
+// Extracted from Plugin_Helpers to eliminate duplication.
+
+// Captured read model data — stores extracted values instead of module+component
+// so that Builder_Helpers can work with abstract spec-level component types.
+type readModel = {
+  outputs: ReadModel.outputs,
+  operations: Pulumi.Output.t<ReadModel.operations>,
+  finish: unit => unit,
+}
+
+let addEventMapperFns = Dict.make()
+let aggregateResources = Dict.make()
+let publishToAggregates = Dict.make()
+// Finish functions captured from aggregate modules during createAggregatesWithoutEventMappers.
+let aggregateFinishFns = Dict.make()
+
+let createAggregatesWithoutEventMappers = (
+  type a,
+  aggregates: array<module(ReventlessInfra.Aggregate.T with type api = a)>,
+  ~api: a,
+  opts,
+) =>
+  aggregates
+  ->Array.map((module(SpecificAggregate: ReventlessInfra.Aggregate.T with type api = a)) => {
+    let aggregate = SpecificAggregate.make(~api, ~opts)
+    let aggOutputs = SpecificAggregate.outputs(aggregate)
+    addEventMapperFns->Dict.set(
+      SpecificAggregate.Spec.name,
+      aggOutputs.addEventMapper,
+    )
+    let resources =
+      aggOutputs.commandTopic->Pulumi.Output.apply(commandTopic =>
+        commandTopic.resources
+      )
+    aggregateResources->Dict.set(SpecificAggregate.Spec.name, resources)
+    let publishJsons =
+      SpecificAggregate.operations(aggregate)->Pulumi.Output.apply(({publishJsons}) => publishJsons)
+    publishToAggregates->Dict.set(SpecificAggregate.Spec.name, publishJsons)
+    aggregateFinishFns->Dict.set(SpecificAggregate.Spec.name, SpecificAggregate.finish)
+    aggOutputs
+  })
+  ->Array.map(aggregate => {(aggregate.name, aggregate)})
+  ->Dict.fromArray
+
+
+let finishAggregates = (
+  aggregatesOutputs: dict<Aggregate.outputs>,
+) => {
+  let allOutputs = aggregatesOutputs->Dict.valuesToArray
+
+  // Wait for ALL commandTopicOutputs (not just those with event mappers)
+  // to ensure forCommandTopic has registered specs before finish() runs.
+  let allCommandTopicOutputs =
+    allOutputs->Array.map(aggregateOutputs => aggregateOutputs.commandTopic)
+  let eventMapperOutputs =
+    allOutputs
+    ->Array.map(aggregateOutputs => aggregateOutputs.eventMapper)
+    ->Array.keepSome
+
+  let _ =
+    (eventMapperOutputs->Pulumi.Output.all, allCommandTopicOutputs->Pulumi.Output.all)
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((eventMapperOutputs, _)) =>
+      eventMapperOutputs
+      ->Array.map(eventMapperOutput => eventMapperOutput.eventCollector)
+      ->Pulumi.Output.all
+      ->Pulumi.Output.apply(_ =>
+        aggregateFinishFns->Dict.valuesToArray->Array.forEach(finishFn => finishFn())
+      )
+    )
+}
+
+let addEventMappers = (
+  allEventTopics,
+  queryEngine,
+) => {
+  let aggregatesOutputs =
+    addEventMapperFns->Dict.mapValues(addEventMapperFn =>
+      addEventMapperFn(allEventTopics, queryEngine)
+    )
+  finishAggregates(aggregatesOutputs)
+
+  aggregatesOutputs
+}
+
+let readModelNamesForSourceName = Dict.make()
+let publishToReadModels = Dict.make()
+
+let finishReadModels = readModels => {
+  let _ =
+    readModels
+    ->Array.map(((_, {operations})) => operations)
+    ->Pulumi.Output.all
+    ->Pulumi.Output.apply(_ =>
+      readModels->Array.forEach(((_, {finish})) => {
+        finish()
+      })
+    )
+}
+
+let extractReadModelsOutputs = readModels =>
+  readModels
+  ->Dict.fromArray
+  ->Dict.toArray
+  ->Array.map(((name, {outputs})) => (name, outputs))
+  ->Dict.fromArray
+
+let createReadModels = (
+  type a,
+  type r,
+  readModels: array<module(ReventlessInfra.ReadModel.T with type api = a and type role = r)>,
+  ~api: a,
+  ~apiRole: r,
+  allEventTopics,
+  opts,
+) => {
+  let readModels = readModels->Array.map((module(SpecificReadModel: ReventlessInfra.ReadModel.T with type api = a and type role = r)) => {
+    let readModel = SpecificReadModel.make(~api, ~apiRole, ~allEventTopics, ~opts)
+    let rmOutputs = SpecificReadModel.outputs(readModel)
+    let rmOperations = SpecificReadModel.operations(readModel)
+    rmOutputs.sourceNames->Array.forEach(sourceName =>
+      switch readModelNamesForSourceName->Dict.get(sourceName) {
+      | Some(readModelNames) =>
+        readModelNamesForSourceName->Dict.set(
+          sourceName,
+          readModelNames->Array.concat([SpecificReadModel.Spec.name]),
+        )
+      | None => Dict.set(readModelNamesForSourceName, sourceName, [SpecificReadModel.Spec.name])
+      }
+    )
+    publishToReadModels->Dict.set(
+      SpecificReadModel.Spec.name,
+      rmOperations->Pulumi.Output.apply(({enqueueEvent}) => enqueueEvent),
+    )
+
+    (SpecificReadModel.Spec.name, {outputs: rmOutputs, operations: rmOperations, finish: SpecificReadModel.finish})
+  })
+  readModels->finishReadModels
+  readModels->extractReadModelsOutputs
+}
+
+// Per-extension-point registry data the EventCollector entry point needs at
+// runtime to publish outgoing events. Lives next to the existing
+// `extensionPointsOutputs` / `extensionPointsHandlers` arrays — same indexing.
+type extensionPointRegistryInfo = {
+  specModule: string,
+  mappingsModule: string,
+}
+
+let createExtensionPoints = (
+  extensionPoints,
+  ~aggregateResources,
+  ~publishToAggregates,
+  ~scheduler,
+  ~queryEngine,
+  ~resourceNaming,
+  ~opts,
+) => {
+  let triples =
+    extensionPoints
+    ->Array.map((module(SpecificExtensionPoint: ReventlessInfra.ExtensionPoint.T)) => {
+      let extensionPoint = SpecificExtensionPoint.make(
+        ~aggregateResources,
+        ~publishToAggregates,
+        ~scheduler,
+        ~queryEngine,
+        ~resourceNaming,
+        ~opts=Some(opts),
+      )
+      // operations() returns abstract type from ReventlessInfra.ExtensionPoint.T;
+      // coerce to the concrete ExtensionPoint.operations (always identical at runtime).
+      let ops: Pulumi.Output.t<ExtensionPoint.operations> =
+        SpecificExtensionPoint.operations(extensionPoint)->Obj.magic
+      let outputs = SpecificExtensionPoint.outputs(extensionPoint)
+      let registryInfo: extensionPointRegistryInfo = {
+        specModule: outputs.specModule,
+        mappingsModule: outputs.mappingsModule,
+      }
+      (
+        outputs,
+        ops->Pulumi.Output.apply(({outgoingJsonEventsHandler}) => outgoingJsonEventsHandler),
+        registryInfo,
+      )
+    })
+  let outputs = triples->Array.map(((o, _, _)) => o)
+  let handlers = triples->Array.map(((_, h, _)) => h)
+  let registryInfos = triples->Array.map(((_, _, r)) => r)
+  (outputs, handlers, registryInfos)
+}
+
+let createResolvers = allQueryDbs =>
+  allQueryDbs
+  ->QueryDb.allResolversMakers
+  ->Array.map(resolverMaker => resolverMaker(allQueryDbs))
+  ->Array.flat

package/src/components/Builder_Helpers.res.mjs

@@ -0,0 +1,142 @@
+// 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 Pulumi from "@pulumi/pulumi";
+import * as QueryDb$ReventlessCore from "./QueryDb/QueryDb.res.mjs";
+
+let addEventMapperFns = {};
+
+let aggregateResources = {};
+
+let publishToAggregates = {};
+
+let aggregateFinishFns = {};
+
+function createAggregatesWithoutEventMappers(aggregates, api, opts) {
+  return Object.fromEntries(aggregates.map(SpecificAggregate => {
+    let aggregate = SpecificAggregate.make(api, opts);
+    let aggOutputs = SpecificAggregate.outputs(aggregate);
+    addEventMapperFns[SpecificAggregate.Spec.name] = aggOutputs.addEventMapper;
+    let resources = aggOutputs.commandTopic.apply(commandTopic => commandTopic.resources);
+    aggregateResources[SpecificAggregate.Spec.name] = resources;
+    let publishJsons = SpecificAggregate.operations(aggregate).apply(param => param.publishJsons);
+    publishToAggregates[SpecificAggregate.Spec.name] = publishJsons;
+    aggregateFinishFns[SpecificAggregate.Spec.name] = SpecificAggregate.finish;
+    return aggOutputs;
+  }).map(aggregate => [
+    aggregate.name,
+    aggregate
+  ]));
+}
+
+function finishAggregates(aggregatesOutputs) {
+  let allOutputs = Object.values(aggregatesOutputs);
+  let allCommandTopicOutputs = allOutputs.map(aggregateOutputs => aggregateOutputs.commandTopic);
+  let eventMapperOutputs = Stdlib_Array.keepSome(allOutputs.map(aggregateOutputs => aggregateOutputs.eventMapper));
+  Pulumi.all([
+    Pulumi.all(eventMapperOutputs),
+    Pulumi.all(allCommandTopicOutputs)
+  ]).apply(param => Pulumi.all(param[0].map(eventMapperOutput => eventMapperOutput.eventCollector)).apply(param => {
+    Object.values(aggregateFinishFns).forEach(finishFn => finishFn());
+  }));
+}
+
+function addEventMappers(allEventTopics, queryEngine) {
+  let aggregatesOutputs = Stdlib_Dict.mapValues(addEventMapperFns, addEventMapperFn => addEventMapperFn(allEventTopics, queryEngine));
+  finishAggregates(aggregatesOutputs);
+  return aggregatesOutputs;
+}
+
+let readModelNamesForSourceName = {};
+
+let publishToReadModels = {};
+
+function finishReadModels(readModels) {
+  Pulumi.all(readModels.map(param => param[1].operations)).apply(param => {
+    readModels.forEach(param => param[1].finish());
+  });
+}
+
+function extractReadModelsOutputs(readModels) {
+  return Object.fromEntries(Object.entries(Object.fromEntries(readModels)).map(param => [
+    param[0],
+    param[1].outputs
+  ]));
+}
+
+function createReadModels(readModels, api, apiRole, allEventTopics, opts) {
+  let readModels$1 = readModels.map(SpecificReadModel => {
+    let readModel = SpecificReadModel.make(api, apiRole, allEventTopics, opts);
+    let rmOutputs = SpecificReadModel.outputs(readModel);
+    let rmOperations = SpecificReadModel.operations(readModel);
+    rmOutputs.sourceNames.forEach(sourceName => {
+      let readModelNames = readModelNamesForSourceName[sourceName];
+      if (readModelNames !== undefined) {
+        readModelNamesForSourceName[sourceName] = readModelNames.concat([SpecificReadModel.Spec.name]);
+      } else {
+        readModelNamesForSourceName[sourceName] = [SpecificReadModel.Spec.name];
+      }
+    });
+    publishToReadModels[SpecificReadModel.Spec.name] = rmOperations.apply(param => param.enqueueEvent);
+    return [
+      SpecificReadModel.Spec.name,
+      {
+        outputs: rmOutputs,
+        operations: rmOperations,
+        finish: SpecificReadModel.finish
+      }
+    ];
+  });
+  finishReadModels(readModels$1);
+  return extractReadModelsOutputs(readModels$1);
+}
+
+function createExtensionPoints(extensionPoints, aggregateResources, publishToAggregates, scheduler, queryEngine, resourceNaming, opts) {
+  let triples = extensionPoints.map(SpecificExtensionPoint => {
+    let extensionPoint = SpecificExtensionPoint.make(aggregateResources, publishToAggregates, scheduler, queryEngine, resourceNaming, opts);
+    let ops = SpecificExtensionPoint.operations(extensionPoint);
+    let outputs = SpecificExtensionPoint.outputs(extensionPoint);
+    let registryInfo_specModule = outputs.specModule;
+    let registryInfo_mappingsModule = outputs.mappingsModule;
+    let registryInfo = {
+      specModule: registryInfo_specModule,
+      mappingsModule: registryInfo_mappingsModule
+    };
+    return [
+      outputs,
+      ops.apply(param => param.outgoingJsonEventsHandler),
+      registryInfo
+    ];
+  });
+  let outputs = triples.map(param => param[0]);
+  let handlers = triples.map(param => param[1]);
+  let registryInfos = triples.map(param => param[2]);
+  return [
+    outputs,
+    handlers,
+    registryInfos
+  ];
+}
+
+function createResolvers(allQueryDbs) {
+  return QueryDb$ReventlessCore.allResolversMakers(allQueryDbs).map(resolverMaker => resolverMaker(allQueryDbs)).flat();
+}
+
+export {
+  addEventMapperFns,
+  aggregateResources,
+  publishToAggregates,
+  aggregateFinishFns,
+  createAggregatesWithoutEventMappers,
+  finishAggregates,
+  addEventMappers,
+  readModelNamesForSourceName,
+  publishToReadModels,
+  finishReadModels,
+  extractReadModelsOutputs,
+  createReadModels,
+  createExtensionPoints,
+  createResolvers,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/Cloner.res

@@ -0,0 +1,84 @@
+let log = Logger.fromEnv()
+
+let componentType = ComponentType.Cloner
+
+type outputs = {resources: Pulumi.Output.t<array<ReventlessInfra.Adapter.resource>>}
+
+type fullQualifiedStackName = {
+  organization: string,
+  project: string,
+  stack: string,
+}
+
+type t
+type component = Component.t<t, outputs, unit>
+
+module type T = {
+  type api
+  let make: (~api: api, ~opts: Pulumi.ComponentResource.options=?) => component
+}
+
+module Adapter = {
+  type runner = {resources: Pulumi.Output.t<array<ReventlessInfra.Adapter.resource>>}
+  type runnerMaker<'api> = (
+    ~name: string,
+    ~api: 'api,
+    ~fullQualifiedStackName: fullQualifiedStackName,
+    ~reventlessCiSecretUrn: string,
+    ~secretUrns: array<string>,
+    ~opts: Pulumi.CustomResourceOptions.t=?,
+  ) => runner
+
+  module type Runner = {
+    type api
+
+    let make: runnerMaker<api>
+  }
+
+  let noRunner = {resources: []->Pulumi.Output.make}
+}
+
+module Make = (Runner: Adapter.Runner): (T with type api = Runner.api) => {
+  type api = Runner.api
+  let construct = (~api: Runner.api, self, name) => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let fullQualifiedStackName = {
+      organization: Env.pulumiOrganization->Option.getOr("NO_ORGANIZATION"),
+      project: Pulumi.Pulumi.getProjectName(),
+      stack: Pulumi.Pulumi.getStackName(),
+    }
+    let secretsConfig = Pulumi.Config.make(Some("secrets"))
+    let secretUrns =
+      ["aws", "pulumi", "repository"]->Array.map(str => Pulumi.Config.get(secretsConfig, str))
+    let reventlessCiSecretUrn = secretsConfig->Pulumi.Config.get("reventless-ci")
+
+    let runner = switch (secretUrns, reventlessCiSecretUrn) {
+    | ([Some(aws), Some(pulumi), Some(repository)], Some(reventlessCiSecretUrn)) =>
+      Runner.make(
+        ~name,
+        ~api,
+        ~fullQualifiedStackName,
+        ~reventlessCiSecretUrn,
+        ~secretUrns=[aws, pulumi, repository],
+        ~opts,
+      )
+
+    | _ =>
+      log.info(
+        ~comp="Cloner",
+        "No ClonerRunner created because no secrets are configured in Pulumi config !",
+      )
+      Adapter.noRunner
+    }
+    self->Component.setOutputs({resources: runner.resources})
+  }
+
+  let make = (~api: Runner.api, ~opts=?) =>
+    Component.make(
+      ~componentType=componentType->ComponentType.toString,
+      ~name=componentType->ComponentType.toString,
+      ~construct=construct(~api, ...),
+      ~opts,
+    )
+}

package/src/components/Cloner.res.mjs

@@ -0,0 +1,88 @@
+// 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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Logger$ReventlessCore from "../util/Logger.res.mjs";
+import * as Component$ReventlessCore from "./Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../ComponentType.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let noRunner = {
+  resources: Pulumi.output([])
+};
+
+let Adapter = {
+  noRunner: noRunner
+};
+
+function Make(Runner) {
+  let make = (api, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString("Cloner"), ComponentType$ReventlessCore.toString("Cloner"), (extra, extra$1) => {
+    let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+    let opts = {
+      parent: opts_parent
+    };
+    let fullQualifiedStackName_organization = Stdlib_Option.getOr(process.env.PULUMI_ORGANIZATION, "NO_ORGANIZATION");
+    let fullQualifiedStackName_project = Pulumi.getProject();
+    let fullQualifiedStackName_stack = Pulumi.getStack();
+    let fullQualifiedStackName = {
+      organization: fullQualifiedStackName_organization,
+      project: fullQualifiedStackName_project,
+      stack: fullQualifiedStackName_stack
+    };
+    let secretsConfig = new Pulumi.Config("secrets");
+    let secretUrns = [
+      "aws",
+      "pulumi",
+      "repository"
+    ].map(str => secretsConfig.get(str));
+    let reventlessCiSecretUrn = secretsConfig.get("reventless-ci");
+    let runner;
+    let exit = 0;
+    if (secretUrns.length !== 3) {
+      exit = 1;
+    } else {
+      let aws = secretUrns[0];
+      if (aws !== undefined) {
+        let pulumi = secretUrns[1];
+        if (pulumi !== undefined) {
+          let repository = secretUrns[2];
+          if (repository !== undefined && reventlessCiSecretUrn !== undefined) {
+            runner = Runner.make(extra$1, api, fullQualifiedStackName, Primitive_option.valFromOption(reventlessCiSecretUrn), [
+              aws,
+              pulumi,
+              repository
+            ], opts);
+          } else {
+            exit = 1;
+          }
+        } else {
+          exit = 1;
+        }
+      } else {
+        exit = 1;
+      }
+    }
+    if (exit === 1) {
+      log.info("Cloner", undefined, "No ClonerRunner created because no secrets are configured in Pulumi config !");
+      runner = noRunner;
+    }
+    return Component$ReventlessCore.setOutputs(extra, {
+      resources: runner.resources
+    });
+  }, opts);
+  return {
+    make: make
+  };
+}
+
+let componentType = "Cloner";
+
+export {
+  log,
+  componentType,
+  Adapter,
+  Make,
+}
+/* log Not a pure module */

package/src/components/CommandGenerator/CommandGenerator.res

@@ -0,0 +1,54 @@
+let componentType = ComponentType.CommandGenerator
+
+/**
+Resolver-supplied arguments for a command invocation.
+
+The `id` field is the envelope id for the produced command message:
+- For **Aggregates**, it is required — the resolver populates it from the
+  GraphQL `id: ID!` argument injected into the mutation SDL.
+- For **DCB StateChangeSlices**, it is optional. When the resolver does not
+  supply one, `makeGenerateCommand` derives the envelope id from the command's
+  `@partitionTag` / `@compositePartitionTag` field(s) using the same helpers
+  the slice itself uses for its decision-model partition key, so envelope id
+  and slice partition key share one source of truth.
+*/
+type arguments = {id: string}
+type meta = {ip: array<string>, user: string, info: string}
+type payload = {
+  command: string,
+  arguments: arguments,
+  meta: meta,
+  identity: Reventless.Identity.t,
+}
+external asPayload: 'a => payload = "%identity"
+type event = {meta?: meta}
+external asEvent: 'a => event = "%identity"
+
+let metaInfo = event => (event->asEvent).meta->Option.map(({info}) => info)
+
+type commandGenerator = payload => Effect.t<CommandTopic.commandOutcome, unit, unit>
+type effectEventHandler<'context> = Runtime.effectHandler<payload, 'context, CommandTopic.commandOutcome, unit>
+
+type publishJsons = CommandTopic.publishJsons
+
+type t
+type outputs = ReventlessInfra.CommandGenerator.outputs
+type component = Component.t<t, outputs, unit>
+
+module type T = {
+  type api
+  type runtimeParts
+  let connect: (
+    ~api: api,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    ~runtime: Runtime.environment<runtimeParts>,
+    component,
+  ) => unit
+
+  let makeHandler: (
+    ~publishJsons: publishJsons,
+    ~publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>,
+  ) => Pulumi.Output.t<effectEventHandler<'context>>
+
+  let make: (~name: string, ~opts: Pulumi.ComponentResource.options=?) => component
+}

package/src/components/CommandGenerator/CommandGenerator.res.mjs

@@ -0,0 +1,15 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function metaInfo(event) {
+  return Stdlib_Option.map(event.meta, param => param.info);
+}
+
+let componentType = "CommandGenerator";
+
+export {
+  componentType,
+  metaInfo,
+}
+/* No side effect */

package/src/components/CommandGenerator/CommandGenerator_Adapter.res

@@ -0,0 +1,22 @@
+type resolvers = {resources: array<ReventlessInfra.Adapter.resource>}
+
+type resolversMaker<'api, 'runtimeParts> = (
+  ~name: string,
+  ~api: 'api,
+  ~fields: array<string>,
+  ~commandSchema: S.t<unknown>,
+  ~runtime: Runtime.environment<'runtimeParts>,
+  ~resources: array<ReventlessInfra.Adapter.resource>,
+  ~opts: Pulumi.ComponentResource.options,
+) => resolvers
+
+module type Resolvers = {
+  type api
+  type runtimeParts
+
+  let handleResolversEvent: CommandGenerator.commandGenerator => Pulumi.Output.t<
+    Runtime.effectHandler<CommandGenerator.payload, 'context, CommandTopic.commandOutcome, unit>,
+  >
+
+  let make: resolversMaker<api, runtimeParts>
+}

package/src/components/CommandGenerator/CommandGenerator_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/CommandGenerator/CommandGenerator_Builder.res

@@ -0,0 +1,70 @@
+module Make = (
+  Spec: Reventless.Aggregate.Spec,
+  Resolvers: CommandGenerator_Adapter.Resolvers,
+): (
+  CommandGenerator.T with type runtimeParts := Resolvers.runtimeParts and type api := Resolvers.api
+) => {
+  let construct = (self, _name) => {
+    let resources = Plugin_Helpers.aggregateMutationFieldsRegistry->Dict.get(Spec.name)->Option.getOr([])->Array.map(field => {
+      let r: ReventlessInfra.Adapter.resource = {
+        id: ""->Pulumi.Output.make,
+        resourceInfo: ReventlessInfra.Adapter.ApiResolver({typeName: "Mutation", fieldName: field})->Pulumi.Output.make,
+        name: ""->Pulumi.Output.make,
+        urn: ""->Pulumi.Output.make,
+        service: ""->Pulumi.Output.make,
+        role: "commandGenerator"->Pulumi.Output.make,
+        region: ""->Pulumi.Output.make,
+        resourceType: ""->Pulumi.Output.make,
+        configuration: Dict.make()->Pulumi.Output.make,
+        tags: Dict.make()->Pulumi.Output.make,
+      }
+      r
+    })
+    let outputs: CommandGenerator.outputs = {resources: resources}
+    let _ = self->Component.setOutputs(outputs)
+  }
+
+  let connect = (~api: Resolvers.api, ~resources, ~runtime, commandGenerator) => {
+    let commandGeneratorResource = commandGenerator->Component.toPulumiResource
+    let name =
+      commandGeneratorResource.name
+      ->Option.getOr("Unnamed")
+      ->ComponentType.name(CommandGenerator.componentType)
+    let opts = {Pulumi.ComponentResource.parent: commandGeneratorResource}
+
+    let fields = Plugin_Helpers.aggregateMutationFieldsRegistry->Dict.get(Spec.name)->Option.getOr([])
+
+    let resolvers = Resolvers.make(
+      ~name,
+      ~api,
+      ~fields,
+      ~commandSchema=Spec.commandSchema->S.castToUnknown,
+      ~runtime,
+      ~resources,
+      ~opts,
+    )
+
+    let cgOutputs: CommandGenerator.outputs = {resources: resolvers.resources}
+    let _ = commandGenerator->Component.setOutputs(cgOutputs)
+  }
+
+  let makeHandler = (~publishJsons, ~publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>) => {
+    module Callback = CommandGenerator_Callback.Make(
+      {
+        let publishJsons = publishJsons
+        let publishJsonsAndWait = publishJsonsAndWait
+      },
+      Spec,
+    )
+
+    Resolvers.handleResolversEvent(Callback.generateCommand)
+  }
+
+  let make = (~name, ~opts=?): CommandGenerator.component =>
+    Component.make(
+      ~componentType=CommandGenerator.componentType->ComponentType.toString,
+      ~name,
+      ~construct,
+      ~opts,
+    )
+}