smithy-client 1.0.0.pre0 → 1.0.0.pre1

data/lib/smithy-client/param_validator.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Smithy
+  module Client
+    # @api private
+    class ParamValidator
+      include Smithy::Schema::Shapes
+
+      EXPECTED_GOT = 'expected %s to be %s, got class %s instead.'
+
+      def initialize(ref, validate_required: true)
+        @ref = ref
+        @validate_required = validate_required
+      end
+
+      # @param [Hash] params
+      # @param [String] context
+      # @return [void]
+      # @raise [ArgumentError] if the params are invalid
+      def validate!(params, context: 'params')
+        errors = []
+        structure(@ref, params, errors, context)
+        raise ArgumentError, error_messages(errors) unless errors.empty?
+      end
+
+      private
+
+      # rubocop:disable Metrics
+      def shape(ref, value, errors, context)
+        case ref.shape
+        when StructureShape then structure(ref, value, errors, context)
+        when ListShape then list(ref, value, errors, context)
+        when MapShape then map(ref, value, errors, context)
+        when DocumentShape then document(ref, value, errors, context)
+        when UnionShape then union(ref, value, errors, context)
+        when StringShape, EnumShape
+          errors << expected_got(context, 'a String', value) unless value.is_a?(String)
+        when IntegerShape, IntEnumShape
+          errors << expected_got(context, 'an Integer', value) unless value.is_a?(Integer)
+        when BigDecimalShape
+          errors << expected_got(context, 'a BigDecimal', value) unless value.is_a?(BigDecimal)
+        when FloatShape
+          errors << expected_got(context, 'a Float', value) unless value.is_a?(Float)
+        when TimestampShape
+          errors << expected_got(context, 'a Time object', value) unless value.is_a?(Time)
+        when BooleanShape
+          errors << expected_got(context, 'true or false', value) unless [true, false].include?(value)
+        when BlobShape
+          unless value.is_a?(String)
+            if streaming_input?(ref)
+              unless io_like?(value)
+                errors << expected_got(
+                  context,
+                  'a String or IO like object that supports read and rewind',
+                  value
+                )
+              end
+            elsif !io_like?(value, require_size: true)
+              errors << expected_got(
+                context,
+                'a String or IO like object that supports read, rewind, and size',
+                value
+              )
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics
+
+      def document(shape, value, errors, context)
+        document_types = [Hash, Array, Numeric, String, TrueClass, FalseClass, NilClass]
+        unless document_types.any? { |t| value.is_a?(t) }
+          errors << expected_got(context, "one of #{document_types.join(', ')}", value)
+        end
+
+        case value
+        when Hash
+          value.each do |k, v|
+            document(shape, v, errors, context + "[#{k}]")
+          end
+        when Array
+          value.each do |v|
+            document(shape, v, errors, context)
+          end
+        end
+      end
+
+      def list(ref, values, errors, context)
+        unless values.is_a?(Array)
+          errors << expected_got(context, 'an Array', values)
+          return
+        end
+
+        values.each.with_index do |value, index|
+          next unless value
+
+          shape(ref.shape.member, value, errors, context + "[#{index}]")
+        end
+      end
+
+      def map(ref, values, errors, context)
+        unless values.is_a?(Hash)
+          errors << expected_got(context, 'a Hash', values)
+          return
+        end
+
+        values.each do |key, value|
+          shape(ref.shape.key, key, errors, "#{context} #{key.inspect} key")
+          next unless value
+
+          shape(ref.shape.value, value, errors, context + "[#{key.inspect}]")
+        end
+      end
+
+      def member(ref, name, value, errors, context)
+        if ref.shape.member?(name)
+          member_ref = ref.shape.member(name)
+          shape(member_ref, value, errors, context + "[#{name.inspect}]")
+        else
+          errors << "unexpected value at #{context}[#{name.inspect}]"
+        end
+      end
+
+      def structure(ref, values, errors, context)
+        return if ref.shape == Prelude::Unit
+        return unless valid_structure?(ref, values, errors, context)
+
+        validate_required_members(ref, values, errors, context) if @validate_required
+        values.each_pair do |name, value|
+          next if value.nil?
+
+          member(ref, name, value, errors, context)
+        end
+      end
+
+      def valid_structure?(ref, values, errors, context)
+        if !values.is_a?(Hash) && !values.is_a?(ref.shape.type)
+          errors << expected_got(context, 'a Hash', values)
+          return false
+        end
+
+        true
+      end
+
+      def union(ref, values, errors, context)
+        return unless valid_union?(ref, values, errors, context)
+
+        if values.is_a?(Schema::Union)
+          _name, member_ref = ref.shape.member_by_type(values.class)
+          shape(member_ref, values.value, errors, context)
+        else
+          values.each_pair do |name, value|
+            next if value.nil?
+
+            member(ref, name, value, errors, context)
+          end
+        end
+      end
+
+      def valid_union?(ref, values, errors, context)
+        return true if values.is_a?(ref.shape.type)
+
+        unless values.is_a?(Hash)
+          errors << expected_got(context, 'a Hash', values)
+          return false
+        end
+        return true if values.size <= 1
+
+        union_members = ref.shape.members.keys.join(', ')
+        error = "expected #{context} to be a Hash with one of #{union_members}, got #{values.size} keys instead."
+        errors << error
+        false
+      end
+
+      def validate_required_members(ref, values, errors, context)
+        ref.shape.members.each do |name, member_ref|
+          traits = member_ref.traits
+          next unless traits.key?('smithy.api#required') && !traits.key?('smithy.api#clientOptional')
+
+          if values[name].nil?
+            param = "#{context}[#{name.inspect}]"
+            errors << "missing required parameter #{param}"
+          end
+        end
+      end
+
+      def streaming_input?(ref)
+        ref.shape.traits.key?('smithy.api#streaming')
+      end
+
+      def io_like?(value, require_size: false)
+        value.respond_to?(:read) && value.respond_to?(:rewind) &&
+          (!require_size || value.respond_to?(:size))
+      end
+
+      def error_messages(errors)
+        if errors.size == 1
+          errors.first
+        else
+          prefix = "\n  - "
+          "parameter validator found #{errors.size} errors:" +
+            prefix + errors.join(prefix)
+        end
+      end
+
+      def expected_got(context, expected, got)
+        format(EXPECTED_GOT, context, expected, got.class.name)
+      end
+    end
+  end
+end

