@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_AppSync.res

@@ -0,0 +1,251 @@
+type api = Types.AppSync.api
+type runtimeParts = Util.Lambda.runtimeParts
+
+let handleResolversEvent = (generateCommand: ReventlessCore.CommandGenerator.commandGenerator) =>
+  Pulumi.Output.make((event, _context) => event->generateCommand)
+
+let make: ReventlessCore.CommandGenerator_Adapter.resolversMaker<api, Util.Lambda.runtimeParts> = (
+  ~name: string,
+  ~api: api,
+  ~fields,
+  ~commandSchema as _,
+  ~runtime,
+  ~resources: array<ReventlessInfra.Adapter.resource>,
+  ~opts,
+) => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let lambda = runtime.parts.lambda
+  let lambdaRole = runtime.parts.lambdaRole
+
+  let dataSourceRole = PulumiAws.IAM.Role.makeWithDefaultPolicy(
+    ~name=name ++ "DataSource",
+    ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
+    ~opts,
+  )
+
+  let _ =
+    (
+      lambda->Pulumi.Output.flatMap(lambda => lambda.arn),
+      lambda->Pulumi.Output.flatMap(lambda => lambda.name),
+      lambdaRole.id,
+      resources->ReventlessCore.Adapter.resourcesToResolvedOutput,
+    )
+    ->Pulumi.Output.all4
+    ->Pulumi.Output.apply(((lambdaArn, lambdaName, lambdaRoleId, resources)) => {
+      open PulumiAws.PolicyDocument
+      open ReventlessCore.Adapter
+
+      // Console..log2(`CommandGeneratorResolvers_AppSync: Resources for ${name}:`, resources)
+
+      let targetSqsResources =
+        resources->ReventlessCore.Util.Adapter.filterSupportedResolvedResources([
+          AWS.SQS.service,
+          AWS.SQS_FIFO.service,
+        ])
+
+      let lambdaSqsSendPolicyDocument =
+        targetSqsResources->Array.length > 0
+          ? {
+              Some(
+                PulumiAws.PolicyDocument.make(
+                  ~id=name ++ "SendSQS",
+                  ~statements=[
+                    {
+                      sid: "LambdaAllowSendSQS",
+                      effect: Allow,
+                      actions: Action("sqs:SendMessage"),
+                      resources: Resources(targetSqsResources->urns),
+                    },
+                  ],
+                ),
+              )
+            }
+          : None
+
+      let _lambdaPolicy = {
+        PulumiAws.IAM.RolePolicy.make(
+          ~name,
+          ~args={
+            policy: PulumiAws.PolicyDocument.mergePolicyDocuments(
+              name ++ "LambdaPolicy",
+              [
+                Some(PulumiAws.Lambda.defaultLoggingPolicyDocument),
+                lambdaSqsSendPolicyDocument,
+              ]->Array.keepSome,
+            )->Pulumi.Output.asInput,
+            role: lambdaRoleId->Pulumi.Input.make,
+          },
+          ~opts,
+        )
+      }
+
+      let _addCommandGeneratorPermission = PulumiAws.Lambda.Permission.make(
+        ~name,
+        ~args={
+          action: "lambda:InvokeFunction",
+          function: lambdaName->Pulumi.Input.make,
+          principal: AWS.CloudwatchEventRule.principal,
+        },
+        ~opts,
+      )
+
+      let _attachDataSourcePolicy = PulumiAws.IAM.RolePolicy.make(
+        ~name=name ++ "DataSource",
+        ~args={
+          PulumiAws.IAM.RolePolicy.policy: PulumiAws.PolicyDocument.make(
+            ~id=name ++ "DataSourcePolicy",
+            ~statements=[
+              {
+                sid: "AllowCloudWatchDataSourceInvokeLambda",
+                effect: Allow,
+                actions: Action("lambda:InvokeFunction"),
+                resources: Resource(lambdaArn),
+              },
+            ],
+          )
+          ->toJsonString
+          ->Pulumi.Input.make,
+          role: dataSourceRole.id->Pulumi.Output.asInput,
+        },
+        ~opts,
+      )
+    })
+
+  let dataSource = PulumiAws.AppSync.DataSource.make(
+    ~name,
+    ~args={
+      type_: AWS_LAMBDA,
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      lambdaConfig: {
+        PulumiAws.AppSync.DataSource.functionArn: lambda
+        ->Pulumi.Output.flatMap(lambda => lambda.arn)
+        ->Pulumi.Output.asInput,
+      }->Pulumi.Input.make,
+      serviceRoleArn: dataSourceRole.arn->Pulumi.Output.asInput,
+    },
+    ~opts=Some(opts),
+  )
+
+  let resolvers = fields->Array.map(field => {
+    // Extract command name: last segment after splitting on "_".
+    // Handles both old ("Aggregate_Command") and prefixed ("Plugin_Aggregate_Command") formats.
+    let commandName = {
+      let parts = field->String.split("_")
+      parts->Array.get(parts->Array.length - 1)->Option.getOr(field)->String.capitalize
+    }
+    AppSync_Resolver_Retrying.makeUnitJsResolver(
+      ~name=field->String.capitalize,
+      ~api,
+      ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+      ~type_="Mutation"->Pulumi.Input.make,
+      ~field=field->Pulumi.Input.make,
+      ~code=PulumiAws.AppSync.Resolver.Functions.invokeCommandGenerator(commandName),
+      ~opts,
+    )
+  })
+
+  // Source C: create Subscription.onX resolver for each mutation field.
+  // @aws_subscribe in the SDL (emitted by Plugin_SubscriptionSchema) handles
+  // delivery. AWS requires a dataSourceName even on UNIT subscription resolvers,
+  // so we reuse the mutation's data source (its code never executes for subs).
+  CommandSubscriptionResolvers_AppSync.make(
+    ~api,
+    ~mutationFields=fields,
+    ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+    ~opts,
+  )
+
+  let resources = resolvers->Array.map(Util_AppSync.toResourceNative)
+
+  {resources: resources}
+}
+
+// -- makeDcb (DCB StateChangeSlice mutations) --------------------------------
+// Creates an AppSync DataSource + Resolver per DCB mutation field, pointing to
+// the shared DCB CommandTopic Lambda. Unlike aggregate mutations, the TAG comes
+// from the schema (not the field name), and there is no id: ID! parameter.
+// The Lambda handler detects the CommandGenerator.payload format and runs
+// makeGenerateCommand → publishJsons before returning the msgId.
+
+let makeDcb = (
+  ~api: api,
+  ~runtime: ReventlessCore.Runtime.environment<runtimeParts>,
+  ~fieldNames: array<string>,
+  ~tags: array<string>,
+  ~opts: Pulumi.ComponentResource.options,
+) => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let lambda = runtime.parts.lambda
+
+  let dataSourceRole = PulumiAws.IAM.Role.makeWithDefaultPolicy(
+    ~name="DcbMutationDS",
+    ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
+    ~opts,
+  )
+
+  let _ =
+    (
+      lambda->Pulumi.Output.flatMap(lambda => lambda.arn),
+      dataSourceRole.id,
+    )
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((lambdaArn, dataSourceRoleId)) => {
+      let _attachDataSourcePolicy = PulumiAws.IAM.RolePolicy.make(
+        ~name="DcbMutationDS",
+        ~args={
+          PulumiAws.IAM.RolePolicy.policy: PulumiAws.PolicyDocument.make(
+            ~id="DcbMutationDSPolicy",
+            ~statements=[
+              {
+                sid: "AllowDcbMutationInvokeLambda",
+                effect: Allow,
+                actions: Action("lambda:InvokeFunction"),
+                resources: Resource(lambdaArn),
+              },
+            ],
+          )
+          ->PulumiAws.PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: dataSourceRoleId->Pulumi.Input.make,
+        },
+        ~opts,
+      )
+    })
+
+  let dataSource = PulumiAws.AppSync.DataSource.make(
+    ~name="DcbMutation",
+    ~args={
+      type_: AWS_LAMBDA,
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      lambdaConfig: {
+        PulumiAws.AppSync.DataSource.functionArn: lambda
+        ->Pulumi.Output.flatMap(lambda => lambda.arn)
+        ->Pulumi.Output.asInput,
+      }->Pulumi.Input.make,
+      serviceRoleArn: dataSourceRole.arn->Pulumi.Output.asInput,
+    },
+    ~opts=Some(opts),
+  )
+
+  let _resolvers = Array.zip(fieldNames, tags)->Array.forEach(((fieldName, tag)) => {
+    let _ = AppSync_Resolver_Retrying.makeUnitJsResolver(
+      ~name=fieldName->String.capitalize,
+      ~api,
+      ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+      ~type_="Mutation"->Pulumi.Input.make,
+      ~field=fieldName->Pulumi.Input.make,
+      ~code=PulumiAws.AppSync.Resolver.Functions.invokeDcbMutation(tag),
+      ~opts,
+    )
+  })
+
+  // Source C: create Subscription.onX resolver for each DCB mutation field.
+  CommandSubscriptionResolvers_AppSync.make(
+    ~api,
+    ~mutationFields=fieldNames,
+    ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+    ~opts,
+  )
+}

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_AppSync.res.mjs

