@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/CommandTopic/CommandTopicChannel_Helpers.res

@@ -0,0 +1,196 @@
+open PulumiAws.PolicyDocument
+open Adapter_Helpers
+
+let createQueuePolicy = (
+  queue: PulumiAws.SQS.Queue.t,
+  name,
+  lambda: Pulumi.Output.t<PulumiAws.Lambda.Function.t>,
+  opts,
+) => {
+  let _ =
+    (queue.arn, queue.id, lambda->Pulumi.Output.flatMap(lambda => lambda.arn))
+    ->Pulumi.Output.all3
+    ->Pulumi.Output.apply(((queueArn, queueId, lambdaArn)) => {
+      let queuePolicyDocument =
+        PulumiAws.PolicyDocument.make(
+          ~id=name ++ "QueuePolicy",
+          ~statements=[
+            {
+              sid: "AllowLambdaToAccessQueue",
+              effect: Allow,
+              principal: Principals({
+                service: PrincipalId("lambda.amazonaws.com"),
+              }),
+              actions: Actions([
+                "sqs:ReceiveMessage",
+                "sqs:DeleteMessage",
+                "sqs:GetQueueAttributes",
+              ]),
+              resources: Resource(queueArn),
+              conditions: {
+                arnEquals: [("AWS:SourceArn", ConditionValue(lambdaArn))]->Dict.fromArray,
+              },
+            },
+            {
+              sid: "AllowCloudWatchEventsToSendToQueue",
+              effect: Allow,
+              principal: Principals({
+                service: PrincipalId("events.amazonaws.com"),
+              }),
+              actions: Actions(["sqs:SendMessage"]),
+              resources: Resource(queueArn),
+            },
+          ],
+        )
+        ->toJsonString
+        ->Pulumi.Input.make
+      let _queuePolicy = PulumiAws.SQS.QueuePolicy.make(
+        ~name,
+        ~args={queueUrl: queueId->Pulumi.Input.make, policy: queuePolicyDocument},
+        ~opts=Some(opts),
+      )
+    })
+}
+
+let createLambdaPolicy = (
+  lambdaRole: PulumiAws.IAM.Role.t,
+  name: string,
+  queue: PulumiAws.SQS.Queue.t,
+  resources: array<ReventlessInfra.Adapter.resource>,
+  opts: Pulumi.CustomResourceOptions.t,
+) => {
+  let _ =
+    (queue.arn, resources->ReventlessCore.Adapter.resourcesToResolvedOutput)
+    ->Pulumi.Output.all2
+    ->Pulumi.Output.apply(((queueArn, resources)) => {
+      let allowSQSSendLambda =
+        resources->sqsResources->Array.length > 0
+          ? Some(
+              PulumiAws.PolicyDocument.make(
+                ~id=name ++ "RemoteSQSLambdaPolicy",
+                ~statements=[
+                  {
+                    sid: "AllowLambdaSendMessageSQS",
+                    effect: Allow,
+                    actions: Action("sqs:SendMessage"),
+                    resources: Resources(
+                      resources->sqsResources->Array.map(sqsResource => sqsResource.urn),
+                    ),
+                  },
+                ],
+              ),
+            )
+          : None
+
+      let allowLambdaReadWriteDynamoDb =
+        resources->dynamoDbResources->Array.length > 0
+          ? Some(
+              PulumiAws.PolicyDocument.make(
+                ~id=name ++ "LambdaDynamoDbAccessPolicy",
+                ~statements=[
+                  {
+                    sid: "AllowLambdaReadWriteDynamoDb",
+                    effect: Allow,
+                    actions: Actions([
+                      "dynamodb:GetItem",
+                      "dynamodb:Query",
+                      "dynamodb:Scan",
+                      "dynamodb:BatchGetItem",
+                      "dynamodb:PutItem",
+                      "dynamodb:UpdateItem",
+                      "dynamodb:DeleteItem",
+                      "dynamodb:BatchWriteItem",
+                      // Phase 7 cross-partition fences emit read-only
+                      // `ConditionCheck` entries inside `TransactWriteItems`
+                      // when a write doesn't touch the cross-partition tag's
+                      // partition itself; this needs its own IAM action.
+                      "dynamodb:ConditionCheckItem",
+                    ]),
+                    resources: Resources(
+                      resources
+                      ->dynamoDbResources
+                      ->Array.flatMap(dynamoDbResource => [
+                        dynamoDbResource.urn,
+                        dynamoDbResource.urn ++ "/index/*",
+                      ]),
+                    ),
+                  },
+                ],
+              ),
+            )
+          : None
+
+      let allowLambdaWriteCloudWatchEvents = PulumiAws.PolicyDocument.make(
+        ~id=name ++ "LambdaCloudWatchEventsPolicy",
+        ~statements=[
+          {
+            sid: "AllowLambdaWriteCloudWatchEvents",
+            effect: Allow,
+            actions: Actions([
+              "events:PutRule",
+              "events:PutTargets",
+              "events:DeleteRule",
+              "events:RemoveTargets",
+            ]),
+            resources: Resource("*"),
+          },
+        ],
+      )
+
+      let allowLambdaReceiveSQS = PulumiAws.PolicyDocument.make(
+        ~id=name ++ "SQSLambdaPolicy",
+        ~statements=[
+          {
+            sid: "AllowLambdaReceiveSQS",
+            effect: Allow,
+            actions: Actions([
+              "sqs:ReceiveMessage",
+              "sqs:DeleteMessage",
+              "sqs:GetQueueAttributes",
+              "sqs:ChangeMessageVisibility",
+            ]),
+            resources: Resource(queueArn),
+          },
+        ],
+      )
+
+      let allowLambdaPassRoleToEvents = PulumiAws.PolicyDocument.make(
+        ~id=name ++ "LambdaPassRoleToCloudWatchEventsRule",
+        ~statements=[
+          {
+            sid: "AllowLambdaPassRoleToEvents",
+            effect: Allow,
+            actions: Action("iam:PassRole"),
+            resources: Resource("*"),
+            conditions: {
+              stringEquals: Dict.fromArray([
+                ("iam:PassedToService", ConditionValue("events.amazonaws.com")),
+              ]),
+            },
+          },
+        ],
+      )
+
+      let _lambdaPolicy = PulumiAws.IAM.RolePolicy.make(
+        ~name,
+        ~args={
+          policy: PulumiAws.PolicyDocument.mergePolicyDocuments(
+            name ++ "LambdaPolicy",
+            [
+              Some(PulumiAws.Lambda.defaultLoggingPolicyDocument),
+              Some(allowLambdaReceiveSQS),
+              Some(allowLambdaWriteCloudWatchEvents),
+              Some(allowLambdaPassRoleToEvents),
+              allowLambdaReadWriteDynamoDb,
+              allowSQSSendLambda,
+            ]->Array.keepSome,
+          )->Pulumi.Output.asInput,
+          role: lambdaRole.id->Pulumi.Output.asInput,
+        },
+        ~opts,
+      )
+    })
+}
+
+let subscribeLambda2SqsTopic = (~batchSize=?, lambda, name, queue, opts) =>
+  Util_EventSourceMapping.subscribeSqs(~lambda, ~name, ~queue, ~batchSize?, ~opts)

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

