smithy 2.0.0.pre0 → 2.0.0.pre1

data/lib/smithy/weld.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Smithy
+  # Base class that all welds must inherit from. Includes hooks for code generation.
+  class Weld
+    include Thor::Base
+    include Thor::Actions
+
+    # @param [Plan] plan The plan that is being executed.
+    def initialize(plan)
+      @plan = plan
+      # Necessary for Thor::Base and Thor::Actions
+      self.options = { force: true, quiet: plan.quiet }
+      self.destination_root = plan.destination_root
+      shell.base = self
+    end
+
+    # Called to determine if the weld should be applied for this model.
+    # @param [Hash] service Service shape
+    # @return [Boolean] (true) True if the weld should be applied, false otherwise.
+    def for?(service) # rubocop:disable Lint/UnusedMethodArgument
+      true
+    end
+
+    # Pre-process the model. Called before the model is loaded.
+    # @param [Hash] model
+    def pre_process(model)
+      model
+    end
+
+    # Post-process the artifacts after they are generated.
+    # @param [Array<String>] artifacts The files that were generated.
+    def post_process(artifacts)
+      artifacts
+    end
+
+    # Called when constructing the module and gemspec. Any dependencies defined
+    # here will be merged with other dependencies. The key is the name of the
+    # dependency and the value is the version constraint.
+    def add_dependencies
+      {}
+    end
+
+    # Called when constructing the module and gemspec. Any dependencies defined
+    # here will be removed from the module and gemspec. Each element in the
+    # array is the name of the dependency.
+    def remove_dependencies
+      []
+    end
+
+    # Called when constructing endpoint parameters. Any bindings defined here will
+    # be merged with other built-in bindings. The key is the name of the binding, and
+    # the value is the binding definition, which is a hash with keys :render_config,
+    # :render_build and :render_test_set.
+    # @return [Hash<String, Hash>] endpoint built in bindings for use in endpoint rules.
+    def endpoint_built_in_bindings
+      {}
+    end
+
+    # Called when constructing the endpoint provider. Any bindings defined here will
+    # be merged with other function bindings. The key is the name of the binding, and
+    # the value is the function to call.
+    # @return [Hash<String, String>] endpoint function bindings for use in endpoint rules.
+    def endpoint_function_bindings
+      {}
+    end
+
+    # Called when constructing the client. Any plugins defined here will be merged
+    # with other plugins. The key is the fully qualified class name of the plugin,
+    # and the value is a hash with any of the following keys:
+    # * :source - the source code of the plugin
+    # * :require_path - the path to require the plugin from the client
+    # * :require_relative - true if the path should be required relative to the client
+    # @return [Hash<String, Hash>] a mapping of fully qualified class names as the
+    #  key, and the plugin
+    def add_plugins
+      {}
+    end
+
+    # Called when constructing the client. Any plugins defined here will be removed
+    # from the client. Each element in the array is the fully qualified class name.
+    def remove_plugins
+      []
+    end
+
+    # Called when resolving the available protocols for the client. The key is the
+    # protocol's configuration name, typically the shape ID, and the value is a class
+    # that will be initialized. The first protocol in the hash will be the default protocol.
+    # @return [Hash<String, Class>] protocols
+    def protocols
+      {}
+    end
+
+    # Called when creating the auth resolver and auth schemes. The key is the absolute shape
+    # id of the auth scheme trait, and the value is a hash with the following keys:
+    # * :auth_scheme_config_option - the client config option for the auth scheme.
+    # * :identity_provider_config_option - the client config option for the identity provider.
+    # * :identity_type - the identity type that the identity provider expects.
+    def add_auth_schemes
+      {}
+    end
+
+    # Called when creating the auth resolver and auth schemes. The value is the
+    # absolute shape id of the auth scheme trait.
+    def remove_auth_schemes
+      []
+    end
+  end
+end

data/lib/smithy/welds/auth/anonymous_auth.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'smithy-client/plugins/anonymous_auth'
+
+module Smithy
+  module Welds
+    # Adds default Anonymous (optional) auth.
+    class AnonymousAuth < Weld
+      def for?(_service)
+        say_status :insert, 'Adding the AnonymousAuth plugin', :yellow unless @plan.quiet
+        true
+      end
+
+      def add_plugins
+        {
+          Smithy::Client::Plugins::AnonymousAuth => { require_path: 'smithy-client/plugins/anonymous_auth' }
+        }
+      end
+
+      def add_auth_schemes
+        {
+          'smithy.api#noAuth' => {
+            auth_scheme_config_option: :anonymous_auth_scheme,
+            identity_provider_config_option: :anonymous_provider,
+            identity_type: Smithy::Client::Identities::Anonymous
+          }
+        }
+      end
+    end
+  end
+end

