aws-sdk-code-generator 0.4.0.pre → 0.6.0.pre

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    # similar to SyntaxExampleHash
+    class KeywordArgumentBuilder
+      include Helper
+
+      attr_reader :newline
+
+      def initialize(api:, shape:, newline:)
+        @api = api
+        @shape = shape
+        @newline = newline
+      end
+
+      def format(indent: '')
+        members_str = struct_members(@shape, indent, [], keyword: true)
+        result = []
+        result << '' if newline
+        result << members_str if !members_str.empty?
+        result << indent if newline
+        result.join(joint)
+      end
+
+      def struct(struct_shape, i, visited)
+        members_str = struct_members(struct_shape, i, visited, keyword: false)
+        result = ["{"]
+        result << members_str if struct_shape['members']&.empty?&.!
+        result << "#{i}}"
+        result.join(joint)
+      end
+
+      def struct_members(struct_shape, i, visited, keyword:)
+        lines = []
+        unless struct_shape['members'].nil?
+          n = 0
+          struct_shape['members'].each do |member_name, member_ref|
+            next if member_ref['documented'] === false
+            more_indent = newline ? "  " : ""
+            if @api['shapes'][member_ref['shape']]['eventstream'] === true
+              # FIXME: "input_event_stream_hander: EventStreams::#{member_ref['shape']}.new"
+              lines << "#{i}#{more_indent}input_event_stream_hander: untyped,"
+            else
+              lines << "#{i}#{more_indent}#{struct_member(struct_shape, member_name, member_ref, i, visited, keyword: keyword)}"
+            end
+          end
+        end
+        if lines.empty?
+          ""
+        else
+          lines.join(joint).chomp(",")
+        end
+      end
+
+      def struct_member(struct, member_name, member_ref, i, visited, keyword:)
+        required = (struct['required'] || []).include?(member_name)
+        if keyword
+          "#{required ? '' : '?'}#{underscore(member_name)}: #{ref_value(member_ref, i + more_indent, visited)},"
+        else
+          "#{underscore(member_name)}: #{ref_value(member_ref, i + more_indent, visited)}#{required ? '' : '?'},"
+        end
+      end
+
+      def ref_value(ref, i, visited)
+        if visited.include?(ref['shape'])
+          return "untyped"
+        else
+          visited  = visited + [ref['shape']]
+        end
+
+        s = shape(ref)
+        case s['type']
+        when 'structure'
+          if ref['shape'] == 'AttributeValue'
+            'untyped'
+          else
+            struct(s, i, visited)
+          end
+        when 'blob'
+          if ref['streaming']
+            "::String | ::StringIO | ::File" # input only
+          else
+            "::String"
+          end
+        when 'list' then list(s, i, visited)
+        when 'map' then map(s, i, visited)
+        when 'boolean' then "bool"
+        when 'integer', 'long' then '::Integer'
+        when 'float', 'double' then '::Float'
+        when 'byte' then '::Integer'
+        when 'character' then '::String'
+        when 'string' then string(ref)
+        when 'timestamp' then '::Time'
+        else raise "unsupported shape #{s['type'].inspect}"
+        end
+      end
+
+      def list(list_shape, i, visited)
+        member_ref = list_shape['member']
+        if complex?(member_ref)
+          complex_list(member_ref, i, visited)
+        else
+          scalar_list(member_ref, i, visited)
+        end
+      end
+
+      def scalar_list(member_ref, i, visited)
+        "Array[#{ref_value(member_ref, i, visited)}]"
+      end
+
+      def complex_list(member_ref, i, visited)
+        newline_indent = newline ? "\n#{i}" : ""
+        "Array[#{newline_indent}#{more_indent}#{ref_value(member_ref, i + more_indent, visited)},#{newline_indent}]"
+      end
+
+      def complex?(ref)
+        s = shape(ref)
+        if s['type'] == 'structure'
+          !ddb_av?(ref)
+        else
+          s['type'] == 'list' || s['type'] == 'map'
+        end
+      end
+
+      def ddb_av?(ref)
+        s = shape(ref)
+        case s['type']
+        when 'list' then ddb_av?(s['member'])
+        when 'structure' then ref['shape'] == 'AttributeValue'
+        else false
+        end
+      end
+
+      def map(map_shape, i, visited)
+        key = string(map_shape['key'])
+        value = ref_value(map_shape['value'], i + more_indent, visited)
+        "Hash[#{key}, #{value}]"
+      end
+
+      def string(ref)
+        string_shape = shape(ref)
+        if string_shape['enum']
+          "(#{string_shape['enum'].map { |s| "\"#{s}\"" }.join(" | ")})"
+        else ref['shape']
+          "::String"
+        end
+      end
+
+      def more_indent
+        newline ? "  " : ""
+      end
+
+      def joint
+        newline ? "\n" : " "
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class MethodSignature < Struct.new(:method_name, :overloads, keyword_init: true)
+      def signature
+        "def #{method_name}: #{overloads.join("\n          #{" " * method_name.length}| ")}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceAction
+      class << self
+        def build_method_signature_list(resource:, api:)
+          (resource["actions"] || []).map do |action_name, action|
+            new(action_name: action_name, action: action, api: api).build_method_signature
+          end
+        end
+      end
+
+      def initialize(action_name:, action:, api:)
+        request = action["request"]
+        operation = api["operations"][request["operation"]]
+        returns = if action["resource"]
+          resource = action["resource"]
+          AwsSdkCodeGenerator::Api.plural?(resource) ? "#{resource["type"]}::Collection" : resource["type"]
+        elsif operation["output"]
+          "Types::#{operation["output"]["shape"]}"
+        else
+          "::Aws::EmptyStructure"
+        end
+
+        @client_request = ResourceClientRequest.new(
+          method_name: Underscore.underscore(action_name),
+          api: api,
+          request: request,
+          returns: returns,
+        )
+      end
+
+      def build_method_signature
+        @client_request.build_method_signature
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceAssociation
+      class << self
+        def build_method_signature_list(resource:, api:, paginators:)
+          associations = []
+          associations += has_associations(resource: resource)
+          associations += has_many_associations(resource: resource, api: api, paginators: paginators)
+          associations.sort_by(&:method_name)
+        end
+
+        private
+
+        def has_associations(resource:)
+          resource.fetch("has", {}).map do |name, assoc|
+            method_name = Underscore.underscore(name)
+            arguments = AwsSdkCodeGenerator::ResourceHasAssociation.send(:compute_params, assoc).map { |param|
+              "#{param[:type]} #{Underscore.underscore(param[:name])}"
+            }.join(', ')
+            returns = AwsSdkCodeGenerator::ResourceHasAssociation.send(:return_type, assoc).sub(/, nil$/, "?")
+            MethodSignature.new(
+              method_name: method_name,
+              overloads: ["(#{arguments}) -> #{returns}"]
+            )
+          end
+        end
+
+        def has_many_associations(resource:, api:, paginators:)
+          resource.fetch("hasMany", {}).map do |name, assoc|
+            ResourceClientRequest.new(
+              method_name: Underscore.underscore(name),
+              api: api,
+              request: assoc["request"],
+              returns: "#{assoc["resource"]["type"]}::Collection",
+              skip: AwsSdkCodeGenerator::ResourceHasManyAssociation.send(
+                :paging_options,
+                {
+                  assoc: assoc,
+                  paginators: paginators
+                }
+              ),
+            ).build_method_signature
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    class ResourceBatchAction
+      class << self
+        def build_method_signature_list(resource:, api:)
+          resource.fetch("batchActions", {}).map do |name, action|
+            new(api: api, name: name, action: action).build_method_signature
+          end
+        end
+      end
+
+      def initialize(api:, name:, action:)
+        @api = api
+        @name = name
+        @action = action
+        @batch_action_documentation = AwsSdkCodeGenerator::ResourceBatchActionDocumentation.new(
+          var_name: nil,
+          method_name: method_name,
+          action: action,
+          api: api,
+        )
+        @skip_params = @batch_action_documentation.send(:skip_params)
+        @input_ref = @batch_action_documentation.send(:input_ref)
+        @input_shape = AwsSdkCodeGenerator::Api.shape(@input_ref, api)
+      end
+
+      def build_method_signature
+        arguments = nil
+        include_required = false
+
+        if @input_shape
+          shape = Helper.deep_copy(@input_shape)
+          shape.fetch("members").reject! { |member_name, _| @skip_params.include?(member_name) }
+          arguments = KeywordArgumentBuilder.new(
+            api: @api,
+            shape: shape,
+            newline: true
+          ).format(indent: ' ' * (14 + method_name.length))
+        end
+
+        MethodSignature.new(
+          method_name: method_name,
+          overloads: [
+            "(#{arguments}) -> void",
+            "(#{include_required ? "" : "?"}Hash[Symbol, untyped]) -> void",
+          ]
+        )
+      end
+
+      private
+
+      def method_name
+        AwsSdkCodeGenerator::ResourceBatchAction.send(:build_method_name, @name, @action)
+      end
+    end
+  end
+end

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.metric('RESOURCE_MODEL') 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.metric('RESOURCE_MODEL') 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.metric('RESOURCE_MODEL') 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

