aws-sdk-dynamodbstreams 1.26.0 → 1.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3895d33d1f49db7f0c34332c5439169ed15a93c3cc7a3e4d970ef725ce6f755f
-  data.tar.gz: 780bb3a618714a91cc2b6d4eaaa9a283c42122e2c65ecbeaf1b95e96a91c381a
+  metadata.gz: adaf2de9db3083531212490efc797a07ef15a365a3c6a12eecbe836c3ad53841
+  data.tar.gz: f45543e1251b629f2c82733f3ed4e69d97fad3f504b72db261233f93afa7b043
 SHA512:
-  metadata.gz: bda879d8b2e114301d7f86c4791ed70fb32e411f0b9f31e0205b01b979b0efb3f6fcd02190b8528d444e54a512ff11e18023ba4ad800686d3c44f11b29c2ae78
-  data.tar.gz: 29ed9f2f337356ba36869aaa3e05cff4fcfcc2c4718ebe9daddc8758c323495d7f430d7ab4891134e40975ae58b569972fe80aa24b34e452e17d466af7fbf028
+  metadata.gz: 2c3ca4b72b802c0a5f026f3fb63f42b09292269b4506fba773d4699effa3cac2131d6f132462af163ff874182c9d350a3dfb9a35b36d947b169e1e74daa588d1
+  data.tar.gz: 9f0f6c964291715cd30556e7da7c35a169a1f42c1b9803dfe95f4d0b57857abb01bdfac0f246738695c307bf75f3afe925d6abd3a7cff10d431c9bef18fedfb9

data/lib/aws-sdk-dynamodbstreams.rb

@@ -48,6 +48,6 @@ require_relative 'aws-sdk-dynamodbstreams/customizations'
 # @!group service
 module Aws::DynamoDBStreams
 
-  GEM_VERSION = '1.26.0'
+  GEM_VERSION = '1.27.0'
 
 end

data/lib/aws-sdk-dynamodbstreams/attribute_translator.rb

@@ -0,0 +1,40 @@
+module Aws
+  module DynamoDBStreams
+    # A utility class that translates DynamoDBStream events from Lambda
+    # functions into their simple attribute equivalents.
+    class AttributeTranslator
+      # Parse a DynamoDBStream event hash from Lambda that contains 1 or more
+      # records. When using the SDK to retrieve DynamoDB stream records, use the
+      # `simple_attributes: true` client option instead.
+      #
+      # @param [Hash] event A DynamoDBStream event.
+      #
+      # @example Parse a DynamoDB stream event from Lambda
+      #   def lambda_handler(event:, context:)
+      #     records = Aws::DynamoDBStreams::AttributeTranslator.from_event(event)
+      #     records.each do |record|
+      #       puts record.dynamodb.new_image
+      #       # => { "size" => 123, "enabled" => true, ... }
+      #     end
+      #   end
+      def self.from_event(event)
+        return unless event.is_a?(Hash)
+
+        # TODO: This implementation is slow and inefficient. It would be
+        # better to write a switch-case that has similar logic to AttributeValue
+        # used in the ValueTranslator. This implementation however provides
+        # consistency between both DynamoDB and DynamoDBStreams. The translator
+        # only works with shapes and structs and not a regular Ruby hash.
+        shape_ref = ClientApi::Shapes::ShapeRef.new(
+          shape: ClientApi::GetRecordsOutput
+        )
+        translator = Plugins::SimpleAttributes::ValueTranslator.new(
+          shape_ref, :unmarshal
+        )
+        parser = Aws::Json::Parser.new(shape_ref)
+        input = parser.parse(Aws::Json.dump(event))
+        translator.apply(input).records
+      end
+    end
+  end
+end

