smithy 2.0.0.pre0 → 2.0.0.pre1

data/lib/smithy/templates/client/schema.erb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# This is generated code!
+
+module <%= module_name %>
+  # This module contains a schema composed of shapes used by the client.
+  module Schema
+
+<% shapes.each do |shape| -%>
+    <%= shape.name %> = <%= shape.initializer %>
+<% end -%>
+
+<% shapes.each do |shape| -%>
+<% case shape.type -%>
+<% when 'enum', 'intEnum' -%>
+<% shape.members.each do |member| -%>
+    <%= shape.name %>.add_member(:<%= member.name %>, <%= member.initializer %>)
+<% end -%>
+<% when 'list' -%>
+    <%= shape.name %>.member = <%= shape.member.initializer %>
+<% when 'map' -%>
+    <%= shape.name %>.key = <%= shape.key.initializer %>
+    <%= shape.name %>.value = <%= shape.value.initializer %>
+<% when 'structure' -%>
+<% shape.members.each do |member| -%>
+    <%= shape.name %>.add_member(:<%= member.name %>, <%= member.initializer %>)
+<% end -%>
+<% if shape.http_payload? -%>
+    <%= shape.name %>[:http_payload] = :<%= shape.http_payload %>
+    <%= shape.name %>[:http_payload_member] = <%= shape.name %>.member(:<%= shape.http_payload %>)
+<% end -%>
+    <%= shape.name %>.type = <%= shape.type_class %>
+<% when 'union' -%>
+<% shape.members.each do |member| -%>
+    <%= shape.name %>.add_member(:<%= member.name %>, <%= shape.union_type(member) %>, <%= member.initializer %>)
+<% end -%>
+    <%= shape.name %>.add_member(:unknown, Types::<%= shape.name %>::Unknown, Smithy::Schema::Shapes::ShapeRef.new(shape: Smithy::Schema::Shapes::Prelude::Unit))
+    <%= shape.name %>.type = <%= shape.type_class %>
+<% end -%>
+<% end -%>
+
+    <%= service_shape.name %> = Smithy::Schema::Shapes::ServiceShape.new do |service|
+      service.id = "<%= service_shape.id %>"
+      service.name = "<%= service_shape.name %>"
+<% if service_shape.version -%>
+      service.version = "<%= service_shape.version %>"
+<% end -%>
+      service.traits = <%= service_shape.traits %>
+<% operation_shapes.each do |shape| -%>
+      service.add_operation(:<%= shape.name.underscore %>, Smithy::Schema::Shapes::OperationShape.new do |operation|
+        operation.id = "<%= shape.id %>"
+        operation.name = "<%= shape.name %>"
+        operation.input = <%= shape.input.initializer %>
+        operation.output = <%= shape.output.initializer %>
+<% shape.errors.each do |error| -%>
+        operation.errors << <%= error.initializer %>
+<% end -%>
+        operation.traits = <%= shape.traits %>
+<% if !schema_gem? && shape.paginated? -%>
+        operation[:paginator] = <%= shape.paginator %>
+<% end -%>
+      end)
+<% end -%>
+
+    end
+
+    class << self
+      def type_registry
+        return @type_registry if @type_registry
+
+        shapes = constants.map { |sym| const_get(sym) }.select { |const| const.is_a?(Smithy::Schema::Shapes::StructureShape) }
+        @type_registry = Smithy::Schema::TypeRegistry.new(shapes)
+      end
+    end
+  end
+end

data/lib/smithy/templates/client/schema_rbs.erb

@@ -0,0 +1,13 @@
+module <%= module_name %>
+  module Schema
+    include Smithy::Schema::Shapes
+
+<% shapes.each do |shape| -%>
+    <%= shape.name %>: <%= shape.shape_class %>
+<% end -%>
+
+<% if service_shape -%>
+    <%= service_shape.name %>: <%= service_shape.shape_class %>
+<% end -%>
+  end
+end

data/lib/smithy/templates/client/spec_helper.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# This is generated code!
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require '<%= gem_name %>'
+
+require 'rspec'
+require 'smithy-client/protocol_spec_matcher'