data/lib/smithy/welds/auth/http_api_key_auth.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'smithy-client/plugins/http_api_key_auth'
+
+module Smithy
+  module Welds
+    # Adds the HTTP API key Auth plugin if the service requires it.
+    class HttpApiKeyAuth < Weld
+      def for?(service)
+        _id, service = service.first
+        return false unless service.fetch('traits', {}).key?('smithy.api#httpApiKeyAuth')
+
+        say_status :insert, 'Adding the HttpApiKeyAuth plugin', :yellow unless @plan.quiet
+        true
+      end
+
+      def add_plugins
+        {
+          Smithy::Client::Plugins::HttpApiKeyAuth => { require_path: 'smithy-client/plugins/http_api_key_auth' }
+        }
+      end
+
+      def add_auth_schemes
+        {
+          'smithy.api#httpApiKeyAuth' => {
+            auth_scheme_config_option: :http_api_key_auth_scheme,
+            identity_provider_config_option: :http_api_key_provider,
+            identity_type: Smithy::Client::Identities::HttpApiKey
+          }
+        }
+      end
+    end
+  end
+end

data/lib/smithy/welds/auth/http_basic_auth.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'smithy-client/plugins/http_basic_auth'
+
+module Smithy
+  module Welds
+    # Adds the HTTP Basic Auth plugin if the service requires it.
+    class HttpBasicAuth < Weld
+      def for?(service)
+        _id, service = service.first
+        return false unless service.fetch('traits', {}).key?('smithy.api#httpBasicAuth')
+
+        say_status :insert, 'Adding the HttpBasicAuth plugin', :yellow unless @plan.quiet
+        true
+      end
+
+      def add_plugins
+        {
+          Smithy::Client::Plugins::HttpBasicAuth => { require_path: 'smithy-client/plugins/http_basic_auth' }
+        }
+      end
+
+      def add_auth_schemes
+        {
+          'smithy.api#httpBasicAuth' => {
+            auth_scheme_config_option: :http_basic_auth_scheme,
+            identity_provider_config_option: :http_login_provider,
+            identity_type: Smithy::Client::Identities::HttpLogin
+          }
+        }
+      end
+    end
+  end
+end

data/lib/smithy/welds/auth/http_bearer_auth.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'smithy-client/plugins/http_bearer_auth'
+
+module Smithy
+  module Welds
+    # Adds the HTTP Bearer Auth plugin if the service requires it.
+    class HttpBearerAuth < Weld
+      def for?(service)
+        _id, service = service.first
+        return false unless service.fetch('traits', {}).key?('smithy.api#httpBearerAuth')
+
+        say_status :insert, 'Adding the HttpBearerAuth plugin', :yellow unless @plan.quiet
+        true
+      end
+
+      def add_plugins
+        {
+          Smithy::Client::Plugins::HttpBearerAuth => { require_path: 'smithy-client/plugins/http_bearer_auth' }
+        }
+      end
+
+      def add_auth_schemes
+        {
+          'smithy.api#httpBearerAuth' => {
+            auth_scheme_config_option: :http_bearer_auth_scheme,
+            identity_provider_config_option: :http_bearer_provider,
+            identity_type: Smithy::Client::Identities::HttpBearer
+          }
+        }
+      end
+    end
+  end
+end

data/lib/smithy/welds/auth/http_digest_auth.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'smithy-client/plugins/http_digest_auth'
+
+module Smithy
+  module Welds
+    # Adds the HTTP Digest Auth plugin if the service requires it.
+    class HttpDigestAuth < Weld
+      def for?(service)
+        _id, service = service.first
+        return false unless service.fetch('traits', {}).key?('smithy.api#httpDigestAuth')
+
+        say_status :insert, 'Adding the HttpDigestAuth plugin', :yellow unless @plan.quiet
+        true
+      end
+
+      def add_plugins
+        {
+          Smithy::Client::Plugins::HttpDigestAuth => { require_path: 'smithy-client/plugins/http_digest_auth' }
+        }
+      end
+
+      def add_auth_schemes
+        {
+          'smithy.api#httpDigestAuth' => {
+            auth_scheme_config_option: :http_digest_auth_scheme,
+            identity_provider_config_option: :http_login_provider,
+            identity_type: Smithy::Client::Identities::HttpLogin
+          }
+        }
+      end
+    end
+  end
+end