@@ -0,0 +1,126 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
+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 Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.res.mjs";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
+import * as Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Adapter.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as Util_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Adapter.res.mjs";
+import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
+import * as AppSync_Resolver_Retrying$ReventlessAws from "../Api/AppSync_Resolver_Retrying.res.mjs";
+import * as CommandSubscriptionResolvers_AppSync$ReventlessAws from "../Api/CommandSubscriptionResolvers_AppSync.res.mjs";
+
+function handleResolversEvent(generateCommand) {
+  return Pulumi.output((event, _context) => generateCommand(event));
+}
+
+function make(name, api, fields, param, runtime, resources, opts) {
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let lambda = runtime.parts.lambda;
+  let lambdaRole = runtime.parts.lambdaRole;
+  let dataSourceRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "DataSource", Pulumi.output(AWS$ReventlessAws.AppSync.principal), opts$1);
+  Pulumi.all([
+    Output$Pulumi.flatMap(lambda, lambda => lambda.arn),
+    Output$Pulumi.flatMap(lambda, lambda => lambda.name),
+    lambdaRole.id,
+    Adapter$ReventlessCore.resourcesToResolvedOutput(resources)
+  ]).apply(param => {
+    let targetSqsResources = Util_Adapter$ReventlessCore.filterSupportedResolvedResources(param[3], [
+      AWS$ReventlessAws.SQS.service,
+      AWS$ReventlessAws.SQS_FIFO.service
+    ]);
+    let lambdaSqsSendPolicyDocument = targetSqsResources.length !== 0 ? PolicyDocument$PulumiAws.make(undefined, name + "SendSQS", [{
+          Sid: "LambdaAllowSendSQS",
+          Effect: "Allow",
+          Action: "sqs:SendMessage",
+          Resource: Adapter$ReventlessCore.urns(targetSqsResources)
+        }]) : undefined;
+    new (Aws.iam.RolePolicy)(name, {
+      policy: PolicyDocument$PulumiAws.mergePolicyDocuments(name + "LambdaPolicy", Stdlib_Array.keepSome([
+        Lambda$PulumiAws.defaultLoggingPolicyDocument,
+        lambdaSqsSendPolicyDocument
+      ])),
+      role: param[2]
+    }, opts$1);
+    new (Aws.lambda.Permission)(name, {
+      action: "lambda:InvokeFunction",
+      function: param[1],
+      principal: AWS$ReventlessAws.CloudwatchEventRule.principal
+    }, opts$1);
+    new (Aws.iam.RolePolicy)(name + "DataSource", {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "DataSourcePolicy", [{
+          Sid: "AllowCloudWatchDataSourceInvokeLambda",
+          Effect: "Allow",
+          Action: "lambda:InvokeFunction",
+          Resource: param[0]
+        }])),
+      role: dataSourceRole.id
+    }, opts$1);
+  });
+  let dataSource = new (Aws.appsync.DataSource)(name, {
+    type: "AWS_LAMBDA",
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    lambdaConfig: {
+      functionArn: Output$Pulumi.flatMap(lambda, lambda => lambda.arn)
+    },
+    serviceRoleArn: dataSourceRole.arn
+  }, opts$1);
+  let resolvers = fields.map(field => {
+    let parts = field.split("_");
+    let commandName = Stdlib_String.capitalize(Stdlib_Option.getOr(parts[parts.length - 1 | 0], field));
+    return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(Stdlib_String.capitalize(field), api, dataSource.name, "Mutation", field, AppSync_Resolver_Functions$PulumiAws.invokeCommandGenerator(commandName), opts$1);
+  });
+  CommandSubscriptionResolvers_AppSync$ReventlessAws.make(api, fields, dataSource.name, opts$1);
+  let resources$1 = resolvers.map(Util_AppSync$ReventlessAws.toResourceNative);
+  return {
+    resources: resources$1
+  };
+}
+
+function makeDcb(api, runtime, fieldNames, tags, opts) {
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let lambda = runtime.parts.lambda;
+  let dataSourceRole = IAM$PulumiAws.Role.makeWithDefaultPolicy("DcbMutationDS", Pulumi.output(AWS$ReventlessAws.AppSync.principal), opts$1);
+  Pulumi.all([
+    Output$Pulumi.flatMap(lambda, lambda => lambda.arn),
+    dataSourceRole.id
+  ]).apply(param => {
+    new (Aws.iam.RolePolicy)("DcbMutationDS", {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, "DcbMutationDSPolicy", [{
+          Sid: "AllowDcbMutationInvokeLambda",
+          Effect: "Allow",
+          Action: "lambda:InvokeFunction",
+          Resource: param[0]
+        }])),
+      role: param[1]
+    }, opts$1);
+  });
+  let dataSource = new (Aws.appsync.DataSource)("DcbMutation", {
+    type: "AWS_LAMBDA",
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    lambdaConfig: {
+      functionArn: Output$Pulumi.flatMap(lambda, lambda => lambda.arn)
+    },
+    serviceRoleArn: dataSourceRole.arn
+  }, opts$1);
+  Stdlib_Array.zip(fieldNames, tags).forEach(param => {
+    let fieldName = param[0];
+    AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(Stdlib_String.capitalize(fieldName), api, dataSource.name, "Mutation", fieldName, AppSync_Resolver_Functions$PulumiAws.invokeDcbMutation(param[1]), opts$1);
+  });
+  CommandSubscriptionResolvers_AppSync$ReventlessAws.make(api, fieldNames, dataSource.name, opts$1);
+}
+
+export {
+  handleResolversEvent,
+  make,
+  makeDcb,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_AppSync_NoOp.res

@@ -0,0 +1,20 @@
+// No-op AppSync CommandGenerator resolver adapter — creates no resolvers.
+// Used for admin-internal aggregates (e.g. Plugin) that have real infrastructure
+// but no AppSync mutation fields (commands come via the ExtensionPoint, not GraphQL).
+type api = Types.AppSync.api
+type runtimeParts = Util.Lambda.runtimeParts
+
+let handleResolversEvent = (_generateCommand: ReventlessCore.CommandGenerator.commandGenerator) =>
+  Pulumi.Output.make((_event, _context) => Effect.succeed(ReventlessCore.CommandTopic.Pending({msgId: ""})))
+
+let make: ReventlessCore.CommandGenerator_Adapter.resolversMaker<api, runtimeParts> = (
+  ~name as _,
+  ~api as _,
+  ~fields as _,
+  ~commandSchema as _,
+  ~runtime as _,
+  ~resources as _,
+  ~opts as _,
+) => {
+  resources: [],
+}

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_AppSync_NoOp.res.mjs

@@ -0,0 +1,23 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Pulumi from "@pulumi/pulumi";
+
+function handleResolversEvent(_generateCommand) {
+  return Pulumi.output((_event, _context) => Effect.succeed({
+    TAG: "Pending",
+    msgId: ""
+  }));
+}
+
+function make(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return {
+    resources: []
+  };
+}
+
+export {
+  handleResolversEvent,
+  make,
+}
+/* effect/Effect Not a pure module */

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_AppSync_Runtime.res

@@ -0,0 +1 @@
+let generateCommand = (commandGenerator, event, _) => event->commandGenerator

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_AppSync_Runtime.res.mjs

@@ -0,0 +1,11 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function generateCommand(commandGenerator, event, param) {
+  return commandGenerator(event);
+}
+
+export {
+  generateCommand,
+}
+/* No side effect */

package/src/adapter/CommandGenerator/InboundTranslationResolvers_AppSync.res

@@ -0,0 +1,95 @@
+// AppSync mutation resolvers for InboundTranslationSlices (AWS).
+// Creates an AppSync DataSource + Resolver per InboundTranslationSlice mutation,
+// pointing to the shared DCB CommandTopic Lambda.
+//
+// The request template sends a payload with `__inboundTranslation: true` so the
+// Lambda's composite handler routes to InboundTranslationSlice.receive instead
+// of the regular SQS command processing.
+
+type runtimeParts = Util.Lambda.runtimeParts
+
+let make = (
+  ~api: Types.AppSync.api,
+  ~runtime: ReventlessCore.Runtime.environment<runtimeParts>,
+  ~fieldNames: array<string>,
+  ~opts: Pulumi.ComponentResource.options,
+) => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let lambda = runtime.parts.lambda
+
+  let dataSourceRole = PulumiAws.IAM.Role.makeWithDefaultPolicy(
+    ~name="InboundTranslationDS",
+    ~servicePrincipal=AWS.AppSync.principal->Pulumi.Output.make,
+    ~opts,
+  )
+
+  let _ =
+    (
+      lambda->Pulumi.Output.flatMap(lambda => lambda.arn),
+      dataSourceRole.id,
+    )
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((lambdaArn, dataSourceRoleId)) => {
+      let _attachDataSourcePolicy = PulumiAws.IAM.RolePolicy.make(
+        ~name="InboundTranslationDS",
+        ~args={
+          PulumiAws.IAM.RolePolicy.policy: PulumiAws.PolicyDocument.make(
+            ~id="InboundTranslationDSPolicy",
+            ~statements=[
+              {
+                sid: "AllowInboundTranslationInvokeLambda",
+                effect: Allow,
+                actions: Action("lambda:InvokeFunction"),
+                resources: Resource(lambdaArn),
+              },
+            ],
+          )
+          ->PulumiAws.PolicyDocument.toJsonString
+          ->Pulumi.Input.make,
+          role: dataSourceRoleId->Pulumi.Input.make,
+        },
+        ~opts,
+      )
+    })
+
+  let dataSource = PulumiAws.AppSync.DataSource.make(
+    ~name="InboundTranslation",
+    ~args={
+      type_: AWS_LAMBDA,
+      apiId: api->Pulumi.Output.flatMap(api => api.id)->Pulumi.Output.asInput,
+      lambdaConfig: {
+        PulumiAws.AppSync.DataSource.functionArn: lambda
+        ->Pulumi.Output.flatMap(lambda => lambda.arn)
+        ->Pulumi.Output.asInput,
+      }->Pulumi.Input.make,
+      serviceRoleArn: dataSourceRole.arn->Pulumi.Output.asInput,
+    },
+    ~opts=Some(opts),
+  )
+
+  let _resolvers = fieldNames->Array.forEach(fieldName => {
+    let _ = AppSync_Resolver_Retrying.makeUnitJsResolver(
+      ~name=fieldName->String.capitalize,
+      ~api,
+      ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+      ~type_="Mutation"->Pulumi.Input.make,
+      ~field=fieldName->Pulumi.Input.make,
+      ~code=PulumiAws.AppSync.Resolver.Functions.invokeInboundTranslation(fieldName),
+      ~opts,
+    )
+  })
+
+  // Source C: create the matching `onX` Subscription resolver for each
+  // mutation field so SDL fields like `onCatalog_ImportProduct` emitted by
+  // Plugin_SubscriptionSchema are actually attached. Mirrors what
+  // CommandGeneratorResolvers_AppSync.make / makeDcb do for aggregate / DCB
+  // mutations. Reuses the mutation's data source — UNIT subscription code
+  // never executes against it.
+  CommandSubscriptionResolvers_AppSync.make(
+    ~api,
+    ~mutationFields=fieldNames,
+    ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+    ~opts,
+  )
+}