data/lib/smithy/templates/client/types.erb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# This is generated code!
+
+module <%= module_name %>
+  # This module contains the types returned by client operations.
+  module Types
+<% types.each do |type| -%>
+
+<% type.docstrings.each do |docstring| -%>
+    # <%= docstring %>
+<% end -%>
+<% case type.type -%>
+<% when 'enum', 'intEnum' -%>
+    module <%= type.name %>
+<% type.members.each do |member| -%>
+<% member.docstrings.each do |docstring| -%>
+      # <%= docstring %>
+<% end -%>
+      <%= member.name %> = <%= member.value %>
+<% end -%>
+    end
+<% when 'structure' -%>
+<% type.attribute_docstrings.each do |docstring| -%>
+    # <%= docstring %>
+<% end -%>
+    class <%= type.name %> < Struct.new(
+<% type.members.each do |member| -%>
+      :<%= member.name.underscore %>,
+<% end -%>
+      keyword_init: true)
+      include Smithy::Schema::Structure
+<% if !type.input? && type.defaults.any? -%>
+
+      def initialize(options = {})
+<% type.defaults.each do |member| -%>
+        options[:<%= member.name.underscore %>] = <%= member.default %> unless options.key?(:<%= member.name.underscore %>)
+<% end -%>
+        super
+      end
+<% end -%>
+    end
+<% when 'union' -%>
+<% type.attribute_docstrings.each do |docstring| -%>
+    # <%= docstring %>
+<% end -%>
+    class <%= type.name %> < Struct.new(
+<% type.members.each do |member| -%>
+      :<%= member.name.underscore %>,
+<% end -%>
+      :unknown,
+      keyword_init: true)
+      include Smithy::Schema::Union
+
+<% type.members.each do |member| -%>
+      class <%= member.name.camelize  %> < <%= type.name %>; end
+<% end -%>
+      class Unknown < <%= type.name %>; end
+    end
+<% end -%>
+<% end -%>
+
+  end
+end

data/lib/smithy/templates/client/types_rbs.erb

@@ -0,0 +1,47 @@
+module <%= module_name %>
+  module Types
+<% types.each do |type| -%>
+
+<% case type.type -%>
+<% when 'enum', 'intEnum' -%>
+    module <%= type.name %>
+<% type.members.each do |member| -%>
+<% if type.type == 'enum' -%>
+      <%= member.name %>: String
+<% elsif type.type == 'intEnum' -%>
+      <%= member.name %>: Integer
+<% end -%>
+<% end -%>
+    end
+<% when 'structure', 'union' -%>
+    class <%= type.name %>
+<% if type.type == 'structure' -%>
+      include Smithy::Schema::Structure
+<% elsif type.type == 'union' -%>
+      include Smithy::Schema::Union
+<% end -%>
+
+      def initialize: (
+<% type.members.each do |member| -%>
+        ?<%= member.name.underscore %>: <%= member.rbs_type %>,
+<% end -%>
+      ) -> void
+      | (?Hash[Symbol, untyped]) -> void
+
+<% type.members.each do |member| -%>
+      attr_accessor <%= member.name.underscore %>: <%= member.rbs_type %>?
+<% end -%>
+<% if type.type == 'union' -%>
+
+<% type.members.each do |member| -%>
+      class <%= member.name.camelize %> < <%= type.name %>
+      end
+<% end -%>
+      class Unknown < <%= type.name %>
+      end
+<% end -%>
+    end
+<% end -%>
+<% end -%>
+  end
+end

data/lib/smithy/templates/client/waiters.erb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# This is generated code!
+
+module <%= module_name %>
+
+  # @api private
+  module Waiters
+<% waiters.each do |waiter| -%>
+<% if waiter.deprecated? -%>
+    # @deprecated
+<% end -%>
+    # @api private
+    #
+<% waiter.docstrings.each do |docstring| -%>
+    # <%= docstring %>
+<% end -%>
+    #
+    class <%= waiter.name %>
+      def initialize(options = {})
+        @client = options[:client]
+        @waiter = Smithy::Client::Waiters::Waiter.new(
+          max_wait_time: options[:max_wait_time],
+          min_delay: options[:min_delay] || <%= waiter.min_delay %>,
+          max_delay: options[:max_delay] || <%= waiter.max_delay %>,
+          poller: Smithy::Client::Waiters::Poller.new(
+            operation_name: :<%= waiter.operation_name %>,
+<% waiter.acceptors.each do |acceptor| -%>
+            <%= acceptor %>
+<% end -%>
+          )
+        )
+      end
+
+      def wait(params = {})
+        @waiter.wait(@client, params)
+      end
+    end
+
+<% end -%>
+  end
+end

