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

data/lib/aws-sdk-code-generator/views/features/smoke.rb

@@ -10,35 +10,25 @@ module AwsSdkCodeGenerator
         def initialize(options)
           service = options.fetch(:service)
           @custom = service.protocol == 'api-gateway'
-          @service = service.name
+          @service_name = service.name
+          @service_module = service.module_name
 
           # This will only be called if this is defined
           smoke_json = service.smoke_tests
-          @client_region = smoke_json["defaultRegion"]
-          @client_endpoint = smoke_json["defaultEndpoint"]
-          @smoke_tests = smoke_json["testCases"].map do |test|
-            h = {
-              operation: underscore(test["operationName"]),
-              smoke_test_tags: "@#{service.identifier} @smoke",
-            }
-            if test["errorExpectedFromService"]
-              h[:error_expectation] = "I expect an error was raised"
-              h[:scenario_string] = "Call Aws::#{service.module_name}::Client##{h[:operation]} and expect it to fail"
-            else
-              h[:error_expectation] = "I expect an error was not raised"
-              h[:scenario_string] = "Call #{service.module_name}::Client##{h[:operation]} and expect it to succeed"
-            end
-            h[:param_hash] = test["input"].inject({}) do |acc, kv|
-              raw_key, value = kv
-              key = underscore(raw_key)
-              acc[key] = value
-              acc
-            end.to_json
-            h
+          @smoke_tests = smoke_json['testCases'].map do |test|
+            SmokeTest.new(
+              service: service,
+              id: test['id'],
+              operation_name: test['operationName'],
+              input: test['input'],
+              expectation: test['expectation'],
+              config: test['config'],
+              tags: test['tags']
+            )
           end
         end
 
-        attr_reader :service, :client_region, :client_endpoint, :smoke_tests
+        attr_reader :service_name, :smoke_tests, :service_module
 
         # @return [String|nil]
         def generated_src_warning
@@ -46,6 +36,92 @@ module AwsSdkCodeGenerator
           GENERATED_SRC_WARNING
         end
 
+        class SmokeTest < View
+          def initialize(options)
+            @service = options.fetch(:service)
+            @id = options.fetch(:id)
+            @operation_name = underscore(options.fetch(:operation_name))
+            @input = options.fetch(:input)
+            @expectation = expectation_str(options.fetch(:expectation))
+            @config = options.fetch(:config)
+
+            tags = options.fetch(:tags) || []
+            tags = tags.map { |t| "@#{t}" }.join(' ')
+            @tags = "@#{@service.identifier} @smoke #{tags}".strip
+          end
+
+          attr_reader :id, :operation_name, :expectation, :tags
+
+          def param_hash
+            deep_underscore(@input).to_json
+          end
+
+          def config_hash
+            @config.each_with_object({}) do |(raw_key, raw_value), acc|
+              key, value = config_map(raw_key, raw_value)
+              acc[key] = value unless key.nil?
+            end.to_json
+          end
+
+          private
+
+          def deep_underscore(input)
+            case input
+            when Hash
+              input.each_with_object({}) do |(key, value), acc|
+                acc[underscore(key)] = deep_underscore(value)
+              end
+            when Array
+              input.map { |value| deep_underscore(value) }
+            else
+              input
+            end
+          end
+
+          def config_map(raw_key, raw_value)
+            case raw_key
+            # generic
+            when 'region' then ['region', raw_value]
+            when 'sigv4aRegionSet' then nil # TODO
+            when 'uri' then ['endpoint', raw_value]
+            when 'useFips' then ['use_fips_endpoint', raw_value]
+            when 'useDualStack' then ['use_dualstack_endpoint', raw_value]
+            # service specific
+            when 'useGlobalEndpoint'
+              value = raw_value == 'true' ? 'legacy' : 'regional'
+              if @service.name == 'S3'
+                ['s3_us_east_1_regional_endpoint', value]
+              elsif @service.name == 'STS'
+                ['sts_regional_endpoints', value]
+              end
+            # s3 specific
+            when 'useAccelerate' then ['use_accelerate_endpoint', raw_value]
+            when 'useArnRegion' then ['s3_use_arn_region', raw_value]
+            when 'useMultiRegionAccessPoints'
+              value = raw_value == 'true' ? 'false' : 'true'
+              ['s3_disable_multiregion_access_points', value]
+            when 'forcePathStyle' then ['force_path_style', raw_value]
+            when 'useAccountIdRouting' then nil # TODO
+            else
+              # catch all, possible code generated config options
+              [downcase(raw_key), raw_value]
+            end
+          end
+
+          def expectation_str(expectation)
+            if expectation.key?('success')
+              'I expect an error was not raised'
+            elsif expectation.key?('failure')
+              if (error_id = expectation['failure']['errorId'])
+                error_class = "#{@service.module_name}::Errors::#{error_id}"
+                "I expect a '#{error_class}' was raised"
+              else
+                'I expect an error was raised'
+              end
+            end
+          end
+        end
+
       end
     end
   end

