@reventlessdev/reventless-core 3.0.0-alpha.134

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

@@ -0,0 +1,68 @@
+// 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 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 CommandGenerator$ReventlessCore from "./CommandGenerator.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "./CommandGenerator_Callback.res.mjs";
+
+function Make(Spec) {
+  return Resolvers => {
+    let construct = (self, _name) => {
+      let resources = Stdlib_Option.getOr(Plugin_Helpers$ReventlessCore.aggregateMutationFieldsRegistry[Spec.name], []).map(field => ({
+        name: Pulumi.output(""),
+        id: Pulumi.output(""),
+        urn: Pulumi.output(""),
+        resourceInfo: Pulumi.output({
+          TAG: "ApiResolver",
+          typeName: "Mutation",
+          fieldName: field
+        }),
+        service: Pulumi.output(""),
+        role: Pulumi.output("commandGenerator"),
+        region: Pulumi.output(""),
+        resourceType: Pulumi.output(""),
+        configuration: Pulumi.output({}),
+        tags: Pulumi.output({})
+      }));
+      let outputs = {
+        resources: resources
+      };
+      Component$ReventlessCore.setOutputs(self, outputs);
+    };
+    let connect = (api, resources, runtime, commandGenerator) => {
+      let commandGeneratorResource = Component$ReventlessCore.toPulumiResource(commandGenerator);
+      let name = ComponentType$ReventlessCore.name(Stdlib_Option.getOr(commandGeneratorResource.__name, "Unnamed"), CommandGenerator$ReventlessCore.componentType);
+      let opts_parent = commandGeneratorResource;
+      let opts = {
+        parent: opts_parent
+      };
+      let fields = Stdlib_Option.getOr(Plugin_Helpers$ReventlessCore.aggregateMutationFieldsRegistry[Spec.name], []);
+      let resolvers = Resolvers.make(name, api, fields, Spec.commandSchema, runtime, resources, opts);
+      let cgOutputs = {
+        resources: resolvers.resources
+      };
+      Component$ReventlessCore.setOutputs(commandGenerator, cgOutputs);
+    };
+    let makeHandler = (publishJsons, publishJsonsAndWait) => {
+      let Callback = CommandGenerator_Callback$ReventlessCore.Make({
+        publishJsons: publishJsons,
+        publishJsonsAndWait: publishJsonsAndWait
+      })(Spec);
+      return Resolvers.handleResolversEvent(Callback.generateCommand);
+    };
+    let make = (name, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(CommandGenerator$ReventlessCore.componentType), name, construct, opts);
+    return {
+      connect: connect,
+      makeHandler: makeHandler,
+      make: make
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/CommandGenerator/CommandGenerator_Callback.res

@@ -0,0 +1,191 @@
+type interceptResult = Allow | Deny(string)
+
+type commandComponentKind = Aggregate | StateChangeSlice
+
+type commandInterceptor = (
+  ~identity: Reventless.Identity.t,
+  ~componentName: string,
+  ~componentKind: commandComponentKind,
+  ~tag: string,
+  ~args: JSON.t,
+) => promise<interceptResult>
+
+/** Module-level interceptor hook. None = passthrough (default). */
+let commandInterceptorHook: ref<option<commandInterceptor>> = ref(None)
+
+let registerCommandInterceptor = (interceptor: commandInterceptor) => {
+  commandInterceptorHook.contents = Some(interceptor)
+}
+
+let clearCommandInterceptor = () => {
+  commandInterceptorHook.contents = None
+}
+
+module type Spec = {
+  let publishJsons: CommandGenerator.publishJsons
+  let publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>
+}
+
+module type T = {
+  let generateCommand: CommandGenerator.commandGenerator
+}
+
+let makeGenerateCommand = (
+  ~publishJsons: CommandGenerator.publishJsons,
+  ~publishJsonsAndWait: option<CommandTopic.publishJsonsAndWait>=?,
+  ~serviceName: string,
+  ~commandSchema: S.t<unknown>,
+  ~componentKind: commandComponentKind,
+  ~stripIdFromParams: bool=true,
+): CommandGenerator.commandGenerator => {
+  (payload: CommandGenerator.payload) =>
+    Effect.sync(() => {
+      let msgId = Message.uuid()
+      let meta = {
+        {
+          Message.service: serviceName,
+          ip: payload.meta.ip->Array.shift->Option.getOr(""),
+          user: payload.meta.user,
+          time: Message.nowAsISOString(),
+          msgId,
+          correlationId: msgId,
+        }
+      }
+      let params = switch payload.arguments
+      ->JSON.stringifyAny
+      ->Option.flatMap(jsonString => jsonString->JSON.parseOrThrow->JSON.Decode.object) {
+      | Some(obj) => {
+          if stripIdFromParams {
+            obj->Dict.delete("id")
+          }
+          obj->Dict.toArray
+        }
+      | None =>
+        JsError.throwWithMessage(
+          "Couldn't decode:" ++
+          payload.arguments
+          ->JSON.stringifyAny
+          ->Option.getOr("<payload.arguments>"),
+        )
+      }
+      let commandStr = JSON.Encode.string(payload.command)
+      let commandJson = switch params->Array.length {
+      | 0 => commandStr
+      | _ => [("TAG", commandStr)]->Array.concat(params)->Dict.fromArray->JSON.Encode.object
+      }
+      // Resolve the envelope id.
+      // - Aggregates always rely on the resolver-supplied id (id: ID! arg in SDL).
+      // - DCB StateChangeSlices fall back to deriving the id from the command's
+      //   partition tag(s) when the resolver didn't supply one — this is what makes
+      //   @compositePartitionTag work end-to-end without per-call-site id stuffing.
+      let suppliedId = payload.arguments.id
+      let id = switch componentKind {
+      | Aggregate => suppliedId
+      | StateChangeSlice =>
+        switch (suppliedId->Obj.magic: Nullable.t<string>)->Nullable.toOption {
+        | Some(idValue) => idValue
+        | None =>
+          try {
+            let derived = Reventless.DcbTag.derivePartitionTag([
+              (serviceName, "", commandSchema),
+            ])
+            switch derived {
+            | Simple(pt) =>
+              let tags = Reventless.DcbTag.extractTagsFromJson(commandSchema, commandJson)
+              Reventless.DcbTag.getPartitionTagValue([{tags: tags}], pt)->Option.getOr("")
+            | Composite(spec) =>
+              let tags = Reventless.DcbTag.extractTagsFromJson(commandSchema, commandJson)
+              Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec)
+            }
+          } catch {
+          // Permissive schemas (e.g. S.json on the AppSync direct-invocation path)
+          // have no tagged fields — derivePartitionTag throws. Fall back to "" so
+          // existing transports keep their pre-fix behavior; the slice decoder
+          // surfaces the missing id downstream as it did before.
+          | _ => ""
+          }
+        }
+      }
+      (meta, commandJson, id)
+    })
+    ->Effect.tap(((_, commandJson, _id)) =>
+      // Render `Name({fields})` without the standalone id: it's the command's
+      // partition-tag value, already shown among the fields, so a leading
+      // `(id)` would just duplicate it.
+      EffectLogger.logInfo(
+        ~comp=`CommandGenerator(${serviceName})`,
+        ~detail=commandJson,
+        `generated command: ${commandJson->LogFormat.cmdLabelOfJson}`,
+      )
+    )
+    ->Effect.flatMap(((meta, commandJson, id)) => {
+      switch commandJson->Message.decode(commandSchema) {
+      | _ =>
+        let interceptEffect = switch commandInterceptorHook.contents {
+        | Some(interceptor) =>
+          Effect.promise(() =>
+            interceptor(
+              ~identity=payload.identity,
+              ~componentName=serviceName,
+              ~componentKind,
+              ~tag=payload.command,
+              ~args=payload.arguments->Obj.magic,
+            )
+          )
+        | None => Effect.succeed(Allow)
+        }
+        interceptEffect->Effect.flatMap(interceptResult =>
+          switch interceptResult {
+          | Allow =>
+            switch publishJsonsAndWait {
+            | Some(publishAndWait) =>
+              Effect.promise(() => publishAndWait([{id, meta, commandJson}]))
+              ->Effect.map(outcomes => {
+                // For aggregates, entityId comes from the envelope id.
+                // DCB slices populate entityId via the side-channel; don't override it.
+                switch outcomes->Array.getUnsafe(0) {
+                | CommandTopic.Accepted(payload) when payload.entityId->Option.isNone =>
+                  CommandTopic.Accepted({...payload, entityId: id})
+                | outcome => outcome
+                }
+              })
+            | None =>
+              Effect.promise(() => publishJsons([{id, meta, commandJson}]))
+              ->Effect.map(_ => CommandTopic.Pending({msgId: meta.msgId}))
+            }
+          | Deny(msg) =>
+            JsError.throwWithMessage(msg)
+          }
+        )
+      | exception err =>
+        switch Plugin_ResolverError.onResolverErrorHook.contents {
+        | Some(hook) =>
+          hook({
+            pluginName: "",
+            componentName: serviceName,
+            attemptedCommandType: commandJson->Message.variantNameOfJson,
+            timestamp: Message.nowAsISOString(),
+          })
+        | None => ()
+        }
+        JsError.throwWithMessage(
+          `Error: Couldn't decode ${commandJson->JSON.stringify}: ${err
+            ->JSON.stringifyAny
+            ->Option.getOrThrow}`,
+        )
+      }
+    })
+}
+
+module Make = (
+  Spec: Spec,
+  AggregateSpec: Reventless.Aggregate.Spec,
+): T => {
+  let generateCommand = makeGenerateCommand(
+    ~publishJsons=Spec.publishJsons,
+    ~publishJsonsAndWait=?Spec.publishJsonsAndWait,
+    ~serviceName=AggregateSpec.name,
+    ~commandSchema=AggregateSpec.commandSchema->S.castToUnknown,
+    ~componentKind=Aggregate,
+  )
+}

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

@@ -0,0 +1,161 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as Plugin_ResolverError$ReventlessCore from "../../plugin/component/Plugin_ResolverError.res.mjs";
+
+let commandInterceptorHook = {
+  contents: undefined
+};
+
+function registerCommandInterceptor(interceptor) {
+  commandInterceptorHook.contents = interceptor;
+}
+
+function clearCommandInterceptor() {
+  commandInterceptorHook.contents = undefined;
+}
+
+function makeGenerateCommand(publishJsons, publishJsonsAndWait, serviceName, commandSchema, componentKind, $staropt$star) {
+  return payload => {
+    let stripIdFromParams = $staropt$star !== undefined ? $staropt$star : true;
+    return Effect.flatMap(Effect.tap(Effect.sync(() => {
+      let msgId = Message$ReventlessCore.uuid();
+      let meta_time = Message$ReventlessCore.nowAsISOString();
+      let meta_ip = Stdlib_Option.getOr(payload.meta.ip.shift(), "");
+      let meta_user = payload.meta.user;
+      let meta = {
+        service: serviceName,
+        time: meta_time,
+        ip: meta_ip,
+        user: meta_user,
+        msgId: msgId,
+        correlationId: msgId
+      };
+      let obj = Stdlib_Option.flatMap(JSON.stringify(payload.arguments), jsonString => Stdlib_JSON.Decode.object(JSON.parse(jsonString)));
+      let params = obj !== undefined ? (stripIdFromParams ? Stdlib_Dict.$$delete(obj, "id") : undefined, Object.entries(obj)) : Stdlib_JsError.throwWithMessage("Couldn't decode:" + Stdlib_Option.getOr(JSON.stringify(payload.arguments), "<payload.arguments>"));
+      let commandStr = payload.command;
+      let match = params.length;
+      let commandJson = match !== 0 ? Object.fromEntries([[
+            "TAG",
+            commandStr
+          ]].concat(params)) : commandStr;
+      let suppliedId = payload.arguments.id;
+      let id;
+      if (componentKind === "Aggregate" || !(suppliedId == null)) {
+        id = suppliedId;
+      } else {
+        try {
+          let derived = DcbTag$Reventless.derivePartitionTag([[
+              serviceName,
+              "",
+              commandSchema
+            ]]);
+          if (derived.TAG === "Simple") {
+            let tags = DcbTag$Reventless.extractTagsFromJson(commandSchema, commandJson);
+            id = Stdlib_Option.getOr(DcbTag$Reventless.getPartitionTagValue([{
+                tags: tags
+              }], derived._0), "");
+          } else {
+            let tags$1 = DcbTag$Reventless.extractTagsFromJson(commandSchema, commandJson);
+            id = DcbTag$Reventless.getCompositePartitionKeyValue(tags$1, derived._0);
+          }
+        } catch (exn) {
+          id = "";
+        }
+      }
+      return [
+        meta,
+        commandJson,
+        id
+      ];
+    }), param => {
+      let commandJson = param[1];
+      return EffectLogger$ReventlessCore.logInfo(`CommandGenerator(` + serviceName + `)`, commandJson, `generated command: ` + LogFormat$ReventlessCore.cmdLabelOfJson(commandJson));
+    }), param => {
+      let id = param[2];
+      let commandJson = param[1];
+      let meta = param[0];
+      let val;
+      try {
+        val = Message$ReventlessCore.decode(commandJson, commandSchema);
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        let hook = Plugin_ResolverError$ReventlessCore.onResolverErrorHook.contents;
+        if (hook !== undefined) {
+          hook({
+            pluginName: "",
+            componentName: serviceName,
+            attemptedCommandType: Message$ReventlessCore.variantNameOfJson(commandJson),
+            timestamp: Message$ReventlessCore.nowAsISOString()
+          });
+        }
+        return Stdlib_JsError.throwWithMessage(`Error: Couldn't decode ` + JSON.stringify(commandJson) + `: ` + Stdlib_Option.getOrThrow(JSON.stringify(err), undefined));
+      }
+      let interceptor = commandInterceptorHook.contents;
+      let interceptEffect = interceptor !== undefined ? Effect.promise(() => interceptor(payload.identity, serviceName, componentKind, payload.command, payload.arguments)) : Effect.succeed("Allow");
+      return Effect.flatMap(interceptEffect, interceptResult => {
+        if (typeof interceptResult !== "object") {
+          if (publishJsonsAndWait !== undefined) {
+            return Effect.map(Effect.promise(() => publishJsonsAndWait([{
+                id: id,
+                meta: meta,
+                commandJson: commandJson
+              }])), outcomes => {
+              let payload = outcomes[0];
+              switch (payload.TAG) {
+                case "Accepted" :
+                  if (!Stdlib_Option.isNone(payload.entityId)) {
+                    return payload;
+                  }
+                  let newrecord = {...payload};
+                  newrecord.entityId = id;
+                  return newrecord;
+                case "Rejected" :
+                case "Pending" :
+                  return payload;
+              }
+            });
+          } else {
+            return Effect.map(Effect.promise(() => publishJsons([{
+                id: id,
+                meta: meta,
+                commandJson: commandJson
+              }])), () => ({
+              TAG: "Pending",
+              msgId: meta.msgId
+            }));
+          }
+        } else {
+          return Stdlib_JsError.throwWithMessage(interceptResult._0);
+        }
+      });
+    });
+  };
+}
+
+function Make(Spec) {
+  return AggregateSpec => {
+    let generateCommand = makeGenerateCommand(Spec.publishJsons, Spec.publishJsonsAndWait, AggregateSpec.name, AggregateSpec.commandSchema, "Aggregate", undefined);
+    return {
+      generateCommand: generateCommand
+    };
+  };
+}
+
+export {
+  commandInterceptorHook,
+  registerCommandInterceptor,
+  clearCommandInterceptor,
+  makeGenerateCommand,
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/components/CommandTopic/CommandTopic.res

@@ -0,0 +1,79 @@
+let componentType = ComponentType.CommandTopic
+
+type outputs = ReventlessInfra.CommandTopic.outputs
+type allOutputs = ReventlessInfra.CommandTopic.allOutputs
+
+type t
+type component<'operations> = Component.t<t, outputs, 'operations>
+
+exception NotPublishedToChannel(exn)
+
+include CommandTopic_Helpers
+
+type publish<'id, 'command> = Message.command'<'id, 'command> => promise<unit>
+type publishJsons = ReventlessInfra.CommandTopic.publishJsons
+type publishJsonsStream = ReventlessInfra.CommandTopic.publishJsonsStream
+
+type commandsHandler<'command> = ReventlessInfra.CommandTopic.commandsHandler<'command>
+
+module type T = {
+  module Spec: ReventlessInfra.CommandTopic.T
+  type callbackEvent
+
+  type publish = publish<Spec.Id.t, Spec.command>
+
+  type operations = {
+    publish: publish,
+    publishJsons: publishJsons,
+    publishJsonsStream: ReventlessInfra.CommandTopic.publishJsonsStream,
+    publishJsonsAndWait: option<publishJsonsAndWait>,
+  }
+  type component = component<operations>
+
+  type commandsHandler = commandsHandler<Message.command'<Spec.Id.t, Spec.command>>
+
+  let connect: (
+    ~runtime: Runtime.environment<'runtimeParts>,
+    ~resources: array<ReventlessInfra.Adapter.resource>,
+    component,
+  ) => unit
+
+  let registerHandler: (
+    ~commandTopic: component,
+    ~schema: S.t<unknown>,
+    ~handler: jsonCommandsHandler,
+    ~typeNames: array<string>,
+  ) => unit
+
+  let makeHandler: (
+    ~commandTopic: component,
+    ~commandsHandler: commandsHandler,
+  ) => Pulumi.Output.t<Runtime.effectHandler<callbackEvent, 'context, unit, string>>
+
+  // Returns the filtering handler output for runtime connection
+  // Registers the handler with the channel's event routing
+  let makeFilteringHandler: component => Pulumi.Output.t<
+    Runtime.effectHandler<callbackEvent, 'context, unit, string>,
+  >
+
+  let make: (~name: string, ~opts: Pulumi.ComponentResource.options=?) => component
+}
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.CommandTopic.resolvedOutputs> =>
+  outputs.resources
+  ->Adapter.resourcesToInterop
+  ->Pulumi.Output.apply(resources => {
+    let resolved: ReventlessInterop.CommandTopic.resolvedOutputs = {resources: resources}
+    resolved
+  })
+
+let filter = (allCommandTopics: allOutputs, names) =>
+  names
+  ->Set.values
+  ->Iterator.toArray
+  ->Array.filterMap(name =>
+    allCommandTopics->Dict.get(name)->Option.map(commandTopic => (name, commandTopic))
+  )
+  ->Dict.fromArray

package/src/components/CommandTopic/CommandTopic.res.mjs

@@ -0,0 +1,68 @@
+// 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "./CommandTopic_Helpers.res.mjs";
+
+let NotPublishedToChannel = /* @__PURE__ */Primitive_exceptions.create("CommandTopic-ReventlessCore.NotPublishedToChannel");
+
+function toResolvedOutputs(outputs) {
+  return Adapter$ReventlessCore.resourcesToInterop(outputs.resources).apply(resources => ({
+    resources: resources
+  }));
+}
+
+function filter(allCommandTopics, names) {
+  return Object.fromEntries(Stdlib_Array.filterMap(names.values().toArray(), name => Stdlib_Option.map(allCommandTopics[name], commandTopic => [
+    name,
+    commandTopic
+  ])));
+}
+
+let componentType = "CommandTopic";
+
+let acceptedResultChannel = CommandTopic_Helpers$ReventlessCore.acceptedResultChannel;
+
+let rejectedResultChannel = CommandTopic_Helpers$ReventlessCore.rejectedResultChannel;
+
+let reportAccepted = CommandTopic_Helpers$ReventlessCore.reportAccepted;
+
+let reportRejected = CommandTopic_Helpers$ReventlessCore.reportRejected;
+
+let commandOutcomeToJson = CommandTopic_Helpers$ReventlessCore.commandOutcomeToJson;
+
+let encodeCommandJson = CommandTopic_Helpers$ReventlessCore.encodeCommandJson;
+
+let runInlineAndCollect = CommandTopic_Helpers$ReventlessCore.runInlineAndCollect;
+
+let callHandlerWithArray = CommandTopic_Helpers$ReventlessCore.callHandlerWithArray;
+
+let extractTypeNamesFromSchema = CommandTopic_Helpers$ReventlessCore.extractTypeNamesFromSchema;
+
+let globalRegistry = CommandTopic_Helpers$ReventlessCore.globalRegistry;
+
+let registerHandler = CommandTopic_Helpers$ReventlessCore.registerHandler;
+
+let getHandlers = CommandTopic_Helpers$ReventlessCore.getHandlers;
+
+export {
+  componentType,
+  NotPublishedToChannel,
+  acceptedResultChannel,
+  rejectedResultChannel,
+  reportAccepted,
+  reportRejected,
+  commandOutcomeToJson,
+  encodeCommandJson,
+  runInlineAndCollect,
+  callHandlerWithArray,
+  extractTypeNamesFromSchema,
+  globalRegistry,
+  registerHandler,
+  getHandlers,
+  toResolvedOutputs,
+  filter,
+}
+/* Adapter-ReventlessCore Not a pure module */

package/src/components/CommandTopic/CommandTopic_Adapter.res

@@ -0,0 +1,53 @@
+type rec connect<'callbackEvent, 'context, 'channelParts, 'runtimeParts> = (
+  ~name: string,
+  ~channel: channel<'callbackEvent, 'context, 'channelParts, 'runtimeParts>,
+  ~runtime: Runtime.environment<'runtimeParts>,
+  ~resources: array<ReventlessInfra.Adapter.resource>,
+  ~opts: Pulumi.ComponentResource.options,
+) => array<ReventlessInfra.Adapter.resource>
+and channel<'callbackEvent, 'context, 'channelParts, 'runtimeParts> = {
+  parts: 'channelParts,
+  resources: array<ReventlessInfra.Adapter.resource>,
+  publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+  publishJsonsStream: Pulumi.Output.t<ReventlessInfra.CommandTopic.publishJsonsStream>,
+  publishJsonsAndWait: Pulumi.Output.t<option<CommandTopic.publishJsonsAndWait>>,
+  handleChannelEvent: CommandTopic.jsonCommandsHandler => Pulumi.Output.t<
+    Runtime.effectHandler<'callbackEvent, 'context, unit, string>,
+  >,
+  connect: connect<'callbackEvent, 'context, 'channelParts, 'runtimeParts>,
+}
+
+@set
+external setChannel: (
+  Component.t<CommandTopic.t, CommandTopic.outputs, 'operations>,
+  channel<'callbackEvent, 'context, 'channelParts, 'runtimeParts>,
+) => unit = "channel"
+@get
+external channel: Component.t<CommandTopic.t, CommandTopic.outputs, 'operations> => channel<
+  'callbackEvent,
+  'context,
+  'channelParts,
+  'runtimeParts,
+> = "channel"
+
+type channelMaker<'callbackEvent, 'context, 'channelParts, 'runtimeParts> = (
+  ~name: string,
+  ~opts: Pulumi.ComponentResource.options=?,
+) => channel<'callbackEvent, 'context, 'channelParts, 'runtimeParts>
+
+module type Channel = {
+  type callbackEvent
+  type runtimeParts
+  type channelParts
+  let make: channelMaker<callbackEvent, 'context, channelParts, runtimeParts>
+}
+
+type remoteChannel = {
+  resources: array<ReventlessInfra.Adapter.resolvedResource>,
+  remotePublish: CommandTopic.publishJsons,
+}
+type remoteChannelMaker = array<ReventlessInfra.Adapter.resolvedResource> => remoteChannel
+
+module type RemoteChannel = {
+  let make: remoteChannelMaker
+}

package/src/components/CommandTopic/CommandTopic_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. */