data/lib/smithy/util/hash_formatter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Util
+    # A class to format a hash into a string.
+    class HashFormatter
+      # @option options [Boolean] :wrap (true) When `true`, the formatted hash will
+      #   be wrapped with curly braces.
+      # @option options [Boolean] :inline (false) When `true` the formatted hash will
+      #   contain no newlines.
+      # @option options [Boolean] :quote_strings (false) By default, all hash string values
+      #   must contain their own quotes. If you pass `true`, then all hash string
+      #   values will be inspected via `#inspect` which will auto-quote them.
+      # @option options [String] :indent ('') The indentation to use for the hash.
+      def initialize(options = {})
+        @wrap = options.fetch(:wrap, true)
+        @inline = options.fetch(:inline, false)
+        @quote_strings = options.fetch(:quote_strings, false)
+        @indent = options.fetch(:indent, '')
+      end
+
+      # @return [String]
+      def format(obj)
+        result = hash(obj, indent: @indent, inline: @inline)
+        result = unwrap(result, obj.size) unless @wrap
+        result = result.strip if @inline && result.lines.to_a.length == 1
+        result
+      end
+
+      private
+
+      def value(obj, options)
+        indent = options.fetch(:indent)
+        inline = options.fetch(:inline)
+        case obj
+        when Hash then hash(obj, indent: indent, inline: inline)
+        when Array then array(obj, indent: indent)
+        when String then @quote_strings ? obj.inspect : obj
+        when Symbol, Numeric, true, false then obj.inspect
+        else raise ArgumentError, "unsupported value: #{obj.class}"
+        end
+      end
+
+      def hash(hash, options)
+        indent = options.fetch(:indent)
+        inline = options.fetch(:inline)
+        if hash.empty?
+          '{}'
+        elsif inline_hash?(hash, inline)
+          inline_hash(hash)
+        else
+          multiline_hash(hash, indent: indent)
+        end
+      end
+
+      def inline_hash(hash)
+        "{ #{hash_entry(hash.keys[0], hash.values[0], indent: '')} }"
+      end
+
+      def multiline_hash(hash, options)
+        indent = options.fetch(:indent)
+        str = "{\n"
+        hash.each.with_index do |(key, value), n|
+          str += "#{indent}  #{hash_entry(key, value, indent: indent)}"
+          str += ',' unless n == hash.keys.length - 1
+          str += "\n"
+        end
+        str + "#{indent}}"
+      end
+
+      def hash_entry(key, value, options)
+        indent = options.fetch(:indent)
+        value = value(value, indent: "#{indent}  ", inline: false)
+        if key.is_a?(Symbol)
+          "#{key}: #{value}"
+        else
+          "#{key.inspect} => #{value}"
+        end
+      end
+
+      def array(array, options)
+        indent = options.fetch(:indent)
+        if array.empty?
+          '[]'
+        elsif inline_array?(array)
+          "[#{value(array[0], indent: indent, inline: true)}]"
+        else
+          format_multiline_array(array, indent: indent)
+        end
+      end
+
+      def format_multiline_array(array, options)
+        indent = options.fetch(:indent)
+        str = "[\n"
+        array.each.with_index do |value, n|
+          str += "#{indent}  #{value(value, indent: "#{indent}  ", inline: true)}"
+          str += ',' unless n == array.length - 1
+          str += "\n"
+        end
+        str + "#{indent}]"
+      end
+
+      def inline_hash?(hash, inline)
+        hash.length == 1 && hash.values[0].is_a?(String) && inline
+      end
+
+      def inline_array?(array)
+        array.length == 1
+      end
+
+      def unwrap(str, size)
+        if @inline || size > 1
+          str[1..-2]
+        else
+          lines = str.lines.to_a
+          lines.shift
+          lines.pop
+          lines = lines.map { |line| line[2..] }
+          lines.join.rstrip
+        end
+      end
+    end
+  end
+end

