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

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceClientRequest
+      include Helper
+
+      attr_reader :method_name
+      attr_reader :arguments
+      attr_reader :returns
+      attr_reader :include_required
+
+      def initialize(method_name:, api:, request:, returns:, skip: [])
+        @method_name = method_name
+        @returns = returns
+        @include_required = false
+
+        operation = api["operations"][request["operation"]]
+        shape_ref = operation["input"]
+        input_shape = AwsSdkCodeGenerator::Api.shape(shape_ref, api)
+        skip = Set.new(skip + AwsSdkCodeGenerator::ResourceSkipParams.compute(input_shape, request))
+        @arguments = if input_shape
+          shape = deep_copy(input_shape)
+          shape["members"].select! { |member_name, _| !skip.include?(member_name) }
+          KeywordArgumentBuilder.new(api: api, shape: shape, newline: true).format(indent: ' ' * (12 + method_name.length))
+        end
+      end
+
+      def build_method_signature
+        MethodSignature.new(
+          method_name: method_name,
+          overloads: [
+            "(#{arguments}) -> #{returns}",
+            "(#{@include_required ? "" : "?"}Hash[Symbol, untyped]) -> #{returns}"
+          ]
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class Waiter < Struct.new(
+      :name,
+      :class_name,
+      :client_overload_keyword_argument,
+      :client_overload_positional_argument,
+      :waiter_overload_keyword_argument,
+      :waiter_overload_positional_argument,
+      keyword_init: true
+    )
+      class << self
+        def build_list(api:, waiters:)
+          operations = api.fetch("operations")
+          waiters =
+            if waiters&.first
+              waiters["waiters"]
+            else
+              {}
+            end
+          waiters.map do |waiter_name, waiter|
+            operation = waiter.fetch("operation")
+            operation_ref = operations[operation]
+            input_shape = operation_ref.dig("input", "shape")
+            include_required = api["shapes"][input_shape]&.[]("required")&.empty?&.!
+
+            name = ":#{Underscore.underscore(waiter_name)}"
+            shapes = api.fetch("shapes")
+            input_shape_ref = shapes[input_shape]
+            params = AwsSdkCodeGenerator::RBS::KeywordArgumentBuilder.new(
+              api: api,
+              shape: input_shape_ref,
+              newline: true,
+            ).format(indent: ' ' * 18)
+            returns = operation_ref.dig("output", "shape") ? "Client::_#{operation}ResponseSuccess" : "::Seahorse::Client::_ResponseSuccess[::Aws::EmptyStructure]"
+            prefix = include_required ? "" : "?"
+
+            new.tap do |w|
+              w.name = name
+              w.class_name = waiter_name
+              w.client_overload_keyword_argument = "(#{name} waiter_name, #{params}) -> #{returns}"
+              w.client_overload_positional_argument = "(#{name} waiter_name, #{prefix}Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> #{returns}"
+              w.waiter_overload_keyword_argument = "(#{params}) -> #{returns}"
+              w.waiter_overload_positional_argument = "(#{prefix}Hash[Symbol, untyped]) -> #{returns}"
+            end
+          end.sort_by(&:name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class << self
+      def to_type(shape_ref, api)
+        _, shape = Api.resolve(shape_ref, api)
+        case shape['type']
+        when 'blob' then Api.streaming?(shape_ref, api) ? '::IO' : '::String'
+        when 'boolean' then 'bool'
+        when 'byte' then '::Integer'
+        when 'character' then '::String'
+        when 'double' then '::Float'
+        when 'float' then '::Float'
+        when 'integer' then '::Integer'
+        when 'list' then "::Array[#{to_type(shape['member'], api)}]"
+        when 'long' then '::Integer'
+        when 'map' then "::Hash[#{to_type(shape['key'], api)}, #{to_type(shape['value'], api)}]"
+        when 'string'
+          if shape['enum']
+            "(#{shape['enum'].map { |e| "\"#{e}\"" }.join(" | ")})"
+          elsif Api.streaming?(shape_ref, api)
+            '::IO'
+          else
+            '::String'
+          end
+        when 'structure'
+          if shape['document']
+            'untyped'
+          else
+            "Types::#{shape_ref['shape']}"
+          end
+        when 'timestamp' then '::Time'
+        else
+          raise "unhandled type #{shape['type'].inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -15,7 +15,9 @@ module AwsSdkCodeGenerator
       parts << 'batch_enum.each do |batch|'
       parts << initialize_params
       parts << apply_params_per_batch