data/lib/smithy-client/plugin.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # Base plugin that all plugins should inherit from.
+    #
+    # @example
+    #    class MyPlugin < Plugin
+    #      option :my_option, default: 'default'
+    #
+    #      def add_handlers(handlers, _config)
+    #        handlers.add(Handler)
+    #      end
+    #
+    #      class Handler < Client::Handler
+    #        def call(context)
+    #          ...
+    #        end
+    #      end
+    #    end
+    class Plugin
+      extend HandlerBuilder
+
+      # @param [Configuration] config
+      # @return [void]
+      def add_options(config)
+        self.class.options.each do |option|
+          if option.default_block
+            config.add_option(option.name, &option.default_block)
+          else
+            config.add_option(option.name, option.default)
+          end
+        end
+      end
+
+      # @param [HandlerList] handlers
+      # @param [Struct] _config
+      # @return [void]
+      def add_handlers(handlers, _config)
+        handlers.copy_from(self.class.handlers)
+      end
+
+      # @param [Class<Base>] client_class
+      # @param [Hash] options
+      # @return [void]
+      def before_initialize(client_class, options)
+        self.class.before_initialize_hooks.each do |block|
+          block.call(client_class, options)
+        end
+      end
+
+      # @param [Base] client
+      # @return [void]
+      def after_initialize(client)
+        self.class.after_initialize_hooks.each do |block|
+          block.call(client)
+        end
+      end
+
+      class << self
+        # (see PluginOption#initialize)
+        def option(name, options = {}, &block)
+          options[:default_block] = block if block_given?
+          self.options << PluginOption.new(name, options)
+        end
+
+        def before_initialize(&block)
+          before_initialize_hooks << block
+        end
+
+        def after_initialize(&block)
+          after_initialize_hooks << block
+        end
+
+        # @return [Array<PluginOption>]
+        def options
+          @options ||= []
+        end
+
+        # @return [HandlerList]
+        def handlers
+          @handlers ||= HandlerList.new
+        end
+
+        # @return [Array<Proc>]
+        def before_initialize_hooks
+          @before_initialize_hooks ||= []
+        end
+
+        # @return [Array<Proc>]
+        def after_initialize_hooks
+          @after_initialize_hooks ||= []
+        end
+      end
+
+      # Holds the configuration for a plugin option.
+      class PluginOption
+        # @param [Symbol] name
+        # @param [Hash] options
+        # @option options [Object] :default
+        # @option options [Proc] :default_block Can also be set by passing a block.
+        # @option options [String] :doc_type
+        # @option options [String] :doc_default
+        # @option options [String] :docstring
+        # @option options [String] :rbs_type
+        def initialize(name, options = {})
+          @name = name
+          # prevent unstable object shapes by ensuring
+          # order and presence of instance variables
+          @default = nil
+          @default_block = nil
+          @doc_default = nil
+          @doc_type = nil
+          @docstring = nil
+          @rbs_type = nil
+          options.each_pair do |opt_name, opt_value|
+            send("#{opt_name}=", opt_value)
+          end
+        end
+
+        # @return [Symbol]
+        attr_reader :name
+
+        # @return [Object, nil]
+        attr_accessor :default
+
+        # @return [Proc, nil]
+        attr_accessor :default_block
+
+        # @return [String, nil]
+        attr_accessor :doc_default
+
+        # @return [String, nil]
+        attr_accessor :doc_type
+
+        # @return [String, nil]
+        attr_accessor :docstring
+
+        # @return [String, nil]
+        attr_accessor :rbs_type
+      end
+    end
+  end
+end