@@ -2,12 +2,26 @@
 
 module AwsSdkCodeGenerator
   class Service
+    # Ordered priority list of supported protocols
+    # api-gateway is a special case and is always first.
+    SUPPORTED_PROTOCOLS = %w[
+      api-gateway
+      smithy-rpc-v2-cbor
+      json_1.0
+      json_1.1
+      rest-json
+      rest-xml
+      query
+      ec2
+    ]
 
     # @param [Hash] options
-    # @option options [required, String] :gem_version Gem version, e.g. "1.0.0".
     # @option options [required, String] :name The service name, e.g. "S3"
     # @option options [String] :module_name The service module name, defaults
     #   to "Aws::#{name}", e.g. "Aws::S3".
+    # @option options [String] :gem_name The gem name, defaults to
+    #  "aws-sdk-#{name}", e.g. "aws-sdk-s3".
+    # @option options [required, String] :gem_version Gem version, e.g. "1.0.0".
     # @option options [required, Hash, String] :api
     # @option options [Hash, String] :docs
     # @option options [Hash, String] :paginators
@@ -20,43 +34,50 @@ module AwsSdkCodeGenerator
     # @option options [Hash<gem,version>] :gem_dependencies ({})
     # @option options [Hash] :add_plugins ({})
     # @option options [Hash] :remove_plugins ([])