data/lib/aws-sdk-dynamodbstreams/attribute_value.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'stringio'
+require 'set'
+
+module Aws
+  module DynamoDBStreams
+    # @api private
+    class AttributeValue
+
+      def initialize
+        @unmarshaler = Unmarshaler.new
+      end
+
+      def unmarshal(value)
+        @unmarshaler.format(value)
+      end
+
+      class Unmarshaler
+
+        def format(obj)
+          type, value = extract_type_and_value(obj)
+          case type
+          when :m
+            value.each.with_object({}) do |(k, v), map|
+              map[k] = format(v)
+            end
+          when :l then value.map { |v| format(v) }
+          when :s then value
+          when :n then BigDecimal(value)
+          when :b then StringIO.new(value)
+          when :null then nil
+          when :bool then value
+          when :ss then Set.new(value)
+          when :ns then Set.new(value.map { |n| BigDecimal(n) })
+          when :bs then Set.new(value.map { |b| StringIO.new(b) })
+          else
+            raise ArgumentError, "unhandled type #{type.inspect}"
+          end
+        end
+
+        private
+
+        def extract_type_and_value(obj)
+          case obj
+          when Hash then obj.to_a.first
+          when Struct
+            obj.members.each do |key|
+              value = obj[key]
+              return [key, value] unless value.nil?
+            end
+          else
+            raise ArgumentError, "unhandled type #{obj.inspect}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-dynamodbstreams/client.rb

@@ -29,6 +29,7 @@ require 'aws-sdk-core/plugins/transfer_encoding.rb'
 require 'aws-sdk-core/plugins/http_checksum.rb'
 require 'aws-sdk-core/plugins/signature_v4.rb'
 require 'aws-sdk-core/plugins/protocols/json_rpc.rb'
+require 'aws-sdk-dynamodbstreams/plugins/simple_attributes.rb'
 
 Aws::Plugins::GlobalConfiguration.add_identifier(:dynamodbstreams)
 
@@ -75,6 +76,7 @@ module Aws::DynamoDBStreams
     add_plugin(Aws::Plugins::HttpChecksum)
     add_plugin(Aws::Plugins::SignatureV4)
     add_plugin(Aws::Plugins::Protocols::JsonRpc)
+    add_plugin(Aws::DynamoDBStreams::Plugins::SimpleAttributes)
 
     # @overload initialize(options)
     #   @param [Hash] options
@@ -266,6 +268,10 @@ module Aws::DynamoDBStreams
     #
     #   @option options [String] :session_token
     #
+    #   @option options [Boolean] :simple_attributes (false)
+    #     When enabled, returns DynamoDBStream attribute values using
+    #     hashes, arrays, sets, integers, floats, booleans, and nil.
+    #
     #   @option options [Boolean] :simple_json (false)
     #     Disables request parameter conversion, validation, and formatting.
     #     Also disable response data type conversions. This option is useful
@@ -787,7 +793,7 @@ module Aws::DynamoDBStreams
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-dynamodbstreams'
-      context[:gem_version] = '1.26.0'
+      context[:gem_version] = '1.27.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/aws-sdk-dynamodbstreams/customizations.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# utility classes
+require 'aws-sdk-dynamodbstreams/attribute_translator'
+require 'aws-sdk-dynamodbstreams/attribute_value'