@@ -0,0 +1,145 @@
+// 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 Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Lambda$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/Lambda/Lambda.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 Adapter_Helpers$ReventlessAws from "../Adapter_Helpers.res.mjs";
+import * as Util_EventSourceMapping$ReventlessAws from "../../util/Util_EventSourceMapping.res.mjs";
+
+function createQueuePolicy(queue, name, lambda, opts) {
+  Pulumi.all([
+    queue.arn,
+    queue.id,
+    Output$Pulumi.flatMap(lambda, lambda => lambda.arn)
+  ]).apply(param => {
+    let queueArn = param[0];
+    let queuePolicyDocument = PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "QueuePolicy", [
+      {
+        Sid: "AllowLambdaToAccessQueue",
+        Principal: {
+          Service: "lambda.amazonaws.com"
+        },
+        Effect: "Allow",
+        Action: [
+          "sqs:ReceiveMessage",
+          "sqs:DeleteMessage",
+          "sqs:GetQueueAttributes"
+        ],
+        Resource: queueArn,
+        Condition: {
+          ArnEquals: Object.fromEntries([[
+              "AWS:SourceArn",
+              param[2]
+            ]])
+        }
+      },
+      {
+        Sid: "AllowCloudWatchEventsToSendToQueue",
+        Principal: {
+          Service: "events.amazonaws.com"
+        },
+        Effect: "Allow",
+        Action: ["sqs:SendMessage"],
+        Resource: queueArn
+      }
+    ]));
+    new (Aws.sqs.QueuePolicy)(name, {
+      policy: queuePolicyDocument,
+      queueUrl: param[1]
+    }, opts);
+  });
+}
+
+function createLambdaPolicy(lambdaRole, name, queue, resources, opts) {
+  Pulumi.all([
+    queue.arn,
+    Adapter$ReventlessCore.resourcesToResolvedOutput(resources)
+  ]).apply(param => {
+    let resources = param[1];
+    let allowSQSSendLambda = Adapter_Helpers$ReventlessAws.sqsResources(resources).length !== 0 ? PolicyDocument$PulumiAws.make(undefined, name + "RemoteSQSLambdaPolicy", [{
+          Sid: "AllowLambdaSendMessageSQS",
+          Effect: "Allow",
+          Action: "sqs:SendMessage",
+          Resource: Adapter_Helpers$ReventlessAws.sqsResources(resources).map(sqsResource => sqsResource.urn)
+        }]) : undefined;
+    let allowLambdaReadWriteDynamoDb = Adapter_Helpers$ReventlessAws.dynamoDbResources(resources).length !== 0 ? PolicyDocument$PulumiAws.make(undefined, name + "LambdaDynamoDbAccessPolicy", [{
+          Sid: "AllowLambdaReadWriteDynamoDb",
+          Effect: "Allow",
+          Action: [
+            "dynamodb:GetItem",
+            "dynamodb:Query",
+            "dynamodb:Scan",
+            "dynamodb:BatchGetItem",
+            "dynamodb:PutItem",
+            "dynamodb:UpdateItem",
+            "dynamodb:DeleteItem",
+            "dynamodb:BatchWriteItem",
+            "dynamodb:ConditionCheckItem"
+          ],
+          Resource: Adapter_Helpers$ReventlessAws.dynamoDbResources(resources).flatMap(dynamoDbResource => [
+            dynamoDbResource.urn,
+            dynamoDbResource.urn + "/index/*"
+          ])
+        }]) : undefined;
+    let allowLambdaWriteCloudWatchEvents = PolicyDocument$PulumiAws.make(undefined, name + "LambdaCloudWatchEventsPolicy", [{
+        Sid: "AllowLambdaWriteCloudWatchEvents",
+        Effect: "Allow",
+        Action: [
+          "events:PutRule",
+          "events:PutTargets",
+          "events:DeleteRule",
+          "events:RemoveTargets"
+        ],
+        Resource: "*"
+      }]);
+    let allowLambdaReceiveSQS = PolicyDocument$PulumiAws.make(undefined, name + "SQSLambdaPolicy", [{
+        Sid: "AllowLambdaReceiveSQS",
+        Effect: "Allow",
+        Action: [
+          "sqs:ReceiveMessage",
+          "sqs:DeleteMessage",
+          "sqs:GetQueueAttributes",
+          "sqs:ChangeMessageVisibility"
+        ],
+        Resource: param[0]
+      }]);
+    let allowLambdaPassRoleToEvents = PolicyDocument$PulumiAws.make(undefined, name + "LambdaPassRoleToCloudWatchEventsRule", [{
+        Sid: "AllowLambdaPassRoleToEvents",
+        Effect: "Allow",
+        Action: "iam:PassRole",
+        Resource: "*",
+        Condition: {
+          StringEquals: Object.fromEntries([[
+              "iam:PassedToService",
+              "events.amazonaws.com"
+            ]])
+        }
+      }]);
+    new (Aws.iam.RolePolicy)(name, {
+      policy: PolicyDocument$PulumiAws.mergePolicyDocuments(name + "LambdaPolicy", Stdlib_Array.keepSome([
+        Lambda$PulumiAws.defaultLoggingPolicyDocument,
+        allowLambdaReceiveSQS,
+        allowLambdaWriteCloudWatchEvents,
+        allowLambdaPassRoleToEvents,
+        allowLambdaReadWriteDynamoDb,
+        allowSQSSendLambda
+      ])),
+      role: lambdaRole.id
+    }, opts);
+  });
+}
+
+function subscribeLambda2SqsTopic(batchSize, lambda, name, queue, opts) {
+  return Util_EventSourceMapping$ReventlessAws.subscribeSqs(lambda, name, queue, batchSize, opts);
+}
+
+export {
+  createQueuePolicy,
+  createLambdaPolicy,
+  subscribeLambda2SqsTopic,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/CommandTopic/CommandTopicChannel_SQS.res

@@ -0,0 +1,91 @@
+type callbackEvent = PulumiAws.SQS.Queue.event
+type runtimeParts = Util.Lambda.runtimeParts
+type channelParts = Util.SQS.channelParts
+
+// Optional override for the SQS event-source mapping `batchSize`. Set from the
+// runtime builder's `finish()` (or `forDcbCommandTopic`) just before invoking
+// the connect callbacks, using the per-flavor `commandHandlerConfig.sqsBatchSize`.
+// `None` => AWS SQS default of 10 messages per batch (mirrored as
+// `CommandHandlerDefaults.sqsBatchSize`).
+let batchSizeRef: ref<option<int>> = ref(None)
+let setBatchSize = (n: int) => batchSizeRef := Some(n)
+let clearBatchSize = () => batchSizeRef := None
+
+let connect = (
+  ~name,
+  ~channel: ReventlessCore.CommandTopic_Adapter.channel<
+    callbackEvent,
+    'context,
+    Util.SQS.channelParts,
+    runtimeParts,
+  >,
+  ~runtime: ReventlessCore.Runtime.environment<runtimeParts>,
+  ~resources: array<ReventlessInfra.Adapter.resource>,
+  ~opts,
+) => {
+  let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
+
+  let queue = channel.parts.queue
+  let lambda = runtime.parts.lambda
+  let lambdaRole = runtime.parts.lambdaRole
+
+  open CommandTopicChannel_Helpers
+
+  queue->createQueuePolicy(name, lambda, opts)
+  lambdaRole->createLambdaPolicy(name, queue, resources, opts)
+  let subscribeResource =
+    lambda->subscribeLambda2SqsTopic(~batchSize=?batchSizeRef.contents, name, queue, opts)
+
+  [subscribeResource]
+}
+
+let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
+  callbackEvent,
+  'context,
+  Util.SQS.channelParts,
+  Util.Lambda.runtimeParts,
+> = (~name, ~opts=?) => {
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+
+  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let queue = PulumiAws.SQS.Queue.make(
+    ~name,
+    ~args={
+      PulumiAws.SQS.Queue.visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make, // TODO rethink timeout
+      redrivePolicy: Util_DeadLetterQueue.queue.arn
+      ->Pulumi.Output.apply(dlqArn =>
+        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+      )
+      ->Pulumi.Output.asInput,
+      sqsManagedSseEnabled: false->Pulumi.Input.make,
+      tags,
+    },
+    ~opts?,
+  )
+
+  let resolvedQueueOutput = queue->Util_SQS.toResolvedQueueOutput
+
+  {
+    ReventlessCore.CommandTopic_Adapter.parts: {queue: queue},
+    resources: [queue->Util_SQS.toResource(~tags=tags->Pulumi.Output.fromInput)],
+    publishJsons: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+      resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS, ...)
+    ),
+    publishJsonsStream: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue => {
+      let publishJsons = resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS, ...)
+      stream =>
+        stream
+        ->Stream.grouped(10)
+        ->Stream.runForEach(jsons =>
+          Effect.promise(() => publishJsons(jsons))
+        )
+    }),
+    publishJsonsAndWait: None->Pulumi.Output.make,
+    connect,
+    handleChannelEvent: handleCommands =>
+      resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+        resolvedQueue->CommandTopicChannel_SQS_Runtime.handleQueueEvent(handleCommands, ...)
+      ),
+  }
+}

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