data/lib/smithy/util/underscore.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Util
+    # @api private
+    module Underscore
+      class << self
+        # @param [String<JMESPath>]
+        # @return [String]
+        def underscore_jmespath(expression)
+          expression
+            .gsub(' or ', '||')
+            .gsub(/(?<![`'])\b\w+\b(?![`'])/, &:underscore)
+        end
+      end
+    end
+  end
+end

data/lib/smithy/util.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'util/hash_formatter'
+require_relative 'util/underscore'
+
+module Smithy
+  # @api private
+  module Util; end
+end

data/lib/smithy/views/client/auth_parameter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class AuthParameter
+        def initialize(options = {})
+          @name = options[:name]
+          @documentation = options[:documentation]
+        end
+
+        attr_reader :name
+
+        def docstrings
+          @documentation.split("\n")
+        end
+
+        def documentation_type
+          'Symbol'
+        end
+
+        def rbs_type
+          'Symbol'
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/auth_parameters.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class AuthParameters < View
+        def initialize(plan)
+          @plan = plan
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def parameters
+          [AuthParameter.new(name: :operation_name, documentation: 'The name of the operation.')]
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/auth_parameters_rbs.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class AuthParametersRbs < View
+        def initialize(plan)
+          @plan = plan
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def parameters
+          [AuthParameter.new(name: :operation_name, documentation: 'The name of the operation.')]
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/auth_plugin.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class AuthPlugin < View
+        def initialize(plan)
+          @plan = plan
+          @auth_schemes = weld_auth_schemes(plan.welds)
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        def auth_schemes
+          @auth_schemes.transform_values { |v| v[:auth_scheme_config_option] }
+        end
+
+        def identity_providers
+          @auth_schemes.to_h { |_, v| [v[:identity_type], v[:identity_provider_config_option]] }
+        end
+
+        private
+
+        def weld_auth_schemes(welds)
+          weld_auth_schemes = welds.map(&:add_auth_schemes).reduce({}, :merge)
+          weld_auth_schemes.except(*welds.map(&:remove_auth_schemes).reduce([], :+))
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/auth_resolver.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class AuthResolver < View
+        def initialize(plan)
+          @plan = plan
+          _, service = plan.service.first
+          @service_traits = service.fetch('traits', {})
+          @operations = Model::ServiceIndex.new(plan.model).operations_for(plan.service)
+          @auth_schemes = auth_schemes(plan.welds)
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def auth_rules_code
+          lines = []
+          lines << 'options = []'
+          auth_operations = operations_with_auth_traits
+          if auth_operations.empty?
+            service_auth_schemes.each do |auth_scheme|
+              lines << "options << #{render_auth_option(auth_scheme)}"
+            end
+          else
+            lines << 'case parameters.operation_name'
+            auth_operations.each do |id, operation|
+              operation_name = Model::Shape.name(id).underscore
+              lines << "when :#{operation_name}"
+              operation_auth_schemes(operation).each do |auth_scheme|
+                lines << "  options << #{render_auth_option(auth_scheme)}"
+              end
+            end
+            lines << 'else'
+            service_auth_schemes.each do |auth_scheme|
+              lines << "  options << #{render_auth_option(auth_scheme)}"
+            end
+            lines << 'end'
+          end
+          lines << 'options'
+          lines
+        end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def auth_schemes(welds)
+          weld_auth_schemes = welds.map(&:add_auth_schemes).reduce({}, :merge)
+          weld_auth_schemes = weld_auth_schemes.except(*welds.map(&:remove_auth_schemes).reduce([], :+))
+          weld_auth_schemes
+            .sort_by { |k, _| k }
+            .to_h
+        end
+
+        def service_has_auth_trait?
+          @service_traits.key?('smithy.api#auth')
+        end
+
+        def service_auth_schemes
+          auth_schemes = []
+          if service_has_auth_trait?
+            service_auth = @service_traits.fetch('smithy.api#auth', [])
+            add_auth_schemes_from_auth_trait(auth_schemes, service_auth)
+          else
+            add_registered_auth_schemes(auth_schemes, @service_traits)
+          end
+          auth_schemes << 'smithy.api#noAuth' if auth_schemes.empty?
+          auth_schemes
+        end
+
+        def operations_with_auth_traits
+          @operations.select do |_, operation|
+            operation_auth?(operation) || optional_operation_auth?(operation)
+          end
+        end
+
+        def operation_auth?(operation)
+          operation.fetch('traits', {}).key?('smithy.api#auth')
+        end
+
+        def optional_operation_auth?(operation)
+          operation.fetch('traits', {}).key?('smithy.api#optionalAuth')
+        end
+
+        def operation_auth_schemes(operation)
+          operation_traits = operation.fetch('traits', {})
+          auth_schemes = []
+          if operation_auth?(operation)
+            operation_auth = operation_traits.fetch('smithy.api#auth', [])
+            add_auth_schemes_from_auth_trait(auth_schemes, operation_auth)
+          else
+            add_registered_auth_schemes(auth_schemes, operation_traits)
+          end
+          auth_schemes << 'smithy.api#optionalAuth' if operation_traits.key?('smithy.api#optionalAuth')
+          auth_schemes << 'smithy.api#noAuth' if auth_schemes.empty?
+          auth_schemes
+        end
+
+        def add_auth_schemes_from_auth_trait(auth_schemes, auth_trait)
+          auth_trait.each do |auth_scheme|
+            auth_schemes << auth_scheme if @auth_schemes.key?(auth_scheme)
+          end
+        end
+
+        def add_registered_auth_schemes(auth_schemes, traits)
+          @auth_schemes.each_key do |auth_scheme|
+            auth_schemes << auth_scheme if traits.key?(auth_scheme)
+          end
+        end
+
+        def render_auth_option(auth_scheme)
+          properties = @service_traits.fetch(auth_scheme, {})
+          "Smithy::Client::AuthOption.new(scheme_id: '#{auth_scheme}', signer_properties: #{properties})"
+        end
+      end
+    end
+  end
+end

data/lib/smithy/views/client/auth_resolver_rbs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Views
+    module Client
+      # @api private
+      class AuthResolverRbs < View
+        def initialize(plan)
+          @plan = plan
+          super()
+        end
+
+        def module_name
+          @plan.module_name
+        end
+      end
+    end
+  end
+end