-      parts << "  batch[0].client.#{client_method}(params)"
+      parts << "  Aws::Plugins::UserAgent.feature('resource') do"
+      parts << "    batch[0].client.#{client_method}(params)"
+      parts << '  end'
       parts << 'end'
       parts << 'nil'
       parts.join("\n").rstrip

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

@@ -15,9 +15,11 @@ module AwsSdkCodeGenerator
         parts = []
         parts << request_options(params) if merge
         parts << assignment(options)
-        parts << "@client."
+        parts << "Aws::Plugins::UserAgent.feature('resource') do\n"
+        parts << "  @client."
         parts << operation_name(request)
         parts << arguments(merge, params, streaming)
+        parts << "\nend"
         parts.join
       end
 

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

@@ -52,11 +52,12 @@ module AwsSdkCodeGenerator
         args = ResourceClientRequestParams.new(
           params: waiter['params']
         ).to_s.strip
-        if waiter['path']
-          "resp = waiter.wait(params.merge(#{args}))"
-        else
-          "waiter.wait(params.merge(#{args}))"
-        end
+        parts = []
+        parts << 'resp = ' if waiter['path']
+        parts << "Aws::Plugins::UserAgent.feature('resource') do\n"
+        parts << "  waiter.wait(params.merge(#{args}))"
+        parts << "\nend"
+        parts.join
       end
 
       def constructor_args(resource, waiter)

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

@@ -20,6 +20,7 @@ module AwsSdkCodeGenerator
     # @option options [Hash<gem,version>] :gem_dependencies ({})
     # @option options [Hash] :add_plugins ({})
     # @option options [Hash] :remove_plugins ([])
+    # @option options [Boolean] :deprecated (false)
     def initialize(options)
       @name = options.fetch(:name)
       @identifier = name.downcase
@@ -57,6 +58,7 @@ module AwsSdkCodeGenerator
       @require_endpoint_discovery = api.fetch('operations', []).any? do |_, o|
         o['endpointdiscovery'] && o['endpointdiscovery']['required']
       end
+      @deprecated = options[:deprecated] || false
     end
 
     # @return [String] The service name, e.g. "S3"
@@ -146,6 +148,25 @@ module AwsSdkCodeGenerator
     # @return [Boolean] true if any operation requires endpoint_discovery
     attr_reader :require_endpoint_discovery
 
+    # @return [String] the service_id
+    def service_id
+      metadata = @api['metadata']
+      return metadata['serviceId'] if metadata['serviceId']
+
+      name = metadata['serviceAbbreviation'] || metadata['serviceFullName']
+      name = name.gsub(/AWS/, '').gsub(/Amazon/, '')
+      name = name.gsub(/[^a-zA-Z0-9 ]+/, '')
+      name = name.gsub(/^[0-9]+/, '')
+      name = name.strip
+
+      name
+    end
+
+    # @return [Boolean] true if the service is deprecated
+    def deprecated?
+      @deprecated
+    end
+
     # @api private
     def inspect
       "#<#{self.class.name}>"

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

@@ -24,10 +24,14 @@ module AwsSdkCodeGenerator
         @gem_version = options.fetch(:gem_version)
         @plugins = PluginList.new(options)
         @codegenerated_plugins = options.fetch(:codegenerated_plugins, [])
+        @default_plugins = Seahorse::Client::AsyncBase.plugins.map do |plugin|
+          PluginList::Plugin.new(class_name: plugin.name, options: plugin.options, path: '')
+        end
         @client_constructor = ClientConstructor.new(
           options.merge(
             plugins: @plugins,
-            codegenerated_plugins: @codegenerated_plugins))
+            codegenerated_plugins: @codegenerated_plugins,
+            default_plugins: @default_plugins))
         @operations = ClientOperationList.new(options).to_a
       end
 

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