data/lib/smithy/welds/plugins.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'smithy-client/plugins/checksum_required'
+require 'smithy-client/plugins/content_length'
+require 'smithy-client/plugins/default_params'
+require 'smithy-client/plugins/host_prefix'
+require 'smithy-client/plugins/idempotency_token'
+require 'smithy-client/plugins/logging'
+require 'smithy-client/plugins/net_http'
+require 'smithy-client/plugins/pageable_response'
+require 'smithy-client/plugins/param_converter'
+require 'smithy-client/plugins/param_validator'
+require 'smithy-client/plugins/protocol'
+require 'smithy-client/plugins/raise_response_errors'
+require 'smithy-client/plugins/request_compression'
+require 'smithy-client/plugins/response_target'
+require 'smithy-client/plugins/retry_errors'
+require 'smithy-client/plugins/sign_requests'
+require 'smithy-client/plugins/stub_responses'
+
+module Smithy
+  module Welds
+    # Provides default plugins.
+    class Plugins < Weld
+      def for?(_service)
+        say_status :insert, 'Adding default plugins', :yellow unless @plan.quiet
+        true
+      end
+
+      def add_plugins
+        base_path = 'smithy-client/plugins'
+        {
+          Smithy::Client::Plugins::ChecksumRequired => { require_path: "#{base_path}/checksum_required" },
+          Smithy::Client::Plugins::ContentLength => { require_path: "#{base_path}/content_length" },
+          Smithy::Client::Plugins::DefaultParams => { require_path: "#{base_path}/default_params" },
+          Smithy::Client::Plugins::HostPrefix => { require_path: "#{base_path}/host_prefix" },
+          Smithy::Client::Plugins::IdempotencyToken => { require_path: "#{base_path}/idempotency_token" },
+          Smithy::Client::Plugins::Logging => { require_path: "#{base_path}/logging" },
+          Smithy::Client::Plugins::NetHTTP => { require_path: "#{base_path}/net_http" },
+          Smithy::Client::Plugins::PageableResponse => { require_path: "#{base_path}/pageable_response" },
+          Smithy::Client::Plugins::ParamConverter => { require_path: "#{base_path}/param_converter" },
+          Smithy::Client::Plugins::ParamValidator => { require_path: "#{base_path}/param_validator" },
+          Smithy::Client::Plugins::Protocol => { require_path: "#{base_path}/protocol" },
+          Smithy::Client::Plugins::RaiseResponseErrors => { require_path: "#{base_path}/raise_response_errors" },
+          Smithy::Client::Plugins::RequestCompression => { require_path: "#{base_path}/request_compression" },
+          Smithy::Client::Plugins::ResponseTarget => { require_path: "#{base_path}/response_target" },
+          Smithy::Client::Plugins::RetryErrors => { require_path: "#{base_path}/retry_errors" },
+          Smithy::Client::Plugins::SignRequests => { require_path: "#{base_path}/sign_requests" },
+          Smithy::Client::Plugins::StubResponses => { require_path: "#{base_path}/stub_responses" }
+        }
+      end
+    end
+  end
+end

data/lib/smithy/welds/rpc_v2_cbor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Welds
+    # Adds the RPCv2 CBOR protocol to the client if the service has the trait.
+    class RPCv2CBOR < Weld
+      def for?(service)
+        _, service = service.first
+        return false unless service.fetch('traits', {}).key?('smithy.protocols#rpcv2Cbor')
+
+        say_status :insert, 'Adding the RPCv2 CBOR protocol', :yellow unless @plan.quiet
+        true
+      end
+
+      def protocols
+        { 'rpcv2Cbor' => Smithy::Client::RPCv2CBOR::Protocol }
+      end
+    end
+  end
+end

data/lib/smithy/welds/rubocop.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Welds
+    # Runs RuboCop autocorrect-all on the generated projections.
+    class Rubocop < Weld
+      TEST_NAMESPACES = [
+        Regexp.new('smithy.tests.*?'),
+        Regexp.new('smithy.protocoltests.*?'),
+        Regexp.new('smithy.ruby.tests.*?')
+      ].freeze
+
+      def for?(service)
+        namespace = Model::Shape.namespace(service.keys.first).to_s
+        TEST_NAMESPACES.none? { |test_namespace| namespace.match?(test_namespace) }
+      end
+
+      def post_process(_artifacts)
+        require 'rubocop'
+        puts "Running RuboCop --autocorrect-all on #{destination_root}"
+        rubocop = ::RuboCop::CLI.new
+        args = [
+          '--autocorrect-all',
+          '--display-only-fail-level-offenses',
+          '--config',
+          "#{destination_root}/.rubocop.yml",
+          destination_root
+        ]
+        rubocop.run(args)
+      end
+    end
+  end
+end

