aws-sdk-code-generator 0.2.4.pre → 0.3.0.pre

data/lib/aws-sdk-code-generator/views/endpoints_module.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class EndpointsModule < View
+      # @option options [required, Service] :service
+      def initialize(options)
+        @service = options.fetch(:service)
+
+        @parameters = @service.endpoint_rules.fetch('parameters', {})
+
+        @endpoint_classes = @service.api['operations'].each.with_object([]) do
+          |(name, op), array|
+          array << EndpointClass.new(
+            name: name,
+            parameters: endpoint_parameters_for_operation(op)
+          )
+        end
+      end
+
+      # @return [Array<EndpointClass>]
+      attr_reader :endpoint_classes
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
+      def module_name
+        @service.module_name
+      end
+
+      class EndpointClass
+        def initialize(options)
+          @name = options[:name]
+          @parameters = options[:parameters]
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [Array<EndpointParameter>]
+        attr_reader :parameters
+
+        def has_endpoint_built_in?
+          parameters.any? { |p| p.param_data['builtIn'] == 'SDK::Endpoint' }
+        end
+      end
+
+      class EndpointParameter
+        def initialize(options)
+          @key = options[:key]
+          @value = options[:value]
+          @source = options[:source]
+          @param_data = options[:param_data]
+        end
+
+        # @return [String]
+        attr_accessor :key
+
+        # @return [String]
+        attr_accessor :value
+
+        # @return [String]
+        attr_accessor :source
+
+        # @return [Hash]
+        attr_accessor :param_data
+
+        def static_string?
+          @source == 'staticContextParam' && value.is_a?(String)
+        end
+      end
+
+
+      private
+
+      def endpoint_parameters_for_operation(operation)
+        @parameters.each.with_object([]) do |(param_name, param_data), endpoint_parameters|
+          value, source = endpoint_parameter_value(
+            operation, param_name, param_data
+          )
+
+          endpoint_parameters << EndpointParameter.new(
+            key: Underscore.underscore(param_name),
+            value: value,
+            source: source,
+            param_data: param_data
+          )
+        end
+      end
+
+      # Most to least
+      # staticContextParams
+      # contextParam
+      # clientContextParams
+      # Built-In Bindings
+      # Built-in binding default values
+      def endpoint_parameter_value(operation, param_name, param_data)
+        value, source = [
+          static_context_param(operation, param_name), 'staticContextParam'
+        ]
+        value, source = [
+          context_param_value(operation, param_name), 'contextParam'
+        ] unless value
+        value, source = [
+          client_context_param_value(param_name, param_data),
+          'clientContextParam'
+        ] unless value
+        value, source = [
+          built_in_client_context_param_value(param_data), 'builtIn'
+        ] unless value
+
+        [value || 'nil', source]
+      end
+
+      def client_context_param_value(param_name, param_data)
+        if @service.api['clientContextParams']&.key?(param_name) &&
+           !param_data['builtIn']
+          "context.config.#{Underscore.underscore(param_name)}"
+        end
+      end
+
+      def built_in_client_context_param_value(param_data)
+        case param_data['builtIn']
+        when 'AWS::Region'
+          'context.config.region'
+        when 'AWS::UseFIPS'
+          'context.config.use_fips_endpoint'
+        when 'AWS::UseDualStack'
+          if @service.name == 'S3' || @service.name == 'S3Control'
+            'context[:use_dualstack_endpoint]'
+          else
+            'context.config.use_dualstack_endpoint'
+          end
+        when 'AWS::STS::UseGlobalEndpoint'
+          "context.config.sts_regional_endpoints == 'legacy'"
+        when 'AWS::S3::UseGlobalEndpoint'
+          "context.config.s3_us_east_1_regional_endpoint == 'legacy'"
+        when 'AWS::S3::Accelerate'
+          if @service.name == 'S3' || @service.name == 'S3Control'
+            'context[:use_accelerate_endpoint]'
+          else
+            'context.config.use_accelerate_endpoint'
+          end
+        when 'AWS::S3::ForcePathStyle'
+          'context.config.force_path_style'
+        when 'AWS::S3::UseArnRegion', 'AWS::S3Control::UseArnRegion'
+          'context.config.s3_use_arn_region'
+        when 'AWS::S3::DisableMultiRegionAccessPoints'
+          'context.config.s3_disable_multiregion_access_points'
+        when 'SDK::Endpoint'
+          'endpoint'
+        end
+      end
+
+      def context_param_value(operation, param_name)
+        return nil unless operation['input']
+
+        input_shape = operation['input']['shape']
+        members = @service.api['shapes'][input_shape].fetch('members', {})
+        members.detect do |(member_name, member)|
+          context_param = member.fetch('contextParam', {})
+          if context_param.fetch('name', nil) == param_name
+            break "context.params[:#{Underscore.underscore(member_name)}]"
+          end
+        end
+      end
+
+      def static_context_param(operation, param_name)
+        operation.fetch('staticContextParams', {})
+                 .fetch(param_name, {}).fetch('value', nil)
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/endpoints_plugin.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    class EndpointsPlugin < View
+      # @option options [required, Service] :service
+      def initialize(options)
+        @service = options.fetch(:service)
+        if (client_options = @service.api['clientContextParams'])
+          endpoint_parameters = @service.endpoint_rules.fetch('parameters', {})
+
+          @endpoint_options = client_options.each.with_object([]) do |(name, _data), array|
+            param_data = endpoint_parameters[name]
+
+            next if param_data['builtIn']
+
+            array << EndpointOption.new(
+              name: Underscore.underscore(name),
+              docstring: param_data['documentation'],
+              doc_type: param_data['type'],
+              default: param_data['default']
+            )
+          end
+        end
+        @endpoint_classes = @service.api['operations'].each.with_object([]) do
+          |(op, _api), array|
+          array << EndpointClass.new(
+            operation_name: Underscore.underscore(op),
+            class_name: op
+          )
+        end
+      end
+
+      # @return [Array<EndpointClass>]
+      attr_reader :endpoint_classes
+
+      # @return [Array<EndpointOption>, nil]
+      attr_reader :endpoint_options
+
+      # @return [String|nil]
+      def generated_src_warning
+        return if @service.protocol == 'api-gateway'
+        GENERATED_SRC_WARNING
+      end
+
+      def module_name
+        @service.module_name
+      end
+
+      class EndpointClass
+        def initialize(options)
+          @operation_name = options[:operation_name]
+          @class_name = options[:class_name]
+        end
+
+        # @return [String]
+        attr_reader :operation_name
+
+        # @return [String]
+        attr_reader :class_name
+      end
+
+      class EndpointOption
+        def initialize(options)
+          @name = options[:name]
+          @doc_type = options[:doc_type]
+          @default = options[:default].nil? ? 'nil' : options[:default]
+          @docstring = options[:docstring]
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [String]
+        attr_reader :doc_type
+
+        # @return [Boolean,String]
+        attr_reader :default
+
+        # @return [String]
+        attr_reader :docstring
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/gemspec.rb

