aws-sdk-extended 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5018a786a6e45aa31c58ee6064b53545f79116d5aed40b3b2f2ce1f4963d94a7
+  data.tar.gz: 22eaa50da7bcb12df4e492105f7ebbd79bf037b8b784716a0f188c01c0f1e5ce
+SHA512:
+  metadata.gz: 3bce11973625136b628f685210bf49fe96ef022a5114108bfa2c7916a4c4fa3b9c0dc4a2c9ea08cfc924c521a95285aab0b04d2f91bcab70986510ea319496de
+  data.tar.gz: 439772535e96a84427a7d869530b7d938c90cd7ce48706c733ecd18a960e4ecf5addcbe5d3874f8df81b63f9a3276c237a9a787b3de94c92941d98db382c4145

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 HoneyryderChuck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# Amazon Extended Client Library for Ruby
+
+[![Gem Version](https://badge.fury.io/rb/aws-sdk-extended.svg)](http://rubygems.org/gems/aws-sdk-extended)
+[![Build status](https://github.com/HoneyryderChuck/aws-sdk-extended/actions/workflows/ci.yml/badge.svg)](https://github.com/HoneyryderChuck/aws-sdk-extended)
+
+
+### Implements the functionality of [amazon-sns-java-extended-client-lib](https://github.com/awslabs/amazon-sns-java-extended-client-lib) and [amazon-sqs-java-extended-client-lib](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-s3-messages.html) in Ruby
+
+The Amazon SQS Extended Client allows clients to manage Amazon SNS and SQS message payloads that exceed the 256 KB message size limit, up to a size of 2 GB. In the event of publishing such large messages, the client accomplishes this feat by storing the actual payload in a S3 bucket and by storing the reference of the stored object in the SQS queue. Similarly, the extended-client is also used for retrieving and dereferencing these references of message objects stored in S3. Thus, the library is used for the following purposes:
+
+1. Specify whether payloads are always stored in Amazon S3 or only when a payload's size exceeds 256 KB.
+2. Send a message that references a single message object stored in an Amazon S3 bucket.
+3. Get the corresponding payload object from an Amazon S3 bucket.
+4. Delete the corresponding payload object from an Amazon S3 bucket.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add aws-sdk-extended
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install aws-sdk-extended
+```
+
+## Usage
+
+The SNS and SQS extended clients are initialized respectively with `Aws::SNS::Client` or `Aws::SQS::Client` objects as single mandatory positional arguments. All method calls are delegated to them, so you can use the extended client objects everywhere you'd use the standard AWS SDK client objects.
+
+They can be initialized with the following optional attributes (as keyword arguments):
+
+* `:use_legacy_attribute` -- if `true`, then all published messages use the Legacy reserved message attribute (`"SQSLargePayloadSize"`) instead of the current reserved message attribute (`"ExtendedPayloadSize"`) (defaults to `false`)
+* `:bucket` -- the S3 bucket name that will store large messages. It falls back to the bucket identified by the `AWS_EXTENDED_CLIENT_S3_BUCKET` env var (if the env var is not set, then it becomes a mandatory attribute).
+* `:payload_size_threshold` -- the threshold for storing the message in the large messages bucket. Cannot be less than `0` or greater than `262144` (defaults to `262144`).
+* `:always_through_s3` -- if `true`, then all messages will be serialized to S3 (defaults to `false`).
+* `:s3_client` -- the `awk-sdk-s3` `Aws::S3::Client` object to use to store objects to S3. Use this if you want to control the S3 client (for example, custom S3 config or credentials) (defaults to a shared `Aws::S3::Client` on first use).
+* (SQS only) `:delete_payload_from_s3` -- if `true`, deletes the large payload from the S3 bucket when the corresponding SQS message is deleted (defaults to `false`).
+
+#### Note:
+> The s3 bucket must already exist prior to usage, and be accessible by whatever credentials you have available
+
+```ruby
+# for SNS
+require "aws-sdk-sns"
+require "aws/sdk/extended"
+
+sns = Aws::SNS::Client.new
+ext_sns = Aws::SNS::ExtendedClient.new(sns) # or, Aws::SNS::ExtendedClient.new(sns, payload_size_threshold: 32)
+
+ext_sns.publish(
+    topic_arn: "TOPIC_ARN",
+    message: "This message should be published to S3 if it exceeds the threshold",
+)
+
+# for SQS
+require "aws-sdk-sqs"
+require "aws/sdk/extended"
+
+sqs = Aws::SQS::Client.new
+ext_sqs = Aws::SQS::ExtendedClient.new(sqs) # or, Aws::SQS::ExtendedClient.new(sqs, payload_size_threshold: 32)
+
+queue_url = ext_sqs.get_queue_url(
+    queue_name: "demo-preparation-queue"
+).queue_url
+
+# sending message
+large_message = "a" * 300000 # Shall cross the limit of 256 KB
+
+ext_sqs.send_message(
+    queue_url: queue_url,
+    message_body: large_message
+)
+
+response = ext_sqs.receive_message(
+    queue_url: queue_url,
+)
+
+response.messages[0].body #=> "aaaaaaaaa...."
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle install`. To release a new version, update the version number in `version.rb`, add the relevant change description to `CHANGELOG.md`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+`aws-sdk-extended` ships with RBS signature files, and uses RBS inline syntax and `rbs-inline` to keep them in sync. In order to not let them fall out of sync when developing, run `fswatch -0 lib | xargs -0 -n1 bundle exec rbs-inline --opt-out --output=sig` in the background.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/HoneyryderChuck/aws-sdk-extended. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/HoneyryderChuck/aws-sdk-extended/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Aws::Sdk::Extended project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/HoneyryderChuck/aws-sdk-extended/blob/master/CODE_OF_CONDUCT.md).

data/lib/aws/sdk/extended/sns.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "aws-sdk-sns"
+
+require_relative "../extended"
+
+module Aws
+  module SNS
+    # Amazon SNS extended client, API-compatible with Aws::SNS::Client from the `aws-sdk-sns` gem,
+    # invokes service methods on Amazon SNS with extended functionality to support large payloads.
+    class ExtendedClient < SimpleDelegator
+      include Extended
+
+      attr_reader :sns_client #: SNS::Client
+
+      attr_reader :s3_client #: S3::Client
+
+      attr_reader :bucket #: String
+
+      attr_reader :always_through_s3 #: bool
+
+      attr_reader :payload_size_threshold #: Integer
+
+      # Constructs a new SNS extended client, where all SNS service calls are forwarded to
+      # +sns_client+, and calls to S3 to store large payloads are forwarded to +s3_client+ using the bucket
+      # specified by +bucket+, and not just payloads which are bigger than the number of bytes specified by
+      # +payload_size_threshold+. This can be circumvented by +always_through_s3+ though, which will cause it
+      # to store all payloads in the S3 bucket.
+      #:  (
+      #|   SNS::Client,
+      #|   ?bucket: String,
+      #|   ?s3_client: S3::Client,
+      #|   ?always_through_s3: bool,
+      #|   ?payload_size_threshold) -> void
+      def initialize(
+        sns_client,
+        bucket: ENV.fetch("AWS_EXTENDED_CLIENT_S3_BUCKET"),
+        s3_client: Extended.default_s3_client,
+        always_through_s3: false,
+        payload_size_threshold: MESSAGE_SIZE_THRESHOLD
+      )
+        @sns_client = sns_client
+        @s3_client = s3_client
+        @bucket = bucket
+        @always_through_s3 = always_through_s3
+        @payload_size_threshold = payload_size_threshold
+        super(sns_client)
+      end
+
+      def freeze #: void
+        @sns_client.freeze
+        @s3_client.freeze
+        @bucket.freeze
+        super
+      end
+
+      # Same functionality as {Aws::SNS::Client#publish}, will store the message payload in S3
+      # if all conditions match.
+      #: (Hash[Symbol, untyped], *untyped) -> SNS::Client::_PublishResponseSuccess
+      def publish(params = {}, *)
+        input = Aws::SNS::Types::PublishInput.new(params)
+
+        return super unless input.message && (@always_through_s3 || large_message?(input))
+
+        # TODO: raise error for JSON payloads: https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/AmazonSNSExtendedClient.java#L184
+        if input.message_structure == "json"
+          raise Extended::Error, "SNS extended client does not support sending JSON messages"
+        end
+
+        params[:message_attributes], params[:message] =
+          Extended.store_large_message(
+            input.message_attributes,
+            input.message, @s3_client, @bucket
+          )
+
+        super
+      end
+
+      private
+
+      # returns whether +input+ is a large message.
+      #
+      #: (SNS::Types::PublishInput) -> bool
+      def large_message?(input)
+        @payload_size_threshold < Extended.message_size(input.message_attributes, input.message)
+      end
+    end
+  end
+end

data/lib/aws/sdk/extended/sqs.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "aws-sdk-sqs"
+
+require_relative "../extended"
+
+module Aws
+  module SQS
+    # Amazon SQS extended client, API-compatible with Aws::SQS::Client from the `aws-sdk-sqs` gem,
+    # invokes service methods on Amazon SQS with extended functionality to support large payloads.
+    class ExtendedClient < SimpleDelegator
+      include Extended
+
+      attr_reader :sqs_client #: SQS::Client
+
+      attr_reader :s3_client #: S3::Client
+
+      attr_reader :bucket #: String
+
+      attr_reader :always_through_s3 #: bool
+
+      attr_reader :delete_payload_from_s3 #: bool
+
+      attr_reader :payload_size_threshold #: Integer
+
+      # Constructs a new SQS extended client, where all SQS service calls are forwarded to
+      # +sqs_client+, and calls to S3 to store and retrieve large payloads are forwarded to +s3_client+
+      #  using the bucket specified by +bucket+, and not just message bodies which are bigger than the number of
+      #  bytes specified by +payload_size_threshold+. This can be circumvented by +always_through_s3+ though,
+      #  which will cause it to store all message bodies in the S3 bucket.
+      #
+      #  When the message is deleted, +delete_payload_from_s3+ determines whether the large payload stored in the
+      #  S3 bucket should be deleted alongside.
+      #
+      #:  (
+      #|   SQS::Client,
+      #|   ?bucket: String,
+      #|   ?s3_client: S3::Client,
+      #|   ?always_through_s3: bool,
+      #|   delete_payload_from_s3: bool,
+      #|   ?payload_size_threshold) -> void
+      def initialize(
+        sqs_client,
+        bucket: ENV.fetch("AWS_EXTENDED_CLIENT_S3_BUCKET"),
+        s3_client: Extended.default_s3_client,
+        always_through_s3: false,
+        delete_payload_from_s3: false,
+        payload_size_threshold: Extended::MESSAGE_SIZE_THRESHOLD
+      )
+        @sqs_client = sqs_client
+        @s3_client = s3_client
+        @bucket = bucket
+        @always_through_s3 = always_through_s3
+        @delete_payload_from_s3 = delete_payload_from_s3
+        @payload_size_threshold = payload_size_threshold
+        super(sqs_client)
+      end
+
+      def freeze
+        @sqs_client.freeze
+        @s3_client.freeze
+        @bucket.freeze
+        super
+      end
+
+      # Same functionality as {Aws::SQS::Client#send_message}, will store the message body in S3
+      # if all conditions match.
+      #
+      #: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_SendMessageResponseSuccess
+      def send_message(params = {}, *)
+        request = Aws::SQS::Types::SendMessageRequest.new(params)
+
+        return super unless request.queue_url && request.message_body && (@always_through_s3 || large_message?(request))
+
+        params[:message_attributes], params[:message_body] =
+          Extended.store_large_message(
+            request.message_attributes,
+            request.message_body, @s3_client, @bucket
+          )
+
+        super
+      end
+
+      # Same functionality as {Aws::SQS::Client#send_message_batch}, will store the message bodies in S3
+      # if all conditions match, and store the reference in the SQS message.
+      #
+      #:  (Hash[Symbol, untyped], *untyped) -> SQS::Client::_SendMessageBatchResponseSuccess
+      def send_message_batch(params = {}, options = {})
+        request = Aws::SQS::Types::SendMessageBatchRequest.new(params)
+
+        return super unless request.queue_url && request.entries
+
+        request.entries.each do |entry|
+          request = Aws::SQS::Types::SendMessageBatchRequestEntry.new(entry)
+
+          next unless @always_through_s3 || large_message?(request)
+
+          Extended.store_large_message(request.message_attributes, request.message_body, @s3_client, @bucket)
+        end
+
+        super
+      end
+
+      # Same functionality as {Aws::SQS::Client#receive_message}, will transparently retrieve large payloads
+      # and store them as the message object in the returned object.
+      #
+      #: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_ReceiveMessageResponseSuccess
+      def receive_message(params = {}, *)
+        requested_attributes = params.fetch(:message_attribute_names, [])
+
+        unless requested_attributes.include?("All") ||
+               requested_attributes.include?("*")
+          requested_attributes << RESERVED_ATTRIBUTE_NAME unless requested_attributes.include?(RESERVED_ATTRIBUTE_NAME)
+
+          unless requested_attributes.include?(LEGACY_RESERVED_ATTRIBUTE_NAME)
+            requested_attributes << LEGACY_RESERVED_ATTRIBUTE_NAME
+          end
+        end
+
+        params[:message_attribute_names] = requested_attributes
+
+        super.tap do |resp|
+          messages = resp.messages || EMPTY_ARRAY #: Array[Aws::SQS::Types::Message]
+
+          messages.each do |message|
+            message_attributes = message.message_attributes
+
+            next unless message_attributes && (
+              message_attributes.include?(RESERVED_ATTRIBUTE_NAME) ||
+              message_attributes.include?(LEGACY_RESERVED_ATTRIBUTE_NAME)
+            )
+
+            get_large_message(message)
+
+            message_attributes.delete(RESERVED_ATTRIBUTE_NAME)
+            message_attributes.delete(LEGACY_RESERVED_ATTRIBUTE_NAME)
+          end
+        end
+      end
+
+      # Same functionality as {Aws::SQS::Client#delete_message}, will (if +@delete_payload_froms3+) delete
+      # the respective s3 objects from the S3 bucket.
+      # and store them as the message object in the returned object.
+      #
+      #: (Hash[Symbol, untyped], *untyped) -> Seahorse::Client::_ResponseSuccess[EmptyStructure]
+      def delete_message(params = {}, *)
+        receipt_handle = params[:receipt_handle]
+
+        return super unless @delete_payload_from_s3 && receipt_handle && large_message_receipt_handle?(receipt_handle)
+
+        bucket, key, params[:receipt_handle] = bucket_key_original_receipt_handle(receipt_handle)
+
+        # TODO: what to do with error?
+        @s3_client.delete_object(bucket: bucket, key: key)
+
+        super
+      end
+
+      # Same functionality as {Aws::SQS::Client#delete_message_batch}, will (if +@delete_payload_froms3+) delete
+      # the respective s3 objects from the S3 bucket.
+      #
+      #: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_DeleteMessageBatchResponseSuccess
+      def delete_message_batch(params = {}, *)
+        request = Aws::SQS::Types::DeleteMessageBatchRequest.new(params)
+
+        if request.queue_url && request.entries
+          s3_to_delete = request.entries.map do |entry|
+            receipt_handle = entry[:receipt_handle]
+            next unless @delete_payload_from_s3 && receipt_handle && large_message_receipt_handle?(receipt_handle)
+
+            *bucket_key, entry[:receipt_handle] = bucket_key_original_receipt_handle(receipt_handle)
+
+            bucket_key
+          end
+
+          s3_to_delete.each do |bucket, key|
+            # TODO: what to do with error?
+            @s3_client.delete_object(bucket: bucket, key: key)
+          end
+        end
+
+        super
+      end
+
+      # Same functionality as {Aws::SQS::Client#change_message_visibility}
+      #
+      #: (Hash[Symbol, untyped], *untyped) -> Seahorse::Client::_ResponseSuccess[EmptyStructure]
+      def change_message_visibility(params = {}, *)
+        request = Aws::SQS::Types::ChangeMessageVisibilityRequest.new(params)
+
+        if request.queue_url && request.receipt_handle &&
+           request.visibility_timeout && large_message_receipt_handle?(request.receipt_handle)
+
+          *_, params[:receipt_handle] = bucket_key_original_receipt_handle(request.receipt_handle)
+        end
+
+        super
+      end
+
+      private
+
+      #: (Aws::SQS::Types::SendMessageRequest | Aws::SQS::Types::SendMessageBatchRequestEntry) -> bool
+      def large_message?(request)
+        @payload_size_threshold < Extended.message_size(request.message_attributes, request.message_body)
+      end
+
+      #: (String) -> bool
+      def large_message_receipt_handle?(receipt_handle)
+        receipt_handle.start_with?(S3_BUCKET_NAME_MARKER)
+      end
+
+      #: (Aws::SQS::Types::Message) -> void
+      def get_large_message(message)
+        receipt_handle = message.receipt_handle
+
+        body = JSON.parse(message.body)
+
+        unless body.is_a?(Array) && body.size == 2 &&
+               (_, s3_params = body) && s3_params.is_a?(Hash)
+          raise Extended::Error,
+                "Invalid payload format for retrieving stored messages in S3"
+        end
+
+        bucket, key = s3_params.values_at("s3BucketName", "s3Key")
+
+        message.receipt_handle = format(RECEIPT_HANDLE_FORMAT, bucket, key, receipt_handle)
+
+        resp = @s3_client.get_object(bucket: bucket, key: key)
+
+        message.body = resp.body.read
+      end
+
+      #: (String) -> [String, String, String]
+      def bucket_key_original_receipt_handle(receipt_handle)
+        _, bucket, = receipt_handle.split(S3_BUCKET_NAME_MARKER)
+        _, key, original_receipt_handle = receipt_handle.split(S3_KEY_MARKER)
+
+        [bucket, key, original_receipt_handle] #: [String, String, String]
+      end
+    end
+  end
+end

data/lib/aws/sdk/extended/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Aws
+  module Sdk
+    module Extended
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/aws/sdk/extended.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "delegate"
+require "aws-sdk-s3"
+
+require_relative "extended/version"
+
+module Aws
+  module Extended
+    # @rbs!
+    #   interface _WithSize
+    #     def size: () -> Integer
+    #   end
+
+    EMPTY_HASH = {}.freeze #: Hash[untyped, untyped]
+    EMPTY_ARRAY = [].freeze #: Array[untyped]
+    EMPTY_STRING = ""
+    MESSAGE_SIZE_THRESHOLD = 262_144
+    MAX_ALLOWED_ATTRIBUTES = 10
+    LEGACY_RESERVED_ATTRIBUTE_NAME = "SQSLargePayloadSize"
+    RESERVED_ATTRIBUTE_NAME = "ExtendedPayloadSize"
+    S3_KEY_ATTRIBUTE_NAME = "S3Key"
+    S3_BUCKET_NAME_MARKER = "-..s3BucketName..-"
+    S3_KEY_MARKER = "-..s3Key..-"
+    RECEIPT_HANDLE_FORMAT = "#{S3_BUCKET_NAME_MARKER}%s" \
+                            "#{S3_BUCKET_NAME_MARKER}#{S3_KEY_MARKER}%s" \
+                            "#{S3_KEY_MARKER}%s".freeze
+
+    DEFAULT_S3_MUTEX = Mutex.new
+
+    class Error < StandardError
+    end
+
+    module_function
+
+    # @rbs self.@default_s3_client: Aws::S3::Client
+
+    def default_s3_client #: Aws::S3::Client
+      @default_s3_client || DEFAULT_S3_MUTEX.synchronize do
+        @default_s3_client ||= Aws::S3::Client.new
+      end
+    end
+
+    #: (Hash[String, untyped], _WithSize) -> Integer
+    def message_size(message_attributes, body)
+      total_size = body.size
+
+      if message_attributes
+        total_size = message_attributes.sum(total_size) do |key, value|
+          key.size + value.fetch(:data_type, EMPTY_STRING).size +
+            value.fetch(:binary_value, EMPTY_STRING).size +
+            value.fetch(:string_value, EMPTY_STRING).size
+        end
+      end
+
+      total_size
+    end
+
+    #: (Hash[String, untyped], _WithSize, S3::Client, String) -> [Hash[Symbol, untyped], String]
+    def store_large_message(message_attributes, body, s3_client, bucket)
+      message_attributes ||= Extended::EMPTY_HASH
+
+      if message_attributes.size > Extended::MAX_ALLOWED_ATTRIBUTES - 1
+        raise Extended::Error,
+              "Number of message attributes exceeds the maximum allowed for large payload messages"
+      end
+
+      if message_attributes.key?(Extended::RESERVED_ATTRIBUTE_NAME) ||
+         message_attributes.key?(Extended::LEGACY_RESERVED_ATTRIBUTE_NAME)
+        raise Extended::Error,
+              "Use of an attribute reserved by SQS extended client."
+      end
+
+      s3_key = message_attributes.fetch(Extended::S3_KEY_ATTRIBUTE_NAME, SecureRandom.urlsafe_base64)
+
+      message_attributes = message_attributes.merge(
+        # TODO: optionally use legacy attribute
+        Extended::RESERVED_ATTRIBUTE_NAME => {
+          data_type: "Number",
+          string_value: body.size.to_s
+        },
+        Extended::S3_KEY_ATTRIBUTE_NAME => {
+          data_type: "String",
+          string_value: s3_key
+        }
+      )
+
+      s3_client.put_object(bucket: bucket, key: s3_key, body: body)
+
+      message_body = JSON.generate(
+        [
+          Extended::RESERVED_ATTRIBUTE_NAME,
+          { s3BucketName: bucket, s3Key: s3_key }
+        ]
+      )
+
+      [message_attributes, message_body]
+    end
+  end
+end

data/sig/aws/sdk/extended/sns.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/aws/sdk/extended/sns.rb with RBS::Inline
+
+module Aws
+  module SNS
+    # Amazon SNS extended client, API-compatible with Aws::SNS::Client from the `aws-sdk-sns` gem,
+    # invokes service methods on Amazon SNS with extended functionality to support large payloads.
+    class ExtendedClient < SimpleDelegator
+      include Extended
+
+      attr_reader sns_client: SNS::Client
+
+      attr_reader s3_client: S3::Client
+
+      attr_reader bucket: String
+
+      attr_reader always_through_s3: bool
+
+      attr_reader payload_size_threshold: Integer
+
+      # Constructs a new SNS extended client, where all SNS service calls are forwarded to
+      # +sns_client+, and calls to S3 to store large payloads are forwarded to +s3_client+ using the bucket
+      # specified by +bucket+, and not just payloads which are bigger than the number of bytes specified by
+      # +payload_size_threshold+. This can be circumvented by +always_through_s3+ though, which will cause it
+      # to store all payloads in the S3 bucket.
+      # :  (
+      # |   SNS::Client,
+      # |   ?bucket: String,
+      # |   ?s3_client: S3::Client,
+      # |   ?always_through_s3: bool,
+      # |   ?payload_size_threshold) -> void
+      def initialize: (untyped sns_client, ?bucket: untyped, ?s3_client: untyped, ?always_through_s3: untyped, ?payload_size_threshold: untyped) -> untyped
+
+      def freeze: () -> void
+
+      # Same functionality as {Aws::SNS::Client#publish}, will store the message payload in S3
+      # if all conditions match.
+      # : (Hash[Symbol, untyped], *untyped) -> SNS::Client::_PublishResponseSuccess
+      def publish: (Hash[Symbol, untyped], *untyped) -> SNS::Client::_PublishResponseSuccess
+
+      private
+
+      # returns whether +input+ is a large message.
+      #
+      # : (SNS::Types::PublishInput) -> bool
+      def large_message?: (SNS::Types::PublishInput) -> bool
+    end
+  end
+end

data/sig/aws/sdk/extended/sqs.rbs

@@ -0,0 +1,93 @@
+# Generated from lib/aws/sdk/extended/sqs.rb with RBS::Inline
+
+module Aws
+  module SQS
+    # Amazon SQS extended client, API-compatible with Aws::SQS::Client from the `aws-sdk-sqs` gem,
+    # invokes service methods on Amazon SQS with extended functionality to support large payloads.
+    class ExtendedClient < SimpleDelegator
+      include Extended
+
+      attr_reader sqs_client: SQS::Client
+
+      attr_reader s3_client: S3::Client
+
+      attr_reader bucket: String
+
+      attr_reader always_through_s3: bool
+
+      attr_reader delete_payload_from_s3: bool
+
+      attr_reader payload_size_threshold: Integer
+
+      # Constructs a new SQS extended client, where all SQS service calls are forwarded to
+      # +sqs_client+, and calls to S3 to store and retrieve large payloads are forwarded to +s3_client+
+      #  using the bucket specified by +bucket+, and not just message bodies which are bigger than the number of
+      #  bytes specified by +payload_size_threshold+. This can be circumvented by +always_through_s3+ though,
+      #  which will cause it to store all message bodies in the S3 bucket.
+      #
+      #  When the message is deleted, +delete_payload_from_s3+ determines whether the large payload stored in the
+      #  S3 bucket should be deleted alongside.
+      #
+      # :  (
+      # |   SQS::Client,
+      # |   ?bucket: String,
+      # |   ?s3_client: S3::Client,
+      # |   ?always_through_s3: bool,
+      # |   delete_payload_from_s3: bool,
+      # |   ?payload_size_threshold) -> void
+      def initialize: (untyped sqs_client, ?bucket: untyped, ?s3_client: untyped, ?always_through_s3: untyped, ?delete_payload_from_s3: untyped, ?payload_size_threshold: untyped) -> untyped
+
+      def freeze: () -> untyped
+
+      # Same functionality as {Aws::SQS::Client#send_message}, will store the message body in S3
+      # if all conditions match.
+      #
+      # : (Hash[Symbol, untyped], *untyped) -> SQS::Client::_SendMessageResponseSuccess
+      def send_message: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_SendMessageResponseSuccess
+
+      # Same functionality as {Aws::SQS::Client#send_message_batch}, will store the message bodies in S3
+      # if all conditions match, and store the reference in the SQS message.
+      #
+      # :  (Hash[Symbol, untyped], *untyped) -> SQS::Client::_SendMessageBatchResponseSuccess
+      def send_message_batch: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_SendMessageBatchResponseSuccess
+
+      # Same functionality as {Aws::SQS::Client#receive_message}, will transparently retrieve large payloads
+      # and store them as the message object in the returned object.
+      #
+      # : (Hash[Symbol, untyped], *untyped) -> SQS::Client::_ReceiveMessageResponseSuccess
+      def receive_message: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_ReceiveMessageResponseSuccess
+
+      # Same functionality as {Aws::SQS::Client#delete_message}, will (if +@delete_payload_froms3+) delete
+      # the respective s3 objects from the S3 bucket.
+      # and store them as the message object in the returned object.
+      #
+      # : (Hash[Symbol, untyped], *untyped) -> Seahorse::Client::_ResponseSuccess[EmptyStructure]
+      def delete_message: (Hash[Symbol, untyped], *untyped) -> Seahorse::Client::_ResponseSuccess[EmptyStructure]
+
+      # Same functionality as {Aws::SQS::Client#delete_message_batch}, will (if +@delete_payload_froms3+) delete
+      # the respective s3 objects from the S3 bucket.
+      #
+      # : (Hash[Symbol, untyped], *untyped) -> SQS::Client::_DeleteMessageBatchResponseSuccess
+      def delete_message_batch: (Hash[Symbol, untyped], *untyped) -> SQS::Client::_DeleteMessageBatchResponseSuccess
+
+      # Same functionality as {Aws::SQS::Client#change_message_visibility}
+      #
+      # : (Hash[Symbol, untyped], *untyped) -> Seahorse::Client::_ResponseSuccess[EmptyStructure]
+      def change_message_visibility: (Hash[Symbol, untyped], *untyped) -> Seahorse::Client::_ResponseSuccess[EmptyStructure]
+
+      private
+
+      # : (Aws::SQS::Types::SendMessageRequest | Aws::SQS::Types::SendMessageBatchRequestEntry) -> bool
+      def large_message?: (Aws::SQS::Types::SendMessageRequest | Aws::SQS::Types::SendMessageBatchRequestEntry) -> bool
+
+      # : (String) -> bool
+      def large_message_receipt_handle?: (String) -> bool
+
+      # : (Aws::SQS::Types::Message) -> void
+      def get_large_message: (Aws::SQS::Types::Message) -> void
+
+      # : (String) -> [String, String, String]
+      def bucket_key_original_receipt_handle: (String) -> [ String, String, String ]
+    end
+  end
+end

data/sig/aws/sdk/extended/version.rbs

@@ -0,0 +1,9 @@
+# Generated from lib/aws/sdk/extended/version.rb with RBS::Inline
+
+module Aws
+  module Sdk
+    module Extended
+      VERSION: ::String
+    end
+  end
+end

data/sig/aws/sdk/extended.rbs

@@ -0,0 +1,46 @@
+# Generated from lib/aws/sdk/extended.rb with RBS::Inline
+
+module Aws
+  module Extended
+    interface _WithSize
+      def size: () -> Integer
+    end
+
+    EMPTY_HASH: Hash[untyped, untyped]
+
+    EMPTY_ARRAY: Array[untyped]
+
+    EMPTY_STRING: ::String
+
+    MESSAGE_SIZE_THRESHOLD: ::Integer
+
+    MAX_ALLOWED_ATTRIBUTES: ::Integer
+
+    LEGACY_RESERVED_ATTRIBUTE_NAME: ::String
+
+    RESERVED_ATTRIBUTE_NAME: ::String
+
+    S3_KEY_ATTRIBUTE_NAME: ::String
+
+    S3_BUCKET_NAME_MARKER: ::String
+
+    S3_KEY_MARKER: ::String
+
+    RECEIPT_HANDLE_FORMAT: untyped
+
+    DEFAULT_S3_MUTEX: untyped
+
+    class Error < StandardError
+    end
+
+    self.@default_s3_client: Aws::S3::Client
+
+    def self?.default_s3_client: () -> Aws::S3::Client
+
+    # : (Hash[String, untyped], _WithSize) -> Integer
+    def self?.message_size: (Hash[String, untyped], _WithSize) -> Integer
+
+    # : (Hash[String, untyped], _WithSize, S3::Client, String) -> [Hash[Symbol, untyped], String]
+    def self?.store_large_message: (Hash[String, untyped], _WithSize, S3::Client, String) -> [ Hash[Symbol, untyped], String ]
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: aws-sdk-extended
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tiago Cardoso
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      Ships with API-compatible clients which support for (SNS) publishing, (SQS) sending, receiving,
+      deleting (and more) messages which exceed the threshold of 256KB imposed by AWS services (up to 2GB).
+email:
+- cardoso_tiago@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/aws/sdk/extended.rb
+- lib/aws/sdk/extended/sns.rb
+- lib/aws/sdk/extended/sqs.rb
+- lib/aws/sdk/extended/version.rb
+- sig/aws/sdk/extended.rbs
+- sig/aws/sdk/extended/sns.rbs
+- sig/aws/sdk/extended/sqs.rbs
+- sig/aws/sdk/extended/version.rbs
+homepage: https://github.com/HoneyryderChuck/aws-sdk-extended
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/igrigorik/http-2/issues
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/HoneyryderChuck/aws-sdk-extended
+  source_code_uri: https://github.com/HoneyryderChuck/aws-sdk-extended
+  changelog_uri: https://github.com/HoneyryderChuck/aws-sdk-extended/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby version of the AWS SNS and SQS extended clients supporting large payload
+  messages
+test_files: []