data/lib/smithy-client/plugin_list.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    # A list of plugins.
+    class PluginList
+      include Enumerable
+
+      # Initializes the plugin list with the given plugins.
+      # @param [Array, Set, PluginList] plugins
+      def initialize(plugins = [])
+        @mutex = Mutex.new
+        @plugins = Set.new
+        if plugins.is_a?(PluginList)
+          plugins.send(:each_plugin) { |plugin| _add(plugin) }
+        else
+          plugins.each { |plugin| _add(plugin) }
+        end
+      end
+
+      # Enumerates the plugins.
+      # @return [Enumerator]
+      def each
+        each_plugin do |plugin_wrapper|
+          yield(plugin_wrapper.plugin)
+        end
+      end
+
+      # Adds and returns the `plugin`.
+      # @param [Plugin] plugin
+      # @return [void]
+      def add(plugin)
+        @mutex.synchronize do
+          _add(plugin)
+        end
+        nil
+      end
+
+      # Removes and returns the `plugin`.
+      # @param [Plugin] plugin
+      # @return [void]
+      def remove(plugin)
+        @mutex.synchronize do
+          @plugins.delete(PluginWrapper.new(plugin))
+        end
+        nil
+      end
+
+      # Replaces the existing list of plugins.
+      # @param [Array<Plugin>] plugins
+      # @return [void]
+      def set(plugins)
+        @mutex.synchronize do
+          @plugins.clear
+          plugins.each do |plugin|
+            _add(plugin)
+          end
+        end
+        nil
+      end
+
+      private
+
+      # Not safe to call outside the mutex.
+      def _add(plugin)
+        @plugins << PluginWrapper.new(plugin)
+      end
+
+      # Yield each PluginDetail behind the mutex
+      def each_plugin(&block)
+        @mutex.synchronize do
+          @plugins.each(&block)
+        end
+      end
+
+      # A utility class that computes the canonical name for a plugin
+      # and defers requiring the plugin until the plugin class is
+      # required.
+      # @api private
+      class PluginWrapper
+        # @param [String, Symbol, Module, Class] plugin
+        def initialize(plugin)
+          case plugin
+          when Module
+            @canonical_name = plugin.name || plugin.object_id
+            @plugin = plugin
+          when Symbol, String
+            words = plugin.to_s.split('.')
+            @canonical_name = words.pop
+            @gem_name = words.empty? ? nil : words.join('.')
+            @plugin = nil
+          else
+            @canonical_name = plugin.object_id
+            @plugin = plugin
+          end
+        end
+
+        # @return [String]
+        attr_reader :canonical_name
+
+        # @return [Class<Plugin>]
+        def plugin
+          @plugin ||= require_plugin
+        end
+
+        # Returns the given plugin if it is already a PluginWrapper.
+        def self.new(plugin)
+          if plugin.is_a?(self)
+            plugin
+          else
+            super
+          end
+        end
+
+        # @return [Boolean]
+        # @api private
+        def eql?(other)
+          canonical_name == other.canonical_name
+        end
+
+        # @return [Integer]
+        # @api private
+        def hash
+          canonical_name.hash
+        end
+
+        private
+
+        # @return [Class<Plugin>]
+        def require_plugin
+          require(@gem_name) if @gem_name
+          plugin_class = Plugin
+          @canonical_name.split('::').each do |const_name|
+            plugin_class = plugin_class.const_get(const_name)
+          end
+          plugin_class
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/anonymous_auth.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../anonymous_provider'
+require_relative '../identities/anonymous'
+require_relative '../signers/anonymous'
+require_relative '../auth_schemes/anonymous'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class AnonymousAuth < Plugin
+        option(:anonymous_provider) do |_config|
+          AnonymousProvider.new
+        end
+
+        option(:anonymous_auth_scheme) do |_config|
+          Smithy::Client::AuthSchemes::Anonymous.new
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/checksum_required.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class ChecksumRequired < Plugin
+        def add_handlers(handlers, _config)
+          # Ensure checksum is computed AFTER the request is built but BEFORE it is signed
+          handlers.add(Handler, priority: 15)
+        end
+
+        # @api private
+        class Handler < Client::Handler
+          CHUNK_SIZE = 1 * 1024 * 1024 # one MB
+
+          def call(context)
+            if checksum_required_operation?(context)
+              context.http_request.headers['Content-Md5'] ||= md5(context.http_request.body)
+            end
+            @handler.call(context)
+          end
+
+          private
+
+          def checksum_required_operation?(context)
+            context.operation.traits.key?('smithy.api#httpChecksumRequired')
+          end
+
+          def md5(value)
+            md5 = OpenSSL::Digest.new('MD5')
+            update_in_chunks(md5, value)
+            md5.base64digest
+          end
+
+          def update_in_chunks(digest, io)
+            loop do
+              chunk = io.read(CHUNK_SIZE)
+              break unless chunk
+
+              digest.update(chunk)
+            end
+            io.rewind
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/content_length.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class ContentLength < Plugin
+        # @api private
+        class Handler < Client::Handler
+          # https://github.com/ruby/net-http/blob/master/lib/net/http/requests.rb
+          METHODS_WITH_BODY = Set.new(%w[POST PUT PATCH PROPFIND PROPPATCH MKCOL LOCK UNLOCK])
+
+          def call(context)
+            body = context.http_request.body
+            if body.respond_to?(:size) && METHODS_WITH_BODY.include?(context.http_request.http_method)
+              context.http_request.headers['Content-Length'] = body.size
+            end
+            @handler.call(context)
+          end
+        end
+
+        handler(Handler, step: :sign, priority: 10)
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/default_params.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class DefaultParams < Plugin
+        def add_handlers(handlers, _config)
+          handlers.add(Handler, step: :initialize)
+        end
+
+        # @api private
+        class Handler < Client::Handler
+          def call(context)
+            Client::DefaultParams.new(context.operation.input).apply(context.params)
+            @handler.call(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smithy-client/plugins/host_prefix.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Client
+    module Plugins
+      # @api private
+      class HostPrefix < Plugin
+        option(
+          :disable_host_prefix_injection,
+          default: false,
+          doc_type: 'Boolean',
+          docstring: 'When `true`, the SDK will not prepend the modeled host prefix to the endpoint.'
+        ) do |_config|
+          value = ENV['DISABLE_HOST_PREFIX_INJECTION'] || 'false'
+          Util.str_to_bool(value)
+        end
+
+        def after_initialize(client)
+          validate_disable_host_prefix_injection(client.config)
+        end
+
+        def validate_disable_host_prefix_injection(config)
+          return if [true, false].include?(config.disable_host_prefix_injection)
+
+          raise ArgumentError,
+                ':disable_host_prefix_injection must be either `true` or `false`'
+        end
+
+        def add_handlers(handlers, config)
+          handlers.add(Handler, priority: 25) unless config.disable_host_prefix_injection
+        end
+
+        # @api private
+        class Handler < Smithy::Client::Handler
+          def call(context)
+            host_prefix = context.operation.traits.dig('smithy.api#endpoint', 'hostPrefix')
+            apply_host_prefix(context, host_prefix) if host_prefix
+            @handler.call(context)
+          end
+
+          private
+
+          # TODO: optimize this to collect all labels in one pass
+          def apply_host_prefix(context, host_prefix)
+            input = context.operation.input
+            prefix = host_prefix.gsub(/\{.+?}/) do |label|
+              label_value(input, label.delete('{}'), context.params)
+            end
+            context.http_request.endpoint.host = prefix + context.http_request.endpoint.host
+          end
+
+          def label_value(input, label, params)
+            name = nil
+            input.shape.members.each do |member_name, member_ref|
+              next unless member_ref.traits.key?('smithy.api#hostLabel')
+              next unless member_ref.member_name == label
+
+              name = member_name
+            end
+            raise ArgumentError, "#{label} is not a valid host label" if name.nil?
+            raise ArgumentError, "params[:#{name}] must not be nil or blank" if params[name].nil? || params[name].empty?
+
+            params[name]
+          end
+        end
+      end
+    end
+  end
+end