@@ -42,6 +42,10 @@ module AwsSdkCodeGenerator
         @custom ? false : true
       end
 
+      def files
+        ['LICENSE.txt', 'CHANGELOG.md', 'VERSION', 'lib/**/*.rb']
+      end
+
       # @return [String]
       def description
         if @custom

data/lib/aws-sdk-code-generator/views/service_module.rb

@@ -11,6 +11,7 @@ module AwsSdkCodeGenerator
       def initialize(options)
         @service = options.fetch(:service)
         @prefix = options.fetch(:prefix)
+        @codegenerated_plugins = options.fetch(:codegenerated_plugins)
       end
 
       # @return [String|nil]
@@ -56,7 +57,7 @@ module AwsSdkCodeGenerator
       # This is required to support backwards compatibility for SSO which was
       # moved from the aws-sdk-sso gem into aws-sdk-core.
       def require_core_guard?
-        name == 'SSO' || name == 'STS'
+        @service.included_in_core?
       end
 
       # @return [Array<String>]
@@ -64,10 +65,23 @@ module AwsSdkCodeGenerator
         paths = Set.new
         paths << "#{@prefix}/types"
         paths << "#{@prefix}/client_api"
+
+        # these must be required before the client
+        if @codegenerated_plugins
+          paths += @codegenerated_plugins.map { | p| p.path }
+        end
+
         paths << "#{@prefix}/client"
         paths << "#{@prefix}/errors"
         paths << "#{@prefix}/waiters" if @service.waiters
         paths << "#{@prefix}/resource"
+
+        unless @service.legacy_endpoints?
+          paths << "#{@prefix}/endpoint_parameters"
+          paths << "#{@prefix}/endpoint_provider"
+          paths << "#{@prefix}/endpoints"
+        end
+
         if @service.resources && @service.resources['resources']
           @service.resources['resources'].keys.each do |resource_name|
             path = "#{@prefix}/#{underscore(resource_name)}"