@@ -0,0 +1,74 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SQS_Queue$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/SQS/SQS_Queue.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as Util_SQS$ReventlessAws from "../../util/Util_SQS.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as Util_DeadLetterQueue$ReventlessAws from "../../util/Util_DeadLetterQueue.res.mjs";
+import * as CommandTopicChannel_Helpers$ReventlessAws from "./CommandTopicChannel_Helpers.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "./CommandTopicChannel_SQS_Runtime.res.mjs";
+
+let batchSizeRef = {
+  contents: undefined
+};
+
+function setBatchSize(n) {
+  batchSizeRef.contents = n;
+}
+
+function clearBatchSize() {
+  batchSizeRef.contents = undefined;
+}
+
+function connect(name, channel, runtime, resources, opts) {
+  let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
+  let queue = channel.parts.queue;
+  let lambda = runtime.parts.lambda;
+  let lambdaRole = runtime.parts.lambdaRole;
+  CommandTopicChannel_Helpers$ReventlessAws.createQueuePolicy(queue, name, lambda, opts$1);
+  CommandTopicChannel_Helpers$ReventlessAws.createLambdaPolicy(lambdaRole, name, queue, resources, opts$1);
+  return [CommandTopicChannel_Helpers$ReventlessAws.subscribeLambda2SqsTopic(batchSizeRef.contents, lambda, name, queue, opts$1)];
+}
+
+function make(name, opts) {
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let queue = new (Aws.sqs.Queue)(name, {
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    tags: tags,
+    visibilityTimeoutSeconds: 180,
+    sqsManagedSseEnabled: false
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  let resolvedQueueOutput = Util_SQS$ReventlessAws.toResolvedQueueOutput(queue);
+  return {
+    parts: {
+      queue: queue
+    },
+    resources: [Util_SQS$ReventlessAws.toResource(tags, queue)],
+    publishJsons: resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS")),
+    publishJsonsStream: resolvedQueueOutput.apply(resolvedQueue => {
+      let publishJsons = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS");
+      return stream => Stream$1.runForEach(Stream.grouped(stream, 10), jsons => Effect.promise(() => publishJsons(jsons)));
+    }),
+    publishJsonsAndWait: Pulumi.output(undefined),
+    handleChannelEvent: handleCommands => resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.handleQueueEvent(resolvedQueue, handleCommands)),
+    connect: connect
+  };
+}
+
+export {
+  batchSizeRef,
+  setBatchSize,
+  clearBatchSize,
+  connect,
+  make,
+}
+/* Stream Not a pure module */

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Async.res

@@ -0,0 +1,69 @@
+// FIFO SQS-backed CommandTopic channel with fire-and-forget semantics.
+// Opt-in for high-contention aggregates and internal automation where
+// ordering guarantees matter more than synchronous command results.
+// Mutations return CommandPending — the client subscribes for the eventual result.
+
+type callbackEvent = PulumiAws.SQS.Queue.event
+type runtimeParts = Util.Lambda.runtimeParts
+type channelParts = Util.SQS.channelParts
+
+let connect = CommandTopicChannel_SQS.connect
+
+// Re-export per-flavor SQS event-source `batchSize` setters from the shared
+// SQS connect impl, so runtime builders can configure them via the aliased
+// module (`CommandTopicChannel.SQS_Async.setBatchSize`).
+let setBatchSize = CommandTopicChannel_SQS.setBatchSize
+let clearBatchSize = CommandTopicChannel_SQS.clearBatchSize
+
+let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
+  callbackEvent,
+  'context,
+  Util.SQS.channelParts,
+  Util.Lambda.runtimeParts,
+> = (~name, ~opts=?) => {
+  let opts =
+    opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
+  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let queue = PulumiAws.SQS.Queue.make(
+    ~name,
+    ~args={
+      PulumiAws.SQS.Queue.fifoQueue: true->Pulumi.Input.make,
+      contentBasedDeduplication: true->Pulumi.Input.make,
+      visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make,
+      redrivePolicy: Util_DeadLetterQueue.fifoQueue.arn
+      ->Pulumi.Output.apply(dlqArn => {
+        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+      })
+      ->Pulumi.Output.asInput,
+      sqsManagedSseEnabled: false->Pulumi.Input.make,
+      deduplicationScope: MessageGroup,
+      fifoThroughputLimit: PerMessageGroupId,
+      tags,
+    },
+    ~opts?,
+  )
+
+  let resolvedQueueOutput = queue->Util_SQS.toResolvedQueueOutput
+
+  {
+    parts: {queue: queue},
+    resources: [queue->Util_SQS_FIFO.toResource(~tags=tags->Pulumi.Output.fromInput)],
+    publishJsons: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+      resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO, ...)
+    ),
+    publishJsonsStream: resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue => {
+      let publishJsons =
+        resolvedQueue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO, ...)
+      stream =>
+        stream
+        ->Stream.grouped(10)
+        ->Stream.runForEach(jsons => Effect.promise(() => publishJsons(jsons)))
+    }),
+    publishJsonsAndWait: None->Pulumi.Output.make,
+    connect,
+    handleChannelEvent: handleCommands =>
+      resolvedQueueOutput->Pulumi.Output.apply(resolvedQueue =>
+        resolvedQueue->CommandTopicChannel_SQS_Runtime.handleQueueEvent(handleCommands, ...)
+      ),
+  }
+}

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