data/lib/aws-sdk-code-generator/views/features/step_definitions.rb

@@ -11,12 +11,9 @@ module AwsSdkCodeGenerator
           service = options.fetch(:service)
           @var_name = service.identifier
           @module_name = service.module_name
-          if service.smoke_tests
-            @client_endpoint = service.smoke_tests['defaultEndpoint']
-          end
         end
 
-        attr_reader :var_name, :module_name, :client_endpoint
+        attr_reader :var_name, :module_name
 
       end
     end

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

@@ -43,7 +43,7 @@ module AwsSdkCodeGenerator
       end
 
       def files
-        ['LICENSE.txt', 'CHANGELOG.md', 'VERSION', 'lib/**/*.rb']
+        ['LICENSE.txt', 'CHANGELOG.md', 'VERSION', 'lib/**/*.rb', 'sig/**/*.rbs']
       end
 
       # @return [String]
@@ -54,7 +54,9 @@ module AwsSdkCodeGenerator
           if @service.short_name != @service.full_name
             abbreviation = " (#{@service.short_name})"
           end
-          desc = "Official AWS Ruby gem for #{@service.full_name}#{abbreviation}. "
+          desc = ''
+          desc += '[DEPRECATED] ' if @service.deprecated?
+          desc += "Official AWS Ruby gem for #{@service.full_name}#{abbreviation}. "
           desc += 'This gem is part of the AWS SDK for Ruby.'
         end
         desc
@@ -72,7 +74,15 @@ module AwsSdkCodeGenerator
         end
       end
 
-      Dependency = Struct.new(:gem, :version)
+      def deprecated?
+        @service.deprecated?
+      end
+
+      Dependency = Struct.new(:gem, :version) do
+        def gem_version
+          [gem, version].compact.map { |s| "'#{s}'"}.join(', ')
+        end
+      end
 
     end
   end