data/lib/aws-sdk-code-generator/views/spec/endpoint_provider_spec_class.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    module Spec
+      class EndpointProviderSpecClass < View
+
+        # @param [Hash] options
+        # @option options [required, Service] :service
+        def initialize(options)
+          @service = options.fetch(:service)
+          test_cases = @service.endpoint_tests.fetch('testCases', [])
+          @endpoint_tests = test_cases.map do |endpoint_test|
+            EndpointProviderTest.new(
+              service: @service,
+              documentation: endpoint_test['documentation'],
+              params: endpoint_test['params'],
+              tags: endpoint_test['tags'],
+              expect: endpoint_test['expect'],
+              operation_inputs: endpoint_test['operationInputs']
+            )
+          end
+        end
+
+        # @return [Array<EndpointProviderTest>]
+        attr_reader :endpoint_tests
+
+        # @return [String|nil]
+        def generated_src_warning
+          return if @service.protocol == 'api-gateway'
+          GENERATED_SRC_WARNING
+        end
+
+        def module_name
+          @service.module_name
+        end
+
+        class EndpointProviderTest
+          def initialize(options)
+            @service = options[:service]
+            @documentation = options[:documentation]
+            @params = options[:params]&.map do |key, value|
+              [Underscore.underscore(key).to_sym, value]
+            end.to_h
+            @tags = options[:tags]
+            @expect = options[:expect]
+            operation_inputs = options[:operation_inputs] || []
+            @operation_inputs = operation_inputs.map do |operation_inputs_test|
+              OperationInputsTest.new(
+                service: @service,
+                operation_name: Underscore.underscore(
+                  operation_inputs_test['operationName']
+                ),
+                operation_params: operation_inputs_test['operationParams'] || [],
+                built_in_params: operation_inputs_test['builtInParams'] || [],
+                client_params: operation_inputs_test['clientParams'] || []
+              )
+            end
+          end
+
+          # @return [String]
+          attr_reader :documentation
+
+          # @return [Hash<Symbol, String>]
+          attr_reader :params
+
+          # @return [Array<String>]
+          attr_reader :tags
+
+          # @return [Hash]
+          attr_reader :expect
+
+          # # @return [Array<OperationInput>]
+          attr_reader :operation_inputs
+
+          def expect_error?
+            !@expect['error'].nil?
+          end
+
+          def expected_auth
+            if expect_auth?
+              @expect['endpoint']['properties']['authSchemes'].first
+            end
+          end
+
+          def expect_auth?
+            @expect['endpoint'] &&
+              @expect['endpoint']['properties'] &&
+              @expect['endpoint']['properties']['authSchemes'] &&
+              !@expect['endpoint']['properties']['authSchemes'].empty?
+          end
+
+          def expected_headers
+            @expect['endpoint']['headers'].map { |k,v| Param.new(k, v.join(",")) }
+          end
+
+          def expect_headers?
+            @expect['endpoint'] &&
+              @expect['endpoint']['headers'] &&
+              !@expect['endpoint']['headers'].empty?
+          end
+
+        end
+
+        class OperationInputsTest
+
+          def initialize(options)
+            @service = options[:service]
+            @operation_name = options[:operation_name]
+            @operation_params = options[:operation_params].map do |k,v|
+              Param.new(Underscore.underscore(k), transform_operation_values(v))
+            end
+            @client_params = options[:client_params].map do |k,v|
+              Param.new(Underscore.underscore(k), v)
+            end
+
+            @client_params += options[:built_in_params].map do |k,v|
+              built_in_to_param(k, v)
+            end
+            # the expected default of UseGlobalEndpoint does not match the SDK's default value
+            if @service.identifier == 's3' && !options[:built_in_params].include?('AWS::S3::UseGlobalEndpoint')
+              @client_params << built_in_to_param('AWS::S3::UseGlobalEndpoint', false)
+            end
+          end
+
+          # @return String
+          attr_reader :operation_name
+
+          # @return [Hash<String, String>]
+          attr_reader :operation_params
+
+          # @return [Hash<String, String>]
+          attr_reader :client_params
+
+          private
+          def transform_operation_values(value)
+            case value
+            when Hash
+              value.each_with_object({}) do |(k, v), o|
+                o[Underscore.underscore(k)] = transform_operation_values(v)
+              end
+            when Array
+              value.map { |v| transform_operation_values(v) }
+            else
+              value
+            end
+          end
+
+          def built_in_to_param(built_in, value)
+            case built_in
+            when 'AWS::Region'
+              Param.new('region', value)
+            when 'AWS::UseFIPS'
+              Param.new('use_fips_endpoint', value)
+            when 'AWS::UseDualStack'
+              Param.new('use_dualstack_endpoint', value)
+            when 'AWS::STS::UseGlobalEndpoint'
+              Param.new('sts_regional_endpoints', value ? 'legacy' : 'regional')
+            when 'AWS::S3::UseGlobalEndpoint'
+              Param.new('s3_us_east_1_regional_endpoint', value ? 'legacy' : 'regional')
+            when 'AWS::S3::Accelerate'
+              Param.new('use_accelerate_endpoint', value)
+            when 'AWS::S3::ForcePathStyle'
+              Param.new('force_path_style', value)
+            when 'AWS::S3::UseArnRegion'
+              Param.new('s3_use_arn_region', value)
+            when 'AWS::S3Control::UseArnRegion'
+              Param.new('s3_use_arn_region', value)
+            when 'AWS::S3::DisableMultiRegionAccessPoints'
+              Param.new('s3_disable_multiregion_access_points', value)
+            when 'SDK::Endpoint'
+              Param.new('endpoint', value)
+            else
+              raise ArgumentError, "#{built_in} not supported."
+            end
+          end
+        end
+
+        class Param
+          def initialize(param, value)
+            @param = param
+            @value = value
+          end
+          attr_accessor :param
+
+          def value
+            if @value.is_a? String
+              "'#{@value}'"
+            else
+              @value
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/spec/spec_helper.rb