@@ -0,0 +1,62 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SQS_Queue$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/SQS/SQS_Queue.res.mjs";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as Util_SQS$ReventlessAws from "../../util/Util_SQS.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as Util_SQS_FIFO$ReventlessAws from "../../util/Util_SQS_FIFO.res.mjs";
+import * as Util_DeadLetterQueue$ReventlessAws from "../../util/Util_DeadLetterQueue.res.mjs";
+import * as CommandTopicChannel_SQS$ReventlessAws from "./CommandTopicChannel_SQS.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "./CommandTopicChannel_SQS_Runtime.res.mjs";
+
+function make(name, opts) {
+  let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
+  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let queue = new (Aws.sqs.Queue)(name, {
+    contentBasedDeduplication: true,
+    fifoQueue: true,
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    tags: tags,
+    visibilityTimeoutSeconds: 180,
+    deduplicationScope: "messageGroup",
+    fifoThroughputLimit: "perMessageGroupId",
+    sqsManagedSseEnabled: false
+  }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
+  let resolvedQueueOutput = Util_SQS$ReventlessAws.toResolvedQueueOutput(queue);
+  return {
+    parts: {
+      queue: queue
+    },
+    resources: [Util_SQS_FIFO$ReventlessAws.toResource(tags, queue)],
+    publishJsons: resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS_FIFO")),
+    publishJsonsStream: resolvedQueueOutput.apply(resolvedQueue => {
+      let publishJsons = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(resolvedQueue, "SQS_FIFO");
+      return stream => Stream$1.runForEach(Stream.grouped(stream, 10), jsons => Effect.promise(() => publishJsons(jsons)));
+    }),
+    publishJsonsAndWait: Pulumi.output(undefined),
+    handleChannelEvent: handleCommands => resolvedQueueOutput.apply(resolvedQueue => CommandTopicChannel_SQS_Runtime$ReventlessAws.handleQueueEvent(resolvedQueue, handleCommands)),
+    connect: CommandTopicChannel_SQS$ReventlessAws.connect
+  };
+}
+
+let connect = CommandTopicChannel_SQS$ReventlessAws.connect;
+
+let setBatchSize = CommandTopicChannel_SQS$ReventlessAws.setBatchSize;
+
+let clearBatchSize = CommandTopicChannel_SQS$ReventlessAws.clearBatchSize;
+
+export {
+  connect,
+  setBatchSize,
+  clearBatchSize,
+  make,
+}
+/* Stream Not a pure module */