data/lib/smithy/welds/transforms/default_endpoint_rules.json

@@ -0,0 +1,35 @@
+{
+  "version": "1.0",
+  "parameters": {
+    "endpoint": {
+      "type": "string",
+      "builtIn": "SDK::Endpoint",
+      "documentation": "Endpoint used for making requests.  Should be formatted as a URI."
+    }
+  },
+  "rules": [
+    {
+      "conditions": [
+        {
+          "fn": "isSet",
+          "argv": [
+            {
+              "ref": "endpoint"
+            }
+          ]
+        }
+      ],
+      "endpoint": {
+        "url": {
+          "ref": "endpoint"
+        }
+      },
+      "type": "endpoint"
+    },
+    {
+      "conditions": [],
+      "error": "Endpoint is not set - you must configure an endpoint.",
+      "type": "error"
+    }
+  ]
+}

data/lib/smithy/welds/transforms/default_endpoint_tests.json

@@ -0,0 +1,24 @@
+{
+  "version": "1.0",
+  "testCases": [
+    {
+      "documentation": "Endpoint set",
+      "expect": {
+        "endpoint": {
+          "url": "https://example.com"
+        }
+      },
+      "params": {
+        "endpoint": "https://example.com"
+      }
+    },
+    {
+      "documentation": "Endpoint not set",
+      "expect": {
+        "error": "Endpoint is not set - you must configure an endpoint."
+      },
+      "params": {
+      }
+    }
+  ]
+}

data/lib/smithy/welds/transforms/endpoints.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Welds
+    # Provides default endpoint builtin/function bindings.
+    class Endpoints < Weld
+      def pre_process(model)
+        id, service = model['shapes'].select { |_k, s| s['type'] == 'service' }.first
+        return if service['traits'] && service['traits']['smithy.rules#endpointRuleSet']
+
+        say_status :insert, "Adding default endpoint rules to service #{id}", :yellow unless @plan.quiet
+        add_default_endpoints(service)
+      end
+
+      def endpoint_built_in_bindings
+        {
+          'SDK::Endpoint' => {
+            render_config: proc do |_plan|
+              <<~ADD_OPTION
+                option(
+                  :endpoint,
+                  doc_type: String,
+                  docstring: 'Custom Endpoint'
+                )
+              ADD_OPTION
+            end,
+            render_build: proc do |_plan|
+              'config.endpoint'
+            end,
+            render_test_set: proc do |_plan, value|
+              { 'endpoint' => value }
+            end
+          }
+        }
+      end
+
+      def endpoint_function_bindings
+        {
+          'isValidHostLabel' => 'Smithy::Client::EndpointRules.valid_host_label?',
+          'parseURL' => 'Smithy::Client::EndpointRules.parse_url',
+          'substring' => 'Smithy::Client::EndpointRules.substring',
+          'uriEncode' => 'Smithy::Client::EndpointRules.uri_encode',
+          'isSet' => 'Smithy::Client::EndpointRules.set?',
+          'not' => 'Smithy::Client::EndpointRules.not?',
+          'getAttr' => 'Smithy::Client::EndpointRules.attr',
+          'stringEquals' => 'Smithy::Client::EndpointRules.string_equals?',
+          'booleanEquals' => 'Smithy::Client::EndpointRules.boolean_equals?'
+        }
+      end
+
+      private
+
+      def add_default_endpoints(service)
+        service['traits'] ||= {}
+        service['traits']['smithy.rules#endpointRuleSet'] = default_endpoint_rules
+        service['traits']['smithy.rules#endpointTests'] = default_endpoint_tests
+      end
+
+      def default_endpoint_rules
+        ::JSON.load_file(File.join(__dir__.to_s, 'default_endpoint_rules.json'))
+      end
+
+      def default_endpoint_tests
+        ::JSON.load_file(File.join(__dir__.to_s, 'default_endpoint_tests.json'))
+      end
+    end
+  end
+end