package/src/adapter/CommandGenerator/InboundTranslationResolvers_AppSync.res.mjs

@@ -0,0 +1,50 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as AWS$ReventlessAws from "../AWS.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
+import * as AppSync_Resolver_Retrying$ReventlessAws from "../Api/AppSync_Resolver_Retrying.res.mjs";
+import * as CommandSubscriptionResolvers_AppSync$ReventlessAws from "../Api/CommandSubscriptionResolvers_AppSync.res.mjs";
+
+function make(api, runtime, fieldNames, opts) {
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let lambda = runtime.parts.lambda;
+  let dataSourceRole = IAM$PulumiAws.Role.makeWithDefaultPolicy("InboundTranslationDS", Pulumi.output(AWS$ReventlessAws.AppSync.principal), opts$1);
+  Pulumi.all([
+    Output$Pulumi.flatMap(lambda, lambda => lambda.arn),
+    dataSourceRole.id
+  ]).apply(param => {
+    new (Aws.iam.RolePolicy)("InboundTranslationDS", {
+      policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, "InboundTranslationDSPolicy", [{
+          Sid: "AllowInboundTranslationInvokeLambda",
+          Effect: "Allow",
+          Action: "lambda:InvokeFunction",
+          Resource: param[0]
+        }])),
+      role: param[1]
+    }, opts$1);
+  });
+  let dataSource = new (Aws.appsync.DataSource)("InboundTranslation", {
+    type: "AWS_LAMBDA",
+    apiId: Output$Pulumi.flatMap(api, api => api.id),
+    lambdaConfig: {
+      functionArn: Output$Pulumi.flatMap(lambda, lambda => lambda.arn)
+    },
+    serviceRoleArn: dataSourceRole.arn
+  }, opts$1);
+  fieldNames.forEach(fieldName => {
+    AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(Stdlib_String.capitalize(fieldName), api, dataSource.name, "Mutation", fieldName, AppSync_Resolver_Functions$PulumiAws.invokeInboundTranslation(fieldName), opts$1);
+  });
+  CommandSubscriptionResolvers_AppSync$ReventlessAws.make(api, fieldNames, dataSource.name, opts$1);
+}
+
+export {
+  make,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/CommandTopic/CommandTopicChannel.res

@@ -0,0 +1,6 @@
+module SQS_Sync = CommandTopicChannel_SQS_Sync
+module SQS_Async = CommandTopicChannel_SQS_Async
+module SQS_Runtime = CommandTopicChannel_SQS_Runtime
+// Legacy aliases — prefer SQS_Sync and SQS_Async for new code
+module SQS = CommandTopicChannel_SQS
+module SQS_FIFO = CommandTopicChannel_SQS_FIFO

package/src/adapter/CommandTopic/CommandTopicChannel.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let SQS_Sync;
+
+let SQS_Async;
+
+let SQS_Runtime;
+
+let SQS;
+
+let SQS_FIFO;
+
+export {
+  SQS_Sync,
+  SQS_Async,
+  SQS_Runtime,
+  SQS,
+  SQS_FIFO,
+}
+/* No side effect */