@@ -9,13 +9,14 @@ module AwsSdkCodeGenerator
 
         # @param [Hash] options
         # @option options [required, Service] :service
+        # @option options[required, String] :aws_sdk_core_lib_path
         def initialize(options)
-          service = options.fetch(:service)
-          @gem_name = service.gem_name
-          @gem_dependencies = service.gem_dependencies.map do |gem_name, _|
+          @service = options.fetch(:service)
+          @gem_name = @service.gem_name
+          @gem_dependencies = @service.gem_dependencies.map do |gem_name, _|
             { dependency: gem_name }
           end
-          @custom = service.protocol == 'api-gateway'
+          @custom = @service.protocol == 'api-gateway'
         end
 
         attr_reader :gem_name
@@ -27,6 +28,10 @@ module AwsSdkCodeGenerator
           GENERATED_SRC_WARNING
         end
 
+        def included_in_core
+          @service.included_in_core?
+        end
+
       end
     end
   end

data/lib/aws-sdk-code-generator/views/types_module.rb

@@ -141,13 +141,14 @@ module AwsSdkCodeGenerator
           elsif shape['union']
             "@note #{shape_name} is a union - when making an API calls you"\
             ' must set exactly one of the members.'
-          else
-            note = "@note When making an API call, you may pass #{shape_name}\n"
-            note += "  data as a hash:\n\n"
-            note += '      ' + SyntaxExampleHash.new(
-              shape: shape(shape_name),
-              api: @service.api,
-            ).format('      ')
+          # This doc block is no longer useful, but keeping for records
+          # else
+          #   note = "@note When making an API call, you may pass #{shape_name}\n"
+          #   note += "  data as a hash:\n\n"
+          #   note += '      ' + SyntaxExampleHash.new(
+          #     shape: shape(shape_name),
+          #     api: @service.api,
+          #   ).format('      ')
           end
         end
       end

data/lib/aws-sdk-code-generator.rb

@@ -2,6 +2,7 @@
 
 require_relative 'aws-sdk-code-generator/api'
 require_relative 'aws-sdk-code-generator/apply_docs'
+require_relative 'aws-sdk-code-generator/codegenerated_plugin'
 require_relative 'aws-sdk-code-generator/client_constructor'
 require_relative 'aws-sdk-code-generator/client_operation_documentation'
 require_relative 'aws-sdk-code-generator/client_operation_list'
@@ -53,9 +54,14 @@ require_relative 'aws-sdk-code-generator/views/features/smoke_step_definitions'
 require_relative 'aws-sdk-code-generator/views/features/smoke'
 require_relative 'aws-sdk-code-generator/views/gemspec'
 require_relative 'aws-sdk-code-generator/views/resource_class'