@@ -34,6 +34,8 @@ module AwsSdkCodeGenerator
         'union' => false, # should remain false
         'document' => true,
         'jsonvalue' => true,
+        'error' => true, # parsing customized error code in query protocol
+        'locationName' => true, # to recognize xmlName defined on shape
         # event stream modeling
         'event' => false,
         'eventstream' => false,
@@ -43,7 +45,7 @@ module AwsSdkCodeGenerator
         'synthetic' => false,
         'box' => false,
         'fault' => false,
-        'error' => false,
+        'exception_event' => false, # internal, exceptions cannot be events
         'deprecated' => false,
         'deprecatedMessage' => false,
         'type' => false,
@@ -51,7 +53,6 @@ module AwsSdkCodeGenerator
         'members' => false,
         'member' => false,
         'key' => false,
-        'locationName' => false,
         'value' => false,
         'required' => false,
         'enum' => false,
@@ -70,9 +71,11 @@ module AwsSdkCodeGenerator
         # keep all
         'endpointPrefix' => true,
         'signatureVersion' => true,
+        'auth' => true,
         'signingName' => true,
         'serviceFullName' => true,
         'protocol' => true,
+        'protocols' => true,
         'targetPrefix' => true,
         'jsonVersion' => true,
         'errorPrefix' => true,
@@ -98,6 +101,7 @@ module AwsSdkCodeGenerator
       # @return [String|nil]
       def generated_src_warning
         return if @service.protocol == 'api-gateway'
+
         GENERATED_SRC_WARNING
       end
 
@@ -204,12 +208,18 @@ module AwsSdkCodeGenerator
             if operation.key?('httpChecksum')
               operation['httpChecksum']['requestAlgorithmMember'] = underscore(operation['httpChecksum']['requestAlgorithmMember']) if operation['httpChecksum']['requestAlgorithmMember']
               operation['httpChecksum']['requestValidationModeMember'] = underscore(operation['httpChecksum']['requestValidationModeMember']) if operation['httpChecksum']['requestValidationModeMember']
-
               o.http_checksum = operation['httpChecksum'].inject([]) do |a, (k, v)|
                 a << { key: k.inspect, value: v.inspect }
                 a
               end
             end
+
+            if operation.key?('requestcompression')
+              o.request_compression = operation['requestcompression'].each_with_object([]) do |(k, v), arr|
+                arr << { key: k.inspect, value: v.inspect }
+              end
+            end
+
             %w(input output).each do |key|
               if operation[key]
                 o.shape_references << "o.#{key} = #{operation_ref(operation[key])}"
@@ -250,6 +260,7 @@ module AwsSdkCodeGenerator
 
       def apig_authorizer
         return nil unless @service.api.key? 'authorizers'
+
         @service.api['authorizers'].map do |name, authorizer|
           Authorizer.new.tap do |a|
             a.name = name
@@ -298,6 +309,9 @@ module AwsSdkCodeGenerator
         args << "name: '#{shape_name}'"
         shape.each_pair do |key, value|
           if SHAPE_KEYS[key]
+            # only query protocols have custom error code
+            next if @service.protocol != 'query' && key == 'error'
+
             args << "#{key}: #{value.inspect}"
           elsif SHAPE_KEYS[key].nil?
             raise "unhandled shape key #{key.inspect}"
@@ -491,8 +505,16 @@ module AwsSdkCodeGenerator
           options = {}
           metadata.each_pair do |key, value|
             next if key == 'resultWrapper'
+
             if key == 'locationName'
-              options[:location_name] = value.inspect
+              options[:location_name] =
+                # use the xmlName on shape if defined
+                if (@service.protocol == 'rest-xml') &&
+                   (shape_location_name = @service.api['shapes'][shape_name]['locationName'])
+                  shape_location_name.inspect
+                else
+                  value.inspect
+                end
             else
               options[:metadata] ||= {}
               options[:metadata][key] = value.inspect
@@ -551,6 +573,9 @@ module AwsSdkCodeGenerator
         # @return [Hash]
         attr_accessor :http_checksum
 
+        # @return [Hash]
+        attr_accessor :request_compression
+
         # @return [Array<String>]
         attr_accessor :shape_references
 

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