+    # @option options [Boolean] :deprecated (false)
+    # @option options [String] :default_endpoint (nil)
+    # @option options [String] :endpoints_key (nil)
     def initialize(options)
       @name = options.fetch(:name)
       @identifier = name.downcase
       @module_name = options[:module_name] || "Aws::#{name}"
       @gem_name = options[:gem_name] || "aws-sdk-#{identifier}"
       @gem_version = options.fetch(:gem_version)
+
       @api = load_json(options.fetch(:api))
-      unless @api['metadata']['protocol'] == 'api-gateway'
-        # Dont reply on API Gateway doc.json
+
+      # computed attributes
+      metadata = @api.fetch('metadata')
+      @protocol = select_protocol(metadata)
+      @protocol_settings = metadata['protocolSettings'] || {}
+      @api_version = metadata['apiVersion']
+      @signature_version = metadata['signatureVersion']
+      @auth = api.fetch('metadata')['auth']
+      @full_name = metadata['serviceFullName']
+      @short_name = metadata['serviceAbbreviation'] || @full_name
+
+      # Dont reply on API Gateway doc.json
+      unless @protocol == 'api-gateway'
         ApplyDocs.new(@api).apply(load_json(options[:docs]))
       end
       @paginators = load_json(options[:paginators])
       @waiters = load_json(options[:waiters])
       @resources = load_json(options[:resources])
       @examples = load_json(options[:examples])
-      @smoke_tests = load_json(options[:smoke_tests])
       unless options[:legacy_endpoints]
         @endpoint_rules = load_json(options[:endpoint_rules])
         @endpoint_tests = load_json(options[:endpoint_tests])
       end
+      @smoke_tests = load_json(options[:smoke_tests])
+
       @gem_dependencies = options[:gem_dependencies] || {}
       @add_plugins = options[:add_plugins] || {}
       @remove_plugins = options[:remove_plugins] || []
+      @deprecated = options[:deprecated] || false
+      @default_endpoint = options[:default_endpoint] # APIG custom service only
       @endpoints_key = options.fetch(:endpoints_key, nil)
-      # APIG custom service only
-      @default_endpoint = options[:default_endpoint]
 
-      # computed attributes
-      @protocol = api.fetch('metadata').fetch('protocol')
-      @protocol_settings = api.fetch('metadata')['protocolSettings'] || {}
-      @api_version = api.fetch('metadata')['apiVersion']
-      @signature_version = api.fetch('metadata')['signatureVersion']
-      @full_name = api.fetch('metadata')['serviceFullName']
-      @short_name = api.fetch('metadata')['serviceAbbreviation'] || @full_name
-      @require_endpoint_discovery = api.fetch('operations', []).any? do |_, o|
-        o['endpointdiscovery'] && o['endpointdiscovery']['required']
-      end
+      @require_endpoint_discovery = endpoint_discovery_required?
     end
 
     # @return [String] The service name, e.g. "S3"
@@ -127,6 +148,9 @@ module AwsSdkCodeGenerator
     # @return [String] The service protocol, e.g. "json", "query", etc.
     attr_reader :protocol
 
+    # @return [Array<String>] The list of supported protocols
+    attr_reader :protocols
+
     # @return [Hash] The service protocol settings
     attr_reader :protocol_settings
 
@@ -136,6 +160,9 @@ module AwsSdkCodeGenerator
     # @return [String] The signature version, e.g. "v4"
     attr_reader :signature_version
 
+    # @return [Array<String>] A list of supported auth types
+    attr_reader :auth
+
     # @return [String] The full product name for the service,
     #   e.g. "Amazon Simple Storage Service".
     attr_reader :full_name
@@ -146,6 +173,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}>"
@@ -153,6 +199,29 @@ module AwsSdkCodeGenerator
 
     private
 
+    def select_protocol(metadata)
+      protocols = metadata.fetch('protocols', [metadata['protocol']])
+      protocol = SUPPORTED_PROTOCOLS.find do |supported_protocol|
+        if %w[json_1.0 json_1.1].include?(supported_protocol)
+          supported_protocol, version = supported_protocol.split('_')
+        end
+
+        if protocols.include?(supported_protocol) &&
+           (version.nil? || version == metadata['jsonVersion'])
+          return supported_protocol
+        end
+      end
+      return protocol if protocol
+
+      raise "unsupported protocols `#{protocols.join(', ')}'"
+    end
+
+    def endpoint_discovery_required?
+      @api.fetch('operations', []).any? do |_, o|
+        o['endpointdiscovery'] && o['endpointdiscovery']['required']
+      end
+    end
+
     def load_json(value)
       case value
       when nil then nil

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