data/lib/smithy/welds/transforms/synthetic_input_output.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/deep_dup'
+
+module Smithy
+  module Welds
+    # Creates synthetic input and output shapes for operations that do not have them.
+    class SyntheticInputOutput < Weld
+      def pre_process(model)
+        say_status :modify, 'Creating synthetic input and output shapes', :yellow unless @plan.quiet
+        create_synthetic_input_output_shapes(model)
+      end
+
+      private
+
+      def create_synthetic_input_output_shapes(model)
+        Model::ServiceIndex.new(model).operations_for(@plan.service).each do |operation_id, operation|
+          create_synthetic_input_shape(model, operation_id, operation) if operation['input']
+          create_synthetic_output_shape(model, operation_id, operation) if operation['output']
+        end
+      end
+
+      def create_synthetic_input_shape(model, operation_id, operation)
+        input_target = operation['input']['target']
+        target = Model.shape(model, input_target)
+        return if target.fetch('traits', {}).key?('smithy.api#input') || input_target == 'smithy.api#Unit'
+
+        input_target = new_shape_id(model, operation_id, 'Input')
+        operation['input']['target'] = input_target
+        input_shape = target.deep_dup
+        model['shapes'][input_target] = input_shape
+        input_shape['traits'] = input_shape.fetch('traits', {}).merge({ 'smithy.api#input' => {} })
+      end
+
+      def create_synthetic_output_shape(model, operation_id, operation)
+        output_target = operation['output']['target']
+        target = Model.shape(model, output_target)
+        return if target.fetch('traits', {}).key?('smithy.api#output') || output_target == 'smithy.api#Unit'
+
+        output_target = new_shape_id(model, operation_id, 'Output')
+        operation['output']['target'] = output_target
+        output_shape = target.deep_dup
+        model['shapes'][output_target] = output_shape
+        output_shape['traits'] = output_shape.fetch('traits', {}).merge({ 'smithy.api#output' => {} })
+      end
+
+      def new_shape_id(model, operation_id, suffix)
+        namespace = Model::Shape.namespace(operation_id)
+        operation_name = Model::Shape.name(operation_id)
+        id = "#{namespace}##{operation_name}#{suffix}"
+        return id unless model['shapes'].key?(id)
+
+        id = "#{namespace}##{operation_name}Operation#{suffix}"
+        return id unless model['shapes'].key?(id)
+
+        raise "unable to generate a unique synthetic #{suffix} shape ID for #{operation_id}"
+      end
+    end
+  end
+end

data/lib/smithy/welds.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'welds/auth/anonymous_auth'
+require_relative 'welds/auth/http_api_key_auth'
+require_relative 'welds/auth/http_basic_auth'
+require_relative 'welds/auth/http_bearer_auth'
+require_relative 'welds/auth/http_digest_auth'
+
+require_relative 'welds/transforms/endpoints'
+require_relative 'welds/transforms/synthetic_input_output'
+
+require_relative 'welds/plugins'
+require_relative 'welds/rpc_v2_cbor'
+# require_relative 'welds/rubocop'
+
+module Smithy
+  # @api private
+  module Welds
+    @welds = {}
+
+    def self.load!(plan)
+      Weld.subclasses.each { |weld| @welds[weld] = weld.new(plan) }
+    end
+
+    def self.for(service)
+      @welds.each_value.select { |weld| weld.for?(service) }
+    end
+  end
+end

data/lib/smithy.rb

@@ -1,7 +1,38 @@
 # frozen_string_literal: true
 
+require 'rails/railtie'
+require 'smithy-client'
+require 'thor'
+
+require_relative 'smithy/command'
+require_relative 'smithy/generators'
+require_relative 'smithy/model'
 require_relative 'smithy/plan'
+require_relative 'smithy/util'
+require_relative 'smithy/views'
+require_relative 'smithy/weld'
+require_relative 'smithy/welds'
 
+# Smithy is a modeling language created by AWS. This gem provides a Ruby
+# implementation of the Smithy language and generates clients, servers, and schemas.
 module Smithy
-  VERSION = File.read(File.expand_path('../VERSION', __dir__)).strip
-end
+  VERSION = File.read(File.expand_path('../VERSION', __dir__.to_s)).strip
+
+  # Generates Ruby code from a Smithy model and writes them to files.
+  # @param [Plan] plan The plan to generate the artifacts from.
+  # @return [Array<String>] The generated files.
+  def self.generate(plan)
+    plan.welds.each { |weld| weld.pre_process(plan.model) }
+    artifacts = Smithy::Generators.generate(plan)
+    plan.welds.each { |weld| weld.post_process(artifacts) }
+    artifacts
+  end
+
+  # Generates minimal Ruby code from a Smithy model and returns the source code.
+  # @param [Plan] plan The plan to generate the source from.
+  # @return [String] The generated source code.
+  def self.source(plan)
+    plan.welds.each { |weld| weld.pre_process(plan.model) }
+    Smithy::Generators.source(plan)
+  end
+end