data/lib/aws-sdk-dynamodbstreams/plugins/simple_attributes.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Aws
+  module DynamoDBStreams
+    module Plugins
+      # Simplifies working with Amazon DynamoDBStreams attribute values.
+      # Translates attribute values from responses to sensible Ruby natives.
+      #
+      # This plugin is disabled by default for all {DynamoDBStreams::Client}
+      # objects. You can enable this plugin by passing
+      # `simple_attributes: false` to the client constructor:
+      #
+      #     ddb = Aws::DynamoDBStreams::Client.new(simple_attributes: true)
+      #
+      # ## Output Examples
+      #
+      # With this plugin **enabled**, `simple_attributes: true`:
+      #
+      #     resp = dynamodbstreams.get_records(shard_iterator: iterator)
+      #     resp.records.first.dynamodb.new_image
+      #     {
+      #       id: 'uuid',
+      #       enabled: true,
+      #       tags: #<Set: {"attributes", "simple"}>,
+      #       data: #<StringIO:0x00007fe4061e6bc0>,
+      #       scores: [0.1e1, 0.2e1, 0.3e1, nil],
+      #       name: {
+      #         first: 'John',
+      #         last: 'Doe',
+      #       }
+      #     }
+      #
+      # With this plugin **disabled**, `simple_attributes: false`:
+      #
+      #     resp = dynamodbstreams.get_records(shard_iterator: iterator)
+      #     resp.records.first.dynamodb.new_image
+      #     {
+      #       "id"=> <struct s='uuid', n=nil, b=nil, ss=nil, ns=nil, bs=nil, m=nil, l=nil, null=nil, bool=nil>
+      #       "enabled"=> <struct s=nil, n=nil, b=nil, ss=nil, ns=nil, bs=nil, m=nil, l=nil, null=nil, bool=true>
+      #       ...
+      #     }
+      #
+      class SimpleAttributes < Seahorse::Client::Plugin
+
+        option(:simple_attributes,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: <<-DOCS
+When enabled, returns DynamoDBStream attribute values using
+hashes, arrays, sets, integers, floats, booleans, and nil.
+        DOCS
+        )
+
+        def add_handlers(handlers, config)
+          if config.simple_attributes
+            handlers.add(Handler, step: :initialize, operations: [:get_records])
+          end
+        end
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            @handler.call(context).on(200) do |response|
+              response.data = translate_output(response)
+            end
+          end
+
+          private
+
+          def translate_output(response)
+            if shape = response.context.operation.output
+              ValueTranslator.new(shape, :unmarshal).apply(response.data)
+            else
+              response.data
+            end
+          end
+
+        end
+
+        # @api private
+        class ValueTranslator
+
+          include Seahorse::Model::Shapes
+
+          def self.apply(rules, mode, data)
+            new(rules, mode).apply(data)
+          end
+
+          def initialize(rules, mode)
+            @rules = rules
+            @mode = mode
+          end
+
+          def apply(values)
+            structure(@rules, values) if @rules
+          end
+
+          private
+
+          def structure(ref, values)
+            shape = ref.shape
+            if values.is_a?(Struct)
+              values.members.each.with_object(values.class.new) do |key, st|
+                st[key] = translate(shape.member(key), values[key])
+              end
+            elsif values.is_a?(Hash)
+              values.each.with_object({}) do |(key, value), hash|
+                hash[key] = translate(shape.member(key), value)
+              end
+            else
+              values
+            end
+          end
+
+          def list(ref, values)
+            return values unless values.is_a?(Array)
+            member_ref = ref.shape.member
+            values.inject([]) do |list, value|
+              list << translate(member_ref, value)
+            end
+          end
+
+          def map(ref, values)
+            return values unless values.is_a?(Hash)
+            value_ref = ref.shape.value
+            values.each.with_object({}) do |(key, value), hash|
+              hash[key] = translate(value_ref, value)
+            end
+          end
+
+          def translate(ref, value)
+            if ClientApi::AttributeValue === ref.shape
+              AttributeValue.new.send(@mode, value)
+            else
+              translate_complex(ref, value)
+            end
+          end
+
+          def translate_complex(ref, value)
+            case ref.shape
+            when StructureShape then structure(ref, value)
+            when ListShape then list(ref, value)
+            when MapShape then map(ref, value)
+            else value
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-dynamodbstreams
 version: !ruby/object:Gem::Version
-  version: 1.26.0
+  version: 1.27.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-05 00:00:00.000000000 Z
+date: 2021-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core
@@ -53,10 +53,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/aws-sdk-dynamodbstreams.rb
+- lib/aws-sdk-dynamodbstreams/attribute_translator.rb
+- lib/aws-sdk-dynamodbstreams/attribute_value.rb
 - lib/aws-sdk-dynamodbstreams/client.rb
 - lib/aws-sdk-dynamodbstreams/client_api.rb
 - lib/aws-sdk-dynamodbstreams/customizations.rb
 - lib/aws-sdk-dynamodbstreams/errors.rb
+- lib/aws-sdk-dynamodbstreams/plugins/simple_attributes.rb
 - lib/aws-sdk-dynamodbstreams/resource.rb
 - lib/aws-sdk-dynamodbstreams/types.rb
 homepage: https://github.com/aws/aws-sdk-ruby