data/lib/aws-sdk-code-generator/views/rbs/client_class.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    module RBS
+      class ClientClass < View
+        SKIP_MEMBERS = Set.new(%w[
+          context
+          data
+          error
+          checksum_validated
+          on
+          on_success
+        ])
+
+        def initialize(options)
+          @options = options
+          @service_name = options.fetch(:service_name)
+          @api = options.fetch(:api)
+          @aws_sdk_core_lib_path = options.fetch(:aws_sdk_core_lib_path)
+          @plugins = PluginList.new(options)
+          @codegenerated_plugins = options.fetch(:codegenerated_plugins)
+          @waiters = AwsSdkCodeGenerator::RBS::Waiter.build_list(api: @api, waiters:options.fetch(:waiters))
+        end
+
+        # @return [String|nil]
+        def generated_src_warning
+          GENERATED_SRC_WARNING
+        end
+
+        def service_name
+          @service_name
+        end
+
+        def client_option(indent: ' ' * 20)
+          plugin_options = documented_plugin_options(@plugins) + documented_plugin_options(@codegenerated_plugins)
+          [
+            '',
+            "#{indent}  #{build_keyword_arguments(plugin_options).join(",\n#{indent}  ")}",
+            indent,
+          ].join("\n")
+        end
+
+        def operations
+          shapes = @api["shapes"]
+          @api["operations"].map do |name, body|
+            method_name = Underscore.underscore(name)
+            indent = " " * (12 + method_name.length)
+            input_shape_name = body.dig("input", "shape")
+            arguments = nil
+            include_required = false
+            if input_shape_name
+              input_shape = shapes[input_shape_name]
+              builder = AwsSdkCodeGenerator::RBS::KeywordArgumentBuilder.new(
+                api: @api,
+                shape: input_shape,
+                newline: true,
+              )
+              arguments = builder.format(indent: indent)
+              include_required = input_shape["required"]&.empty?&.!
+            end
+            if AwsSdkCodeGenerator::Helper.operation_streaming?(body, @api)
+              block = " ?{ (*untyped) -> void }"
+            end
+            if output_shape_name = body.dig("output", "shape")
+              output_shape = shapes[output_shape_name]
+              data = AwsSdkCodeGenerator::RBS.to_type(body.fetch( "output"), @api)
+              interface = "_#{name}ResponseSuccess"
+            else
+              output_shape = nil
+              data = "::Aws::EmptyStructure"
+              interface = empty_interface = "::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]"
+            end
+            returns_members = output_shape&.[]("members")&.inject([]) do |a, (member_name, member_ref)|
+              member_name_underscore = Underscore.underscore(member_name)
+              next a if SKIP_MEMBERS.include?(member_name_underscore)
+              a << {
+                method_name: member_name_underscore,
+                returns: AwsSdkCodeGenerator::RBS.to_type(member_ref, @api),
+              }
+            end
+
+            {
+              method_name: method_name,
+              signature: AwsSdkCodeGenerator::RBS::MethodSignature.new(
+                method_name: method_name,
+                overloads: [
+                  "(#{arguments})#{block} -> #{interface}",
+                  "(#{include_required ? "" : "?"}Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options)#{block} -> #{interface}",
+                ]).signature,
+              interface: interface,
+              data: data,
+              returns_members: returns_members,
+              empty_structure: output_shape.nil?
+            }
+          end
+        end
+
+        def waiters?
+          @waiters.size > 0
+        end
+
+        def waiters_first
+          [@waiters.first]
+        end
+
+        def waiters_others
+          @waiters[1..-1]
+        end
+
+        private
+
+        def documented_plugin_options(plugins)
+          i = 0
+          plugins.map(&:options).flatten.select(&:documented?).sort_by do |opt|
+            [opt.required ? 'a' : 'b', opt.name, i += 1]
+          end
+        end
+
+        def build_keyword_arguments(plugins)
+          buffer = plugins.map do |opt|
+            if opt.rbs_type
+              opt.rbs_type
+            else
+              case opt.doc_type
+              when "Boolean"
+                "bool"
+              when nil
+                "untyped"
+              else
+                opt.doc_type.to_s
+              end
+            end.yield_self do |type|
+              [opt.name, "?#{opt.name}: #{type}", opt.doc_type]
+            end
+          end
+          # Find duplicated key
+          grouped = buffer.group_by { |name, _| name }
+          grouped.transform_values(&:count).find_all { |_, c| 1 < c }.each do |name,|
+            case name
+            when :endpoint, :endpoint_provider, :retry_limit, :disable_s3_express_session_auth
+              # ok
+            else
+              warn("Duplicate client option in #{@service_name}: `#{grouped[name].map { |g| g.values_at(0, 2) }}`", uplevel: 0)
+            end
+          end
+          buffer.uniq! { |b| b[0] }
+          buffer.map! { |b| b[1] }
+          buffer.concat([
+            # from mustache
+            "?http_proxy: String",
+            "?http_open_timeout: (Float | Integer)",
+            "?http_read_timeout: (Float | Integer)",
+            "?http_idle_timeout: (Float | Integer)",
+            "?http_continue_timeout: (Float | Integer)",
+            "?ssl_timeout: (Float | Integer | nil)",
+            "?http_wire_trace: bool",
+            "?ssl_verify_peer: bool",
+            "?ssl_ca_bundle: String",
+            "?ssl_ca_directory: String",
+            # from object
+            "?ssl_ca_store: String",
+            "?on_chunk_received: Proc",
+            "?on_chunk_sent: Proc",
+            "?raise_response_errors: bool",
+          ])
+          buffer
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/rbs/errors_module.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    module RBS
+      class ErrorsModule < View
+        attr_reader :errors
+
+        def initialize(service:)
+          @service = service
+          @errors = AwsSdkCodeGenerator::RBS::ErrorList.new(
+            api: service.api,
+            module_name: service.module_name
+          ).to_a
+        end
+
+        # @return [String|nil]
+        def generated_src_warning
+          GENERATED_SRC_WARNING
+        end
+
+        def service_name
+          @service.name
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/rbs/resource_class.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    module RBS
+      class ResourceClass < View
+        attr_reader :service_name
+        attr_reader :class_name
+        attr_reader :identifiers
+        attr_reader :data_attributes
+        attr_reader :shape
+        attr_reader :exists_waiters
+        attr_reader :waiters
+        attr_reader :actions
+        attr_reader :associations
+        attr_reader :batch_actions
+
+        def initialize(service_name:, class_name:, resource:, api:, paginators:)
+          @class_name = class_name
+          @resource = resource
+          @service_name = service_name
+          @identifiers = ResourceIdentifier.build_list(resource)
+          @data_attributes = if @resource["shape"]
+            data_attribute_names = AwsSdkCodeGenerator::ResourceAttribute.send(:data_attribute_names, @resource, api)
+            data_attribute_names.map do |member_name, member_ref|
+              AwsSdkCodeGenerator::RBS::MethodSignature.new(
+                method_name: Underscore.underscore(member_name),
+                overloads: ["() -> #{AwsSdkCodeGenerator::RBS.to_type(member_ref, api)}"]
+              )
+            end
+          else
+            []
+          end
+          @shape = @resource["shape"]
+          @exists_waiters = @resource.fetch("waiters", []).any? { |name, _| name == "Exists" }
+          @waiters = @resource.fetch("waiters", []).map do |waiter_name, waiter_body|
+            AwsSdkCodeGenerator::RBS::MethodSignature.new(
+              method_name: "wait_until_#{Underscore.underscore(waiter_name)}",
+              overloads: [
+                "(?max_attempts: Integer, ?delay: Numeric, ?before_attempt: (^(Integer attempts) -> void), ?before_wait: (^(Integer attempts, untyped response) -> void)) ?{ (untyped waiter) -> void } -> #{class_name}",
+                "(?Hash[Symbol, untyped]) ?{ (untyped waiter) -> void } -> #{class_name}",
+              ],
+            )
+          end
+          @actions = AwsSdkCodeGenerator::RBS::ResourceAction.build_method_signature_list(resource: @resource, api: api)
+          @associations = AwsSdkCodeGenerator::RBS::ResourceAssociation.build_method_signature_list(resource: @resource, api: api, paginators: paginators)
+          @batch_actions = AwsSdkCodeGenerator::RBS::ResourceBatchAction.build_method_signature_list(resource: @resource, api: api)
+          avoid_duplicate_methods
+        end
+
+        # @return [String|nil]
+        def generated_src_warning
+          GENERATED_SRC_WARNING
+        end
+
+        def initialize_signature
+          initialize_overloads =
+            if @identifiers.empty?
+              []
+            else
+              positional = @identifiers.map { |id| "#{id.type} #{id.name}" } << "Hash[Symbol, untyped] options"
+              keyword = @identifiers.map { |id| "#{id.name}: #{id.type}" } << "?client: Client"
+              [
+                "(#{positional.join(', ')}) -> void",
+                "(#{keyword.join(', ')}) -> void"
+              ]
+            end
+          initialize_overloads << "(Hash[Symbol, untyped] args) -> void"
+          "def initialize: #{initialize_overloads.join("\n                    | ")}"
+        end
+
+        def load?
+          @resource["load"]
+        end
+
+        def load_or_shape?
+          load? or !!shape
+        end
+
+        private
+
+        # `Aws::RDS::DBEngineVersion` has a duplicated method named `engine`.
+        # This is a rare case and should be patched minimally.
+        def avoid_duplicate_methods
+          overrided_method_names = @actions.map(&:method_name).to_set + @associations.map(&:method_name).to_set
+          @identifiers.each do |identifier|
+            if identifier.alias && overrided_method_names.include?(identifier.alias)
+              identifier.alias = nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/views/rbs/root_resource_class.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    module RBS
+      class RootResourceClass < View
+        attr_reader :actions
+        attr_reader :associations
+        attr_reader :service_name
+
+        def initialize(client_class:, api:, resources:, service_name:, paginators:)
+          @client_class = client_class
+          @service_name = service_name
+          resource = resources&.[]("service") || {}
+          @actions = AwsSdkCodeGenerator::RBS::ResourceAction.build_method_signature_list(resource: resource, api: api)
+          @associations = AwsSdkCodeGenerator::RBS::ResourceAssociation.build_method_signature_list(resource: resource, api: api, paginators: paginators)
+        end
+
+        # @return [String|nil]
+        def generated_src_warning
+          GENERATED_SRC_WARNING
+        end
+
+        def client_option
+          @client_class.client_option(indent: ' ' * 22)
+        end
+      end
+    end
+  end
+end