+require_relative 'aws-sdk-code-generator/views/endpoint_parameters_class'
+require_relative 'aws-sdk-code-generator/views/endpoint_provider_class'
+require_relative 'aws-sdk-code-generator/views/endpoints_module'
+require_relative 'aws-sdk-code-generator/views/endpoints_plugin'
 require_relative 'aws-sdk-code-generator/views/root_resource_class'
 require_relative 'aws-sdk-code-generator/views/service_module'
 require_relative 'aws-sdk-code-generator/views/spec/spec_helper'
+require_relative 'aws-sdk-code-generator/views/spec/endpoint_provider_spec_class'
 require_relative 'aws-sdk-code-generator/views/types_module'
 require_relative 'aws-sdk-code-generator/views/event_streams_module'
 require_relative 'aws-sdk-code-generator/views/authorizer_class'

data/templates/async_client_class.mustache

@@ -66,11 +66,11 @@ module {{module_name}}
 
       {{#eventstream_input}}
       req.context[:input_event_stream_handler] = input_event_stream_handler
-      req.handlers.add(Aws::Binary::EncodeHandler, priority: 95)
+      req.handlers.add(Aws::Binary::EncodeHandler, priority: 55)
       {{/eventstream_input}}
       {{#eventstream_output}}
       req.context[:output_event_stream_handler] = output_event_stream_handler
-      req.handlers.add(Aws::Binary::DecodeHandler, priority: 95)
+      req.handlers.add(Aws::Binary::DecodeHandler, priority: 55)
       {{/eventstream_output}}
 
       req.send_request(options{{{block_option}}})

data/templates/client_api_module.mustache

@@ -44,6 +44,13 @@ module {{module_name}}
         {{#http_checksum_required}}
         o.http_checksum_required = true
         {{/http_checksum_required}}
+        {{#http_checksum}}
+        o.http_checksum = {
+          {{#http_checksum}}
+          {{{key}}} => {{{value}}},
+          {{/http_checksum}}
+        }
+        {{/http_checksum}}
         {{#deprecated}}
         o.deprecated = true
         {{/deprecated}}

data/templates/client_class.mustache

@@ -45,7 +45,7 @@ module {{module_name}}
     #     seconds to wait when opening a HTTP session before raising a
     #     `Timeout::Error`.
     #
-    #   @option options [Integer] :http_read_timeout (60) The default
+    #   @option options [Float] :http_read_timeout (60) The default
     #     number of seconds to wait for response data.  This value can
     #     safely be set per-request on the session.
     #
@@ -61,6 +61,9 @@ module {{module_name}}
     #     disables this behaviour.  This value can safely be set per
     #     request on the session.
     #
+    #   @option options [Float] :ssl_timeout (nil) Sets the SSL timeout
+    #     in seconds.
+    #
     #   @option options [Boolean] :http_wire_trace (false) When `true`,
     #     HTTP debug output will be sent to the `:logger`.
     #

data/templates/endpoint_parameters_class.mustache

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+module {{module_name}}
+  # Endpoint parameters used to influence endpoints per request.
+  #
+  {{#parameters}}
+  {{documentation}}
+  {{/parameters}}
+  EndpointParameters = Struct.new(
+    {{#parameters}}
+    :{{underscore_name}},
+    {{/parameters}}
+    {{^parameters}}
+    nil
+    {{/parameters}}
+  ) do
+    include Aws::Structure
+
+    # @api private
+    class << self
+      PARAM_MAP = {
+        {{#parameters}}
+        '{{name}}' => :{{underscore_name}},
+        {{/parameters}}
+      }.freeze
+    end
+
+    def initialize(options = {})
+      {{#parameters}}
+      self[:{{underscore_name}}] = options[:{{underscore_name}}]
+      {{#default?}}
+      {{#boolean_default?}}
+      self[:{{underscore_name}}] = {{default}} if self[:{{underscore_name}}].nil?
+      {{/boolean_default?}}
+      {{^boolean_default?}}
+      self[:{{underscore_name}}] ||= '{{default}}' if self[:{{underscore_name}}].nil?
+      {{/boolean_default?}}
+      {{/default?}}
+      {{#required}}
+      if self[:{{underscore_name}}].nil?
+        raise ArgumentError, "Missing required EndpointParameter: :{{underscore_name}}"
+      end
+      {{/required}}
+      {{/parameters}}
+    end
+  end
+end