@@ -27,10 +27,14 @@ module AwsSdkCodeGenerator
         @gem_version = options.fetch(:gem_version)
         @plugins = PluginList.new(options)
         @codegenerated_plugins = options.fetch(:codegenerated_plugins, [])
+        @default_plugins = Seahorse::Client::Base.plugins.map do |plugin|
+          PluginList::Plugin.new(class_name: plugin.name, options: plugin.options, path: '')
+        end
         @client_constructor = ClientConstructor.new(
           options.merge(
             plugins: @plugins,
-            codegenerated_plugins: @codegenerated_plugins))
+            codegenerated_plugins: @codegenerated_plugins,
+            default_plugins: @default_plugins))
         @operations = ClientOperationList.new(options).to_a
         @waiters = Waiter.build_list(options[:waiters])
         @custom = options.fetch(:custom)

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

@@ -26,8 +26,227 @@ module AwsSdkCodeGenerator
         @service.module_name
       end
 
-      def endpoint_rules_encoded
-        Base64.encode64(JSON.dump(@endpoint_rules))
+      def endpoint_rules_code
+        res = StringIO.new
+        # map parameters first
+        @endpoint_rules["parameters"].each do |k,_v|
+          res << indent("#{underscore(k)} = parameters.#{underscore(k)}\n", 3)
+        end
+
+        # map rules
+        @endpoint_rules["rules"].each do |rule|
+          case rule["type"]
+          when "endpoint"
+            res << endpoint_rule(rule, 3)
+          when "error"
+            res << error_rule(rule, 3)
+          when "tree"
+            res << tree_rule(rule, 3)
+          else
+            raise "Unknown rule type: #{rule['type']}"
+          end
+        end
+
+        # if no rules match, raise an error
+        res << indent("raise ArgumentError, 'No endpoint could be resolved'\n", 3)
+
+        res.string
+      end
+
+      private
+
+      def endpoint_rule(rule, levels=3)
+        res = StringIO.new
+        if rule['conditions'] && !rule['conditions'].empty?
+          res << conditions(rule['conditions'], levels)
+          res << endpoint(rule['endpoint'], levels+1)
+          res << indent("end\n", levels)
+        else
+          res << endpoint(rule['endpoint'], levels)
+        end
+        res.string
+      end
+
+      def endpoint(endpoint, levels)
+        res = StringIO.new
+        res << "return Aws::Endpoints::Endpoint.new(url: #{str(endpoint['url'])}"
+        if endpoint['headers']
+          res << ", headers: #{templated_hash_to_s(endpoint['headers'])}"
+        end
+        if endpoint['properties']
+          res << ", properties: #{templated_hash_to_s(endpoint['properties'])}"
+        end
+        res << ")\n"
+        indent(res.string, levels)
+      end
+
+      def templated_hash_to_s(hash)
+        template_hash_values(hash).to_s.gsub('\#{', '#{') # unescape references
+      end
+
+      def template_hash_values(hash)
+        hash.inject({}) { |h, (k, v)| h[k] = template_hash_value(v); h }
+      end
+
+      def template_hash_value(value)
+        case value
+        when Hash
+          template_hash_values(value)
+        when Array
+          value.map { |v| template_hash_value(v) }
+        when String
+          template_str(value, false)
+        else
+          value
+        end
+      end
+
+      def error_rule(rule, levels=3)
+        res = StringIO.new
+        if rule['conditions'] && !rule['conditions'].empty?
+          res << conditions(rule['conditions'], levels)
+          res << error(rule['error'], levels+1)
+          res << indent("end\n", levels)
+        else
+          res << error(rule['error'], levels)
+        end
+        res.string
+      end
+
+      def error(error, levels)
+        indent("raise ArgumentError, #{str(error)}\n", levels)
+      end
+
+      def tree_rule(rule, levels=3)
+        res = StringIO.new
+        if rule['conditions'] && !rule['conditions'].empty?
+          res << conditions(rule['conditions'], levels)
+          res << tree_rules(rule['rules'], levels+1)
+          res << indent("end\n", levels)
+        else
+          res << tree_rules(rule['rules'], levels)
+        end
+        res.string
+      end
+
+      def tree_rules(rules, levels)
+        res = StringIO.new
+        rules.each do |rule|
+          case rule["type"]
+          when "endpoint"
+            res << endpoint_rule(rule, levels)
+          when "error"
+            res << error_rule(rule, levels)
+          when "tree"
+            res << tree_rule(rule, levels)
+          else
+            raise "Unknown rule type: #{rule['type']}"
+          end
+        end
+        res.string
+      end
+
+      def conditions(conditions, level)
+        res = StringIO.new
+        cnd_str = conditions.map { |c| condition(c) }.join(" && ")
+        res << indent("if #{cnd_str}\n", level)
+        res.string
+      end
+
+      def condition(condition)
+        if condition['assign']
+          "(#{underscore(condition['assign'])} = #{fn(condition)})"
+        else
+          fn(condition)
+        end
+      end
+
+      def str(s)
+        if s.is_a?(Hash)
+          if s['ref']
+            underscore(s['ref'])
+          elsif s['fn']
+            fn(s)
+          else
+            raise "Unknown string type: #{s}"
+          end
+        else
+          template_str(s)
+        end
+      end
+
+      def template_str(string, wrap=true)
+        string.scan(/\{.+?\}/).each do |capture|
+          value = capture[1..-2] # strips curly brackets
+          string = string.gsub(capture, '#{' + template_replace(value) + '}')
+        end
+        string = string.gsub('"', '\"')
+        wrap ? "\"#{string}\"" : string
+      end
+
+      def template_replace(value)
+        indexes = value.split("#")
+        res = underscore(indexes.shift)
+        res += indexes.map do |index|
+          "['#{index}']"
+        end.join("")
+        res
+      end
+
+      def fn(fn)
+        args = fn['argv'].map {|arg| fn_arg(arg)}.join(", ")
+        "#{fn_name(fn['fn'])}(#{args})"
+      end
+
+      def fn_arg(arg)
+        if arg.is_a?(Hash)
+          if arg['ref']
+            underscore(arg['ref'])
+          elsif arg['fn']
+            fn(arg)
+          else
+            raise "Unexpected argument type: #{arg}"
+          end
+        elsif arg.is_a?(String)
+          template_str(arg)
+        else
+          arg
+        end
+      end
+
+      def fn_name(fn)
+        case fn
+        when 'isSet'
+          "Aws::Endpoints::Matchers.set?"
+        when 'not'
+          "Aws::Endpoints::Matchers.not"
+        when 'getAttr'
+          "Aws::Endpoints::Matchers.attr"
+        when 'substring'
+          "Aws::Endpoints::Matchers.substring"
+        when 'stringEquals'
+          "Aws::Endpoints::Matchers.string_equals?"
+        when 'booleanEquals'
+          "Aws::Endpoints::Matchers.boolean_equals?"
+        when 'uriEncode'
+          "Aws::Endpoints::Matchers.uri_encode"
+        when 'parseURL'
+          "Aws::Endpoints::Matchers.parse_url"
+        when 'isValidHostLabel'
+          "Aws::Endpoints::Matchers.valid_host_label?"
+        when 'aws.partition'
+          "Aws::Endpoints::Matchers.aws_partition"
+        when 'aws.parseArn'
+          "Aws::Endpoints::Matchers.aws_parse_arn"
+        when 'aws.isVirtualHostableS3Bucket'
+          "Aws::Endpoints::Matchers.aws_virtual_hostable_s3_bucket?"
+        else
+          raise "Function not found: #{@fn}"
+        end
+      end
+
+      def indent(s, levels=3)
+        ("  " * levels) + s
       end
     end
   end

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

@@ -99,9 +99,15 @@ module AwsSdkCodeGenerator
             ).to_s
           end
           param_hash_str = Docstring.join_docstrings([option_tags], block_comment: false)
+          param_hash =
+            if param_hash_str.nil?
+              '# This event has no members'
+            else
+              Docstring.indent(param_hash_str, '      ')
+            end
           m << EventEntry.new(
             name: underscore(n),
-            param_hash: Docstring.indent(param_hash_str, '      ')
+            param_hash: param_hash
           )
           m
         end