smithy 2.0.0.pre0 → 2.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caac54dead11621fd0d7a29869e6f9dd39945a7a2e0a0dea66435e2c17c79ab1
-  data.tar.gz: b6ec328bb2439cae20f86056326e769b39376301b293ba5438170d105315e5a5
+  metadata.gz: a3d6e2e6c2474e08572ffac8b6d9e014d61433a94b27329c04c58ad964f1f647
+  data.tar.gz: 50392ce54b2239d61b8a5c1189b9e55bdd8e3c9558f163f1d005b5b91ff85867
 SHA512:
-  metadata.gz: d7b62fcc5ce4c8bb2af3f89886ed59b49f26189e923368a27e3d92094a6f58616a0d28d9668a3f2771a21880f8857dec059af3e96c55d4cb8f4fc9061bed2f3c
-  data.tar.gz: 152b056cddc6c5bffa308da073cb6bb8443ff6fc98780946e1d8409486e59b72b80dd78464feee32de1c520219c3b149ccd77bf7d6e2880aa3bb4e282e86bd12
+  metadata.gz: d4b2bc367e168ed6e0841bb6efe7b5b949910efcf36778d4a95afa127935fb758929128cc9d93feae7402a98185e629e16461cbd7f38a3d2910169076b740494
+  data.tar.gz: 32bd9986f0dc5a9c9c52414d48c5dcd2f0213d8115d475a4f50dbe6ac375a47a0ce30b5a5a39e815cb716ca3ff2c72c4e4f0ff59181b7699f54c1edc19b6dca0

data/VERSION

@@ -1 +1 @@
-2.0.0.pre0
+2.0.0.pre1

data/bin/smithy-ruby

@@ -1,8 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-puts "I'm being executed!"
-
 require 'smithy'
-
-Smithy::Plan.new(ARGV)
+Smithy::Command::CLI.start

data/lib/smithy/command.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Smithy
+  # @api private
+  module Command
+    # @api private
+    class Base < Thor
+      # Necessary to report the correct status to the parent process (`smithy build`)
+      def self.exit_on_failure?
+        true
+      end
+    end
+
+    # @api private
+    class Smith < Base
+      class_option :destination_root, type: :string, required: true,
+                                      default: ENV.fetch('SMITHY_PLUGIN_DIR', nil),
+                                      desc: 'The destination directory for the generated code.'
+      class_option :quiet, type: :boolean, default: false, desc: 'Suppress all output.'
+
+      def self.gem_options!
+        method_option :name, type: :string,
+                             desc: 'The name of the service to generate code for.' \
+                                   'Defaults to the name of the first service shape found in the model.'
+        method_option :module_name, type: :string,
+                                    desc: 'The module name to generate, e.g. `Organization::Weather`. ' \
+                                          'Defaults to the name of the service.'
+        method_option :gem_name, type: :string, required: true,
+                                 desc: 'The name of the gem to generate. Defaults to a gem name derived ' \
+                                       'from the module name, suffixed with "-schema" if type is schema.'
+        method_option :gem_version, type: :string, required: true, desc: 'The version of the gem to generate.'
+      end
+
+      gem_options!
+      desc 'schema', 'Generates a schema for the model provided to STDIN.'
+      def schema
+        invoke(:schema, options)
+      end
+
+      gem_options!
+      desc 'client', 'Generates a client for the model provided to STDIN.'
+      def client
+        invoke(:client, options)
+      end
+
+      desc 'server', 'Generates a server for the model provided to STDIN.'
+      def server
+        raise NotImplementedError, 'server generation is not yet implemented'
+      end
+
+      no_tasks do
+        def invoke(type, options)
+          model = JSON.parse($stdin.read)
+          plan = Smithy::Plan.new(model, type, options)
+          Smithy.generate(plan)
+        end
+      end
+    end
+
+    # @api private
+    class CLI < Base
+      desc 'smith', 'Generate code using a Smithy model.'
+      subcommand 'smith', Smith
+    end
+  end
+end

data/lib/smithy/generators/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Generators
+    # Base class for generating files.
+    class Base
+      include Thor::Base
+      include Thor::Actions
+
+      # @param [Plan] plan The plan to generate.
+      def initialize(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
+    end
+  end
+end

data/lib/smithy/generators/client.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Generators
+    # Generates a gem for the client.
+    class Client < Base
+      # @param [Plan] plan The plan to generate.
+      def initialize(plan)
+        @plan = plan
+        @gem_name = plan.gem_name
+        super
+      end
+
+      def generate
+        gem_files.each_with_object([]) do |(file, content), files|
+          next if file == "lib/#{@gem_name}/customizations.rb" && should_skip_customizations?
+
+          create_file file, content
+          files << file
+        end
+      end
+
+      def source
+        source_files.map { |_file, content| content }.join("\n")
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize
+      def gem_files
+        Enumerator.new do |e|
+          e.yield "#{@gem_name}.gemspec", Views::Client::Gemspec.new(@plan).render
+          e.yield '.rubocop.yml', Views::Client::RubocopYml.new(@plan).render
+
+          source_files.each { |file, content| e.yield file, content }
+          e.yield "lib/#{@gem_name}/customizations.rb", Views::Client::Customizations.new.render
+
+          spec_files.each { |file, content| e.yield file, content }
+
+          rbs_files.each { |file, content| e.yield file, content }
+        end
+      end
+
+      def source_files
+        Enumerator.new do |e|
+          e.yield "lib/#{@gem_name}.rb", Views::Client::Module.new(@plan).render
+          e.yield "lib/#{@gem_name}/auth_parameters.rb", Views::Client::AuthParameters.new(@plan).render
+          e.yield "lib/#{@gem_name}/auth_resolver.rb", Views::Client::AuthResolver.new(@plan).render
+          e.yield "lib/#{@gem_name}/errors.rb", Views::Client::Errors.new(@plan).render
+          e.yield "lib/#{@gem_name}/endpoint_parameters.rb", Views::Client::EndpointParameters.new(@plan).render
+          e.yield "lib/#{@gem_name}/endpoint_provider.rb", Views::Client::EndpointProvider.new(@plan).render
+          e.yield "lib/#{@gem_name}/paginators.rb", Views::Client::Paginators.new(@plan).render
+          code_generated_plugins.each { |path, plugin| e.yield path, plugin.source }
+          e.yield "lib/#{@gem_name}/types.rb", Views::Client::Types.new(@plan).render
+          e.yield "lib/#{@gem_name}/schema.rb", Views::Client::Schema.new(@plan).render
+          e.yield "lib/#{@gem_name}/waiters.rb", Views::Client::Waiters.new(@plan).render
+          e.yield "lib/#{@gem_name}/client.rb", Views::Client::Client.new(@plan, code_generated_plugins).render
+        end
+      end
+
+      def spec_files
+        Enumerator.new do |e|
+          e.yield 'spec/spec_helper.rb', Views::Client::SpecHelper.new(@plan).render
+          e.yield "spec/#{@gem_name}/endpoint_provider_spec.rb", Views::Client::EndpointProviderSpec.new(@plan).render
+          e.yield "spec/#{@gem_name}/protocol_spec.rb", Views::Client::ProtocolSpec.new(@plan).render
+        end
+      end
+
+      def rbs_files
+        Enumerator.new do |e|
+          e.yield "sig/#{@gem_name}.rbs", Views::Client::ModuleRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/auth_parameters.rbs", Views::Client::AuthParametersRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/auth_resolver.rbs", Views::Client::AuthResolverRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/client.rbs", Views::Client::ClientRbs.new(@plan, code_generated_plugins).render
+          e.yield "sig/#{@gem_name}/errors.rbs", Views::Client::ErrorsRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/endpoint_parameters.rbs", Views::Client::EndpointParametersRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/endpoint_provider.rbs", Views::Client::EndpointProviderRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/schema.rbs", Views::Client::SchemaRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/types.rbs", Views::Client::TypesRbs.new(@plan).render
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def code_generated_plugins
+        Enumerator.new do |e|
+          e.yield "lib/#{@gem_name}/plugins/auth.rb", Views::Client::Plugin.new(
+            class_name: "::#{@plan.module_name}::Plugins::Auth",
+            require_path: 'plugins/auth',
+            require_relative: true,
+            source: Views::Client::AuthPlugin.new(@plan).render
+          )
+          e.yield "lib/#{@gem_name}/plugins/endpoint.rb", Views::Client::Plugin.new(
+            class_name: "::#{@plan.module_name}::Plugins::Endpoint",
+            require_path: 'plugins/endpoint',
+            require_relative: true,
+            source: Views::Client::EndpointPlugin.new(@plan).render
+          )
+        end
+      end
+
+      def should_skip_customizations?
+        Dir["#{destination_root}/**/*"].any? { |f| f.include?('/customizations.rb') }
+      end
+    end
+  end
+end

data/lib/smithy/generators/schema.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Generators
+    # Generates a gem for the types.
+    class Schema < Base
+      # @param [Plan] plan The plan to generate.
+      def initialize(plan)
+        @plan = plan
+        @gem_name = plan.gem_name
+        super
+      end
+
+      def generate
+        gem_files.each_with_object([]) do |(file, content), files|
+          next if file == "lib/#{@gem_name}/customizations.rb" && should_skip_customizations?
+
+          create_file file, content
+          files << file
+        end
+      end
+
+      def source
+        source_files.map { |_file, content| content }.join("\n")
+      end
+
+      private
+
+      def gem_files
+        Enumerator.new do |e|
+          e.yield "#{@gem_name}.gemspec", Views::Client::Gemspec.new(@plan).render
+          e.yield '.rubocop.yml', Views::Client::RubocopYml.new(@plan).render
+
+          source_files.each { |file, content| e.yield file, content }
+          e.yield "lib/#{@gem_name}/customizations.rb", Views::Client::Customizations.new.render
+          rbs_files.each { |file, content| e.yield file, content }
+        end
+      end
+
+      def source_files
+        Enumerator.new do |e|
+          e.yield "lib/#{@gem_name}.rb", Views::Client::Module.new(@plan).render
+          e.yield "lib/#{@gem_name}/types.rb", Views::Client::Types.new(@plan).render
+          e.yield "lib/#{@gem_name}/schema.rb", Views::Client::Schema.new(@plan).render
+        end
+      end
+
+      def rbs_files
+        Enumerator.new do |e|
+          e.yield "sig/#{@gem_name}.rbs", Views::Client::ModuleRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/types.rbs", Views::Client::TypesRbs.new(@plan).render
+          e.yield "sig/#{@gem_name}/schema.rbs", Views::Client::SchemaRbs.new(@plan).render
+        end
+      end
+
+      def should_skip_customizations?
+        Dir["#{destination_root}/**/*"].any? { |f| f.include?('/customizations.rb') }
+      end
+    end
+  end
+end

data/lib/smithy/generators.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'generators/base'
+require_relative 'generators/client'
+require_relative 'generators/schema'
+
+module Smithy
+  # Facilitates generation of artifacts.
+  module Generators
+    def self.generate(plan)
+      case plan.type
+      when :schema then Schema.new(plan).generate
+      when :client then Client.new(plan).generate
+      else
+        raise 'Not yet implemented'
+      end
+    end
+
+    def self.source(plan)
+      case plan.type
+      when :schema then Schema.new(plan).source
+      when :client then Client.new(plan).source
+      when :server then raise 'Will not be implemented'
+      else
+        raise 'Not yet implemented'
+      end
+    end
+  end
+end

data/lib/smithy/model/flattener.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Model
+    # @api private
+    class Flattener
+      def initialize(model)
+        @model = model
+      end
+
+      def shape(id)
+        shape = @model['shapes'][id]
+        return shape unless shape['mixins']
+
+        shape['mixins'].reverse_each do |mixin|
+          mixin_shape = shape(mixin['target'])
+          shape = deep_merge(mixin_shape, shape, exclude_traits(mixin_shape))
+          apply_traits(id, shape)
+          shape.delete('mixins')
+        end
+
+        shape
+      end
+
+      private
+
+      def exclude_traits(shape)
+        [
+          'smithy.api#mixin',
+          *shape.fetch('traits', {}).fetch('smithy.api#mixin', {}).fetch('localTraits', [])
+        ]
+      end
+
+      def deep_merge(hash1, hash2, exclude_traits = [], context = nil)
+        hash1 = hash1.dup
+        if hash1['traits']
+          hash1['traits'] = hash1['traits'].except(*exclude_traits)
+          hash1.delete('traits') if hash1['traits'].empty?
+        end
+        deep_merge!(hash1, hash2, exclude_traits, context)
+      end
+
+      def deep_merge!(hash1, hash2, exclude_traits, context)
+        hash1.merge!(hash2) do |key, v1, v2|
+          if v1.is_a?(Hash) && v2.is_a?(Hash)
+            deep_merge(v1, v2, exclude_traits, key)
+          elsif v1.is_a?(Array) && v2.is_a?(Array) && context != 'traits'
+            # Merge arrays, but only if the key is not a trait
+            v1 + v2
+          else
+            v2
+          end
+        end
+      end
+
+      def apply_traits(id, shape)
+        case shape['type']
+        when 'structure'
+          structure(id, shape)
+        when 'union'
+          union(id, shape)
+        when 'list'
+          list(id, shape)
+        when 'map'
+          map_key(id, shape)
+          map_value(id, shape)
+        end
+      end
+
+      def structure(id, shape)
+        shape['members'].each do |member_name, member_shape|
+          member_id = "#{id}$#{member_name}"
+          next unless apply_shape_exists?(member_id)
+
+          apply_shape = shape(member_id)
+          member_keys = shape['members'][member_name].keys
+          shape['members'][member_name] = deep_merge(member_shape, apply_shape).slice(*member_keys)
+        end
+      end
+      alias union structure
+
+      def list(id, shape)
+        member_id = "#{id}$member"
+        return unless apply_shape_exists?(member_id)
+
+        apply_shape = shape(member_id)
+        member_keys = shape['member'].keys
+        shape['member'] = deep_merge(shape['member'], apply_shape).slice(*member_keys)
+      end
+
+      def map_key(id, shape)
+        key_id = "#{id}$key"
+        return unless apply_shape_exists?(key_id)
+
+        key_shape = shape(key_id)
+        key_keys = shape['key'].keys
+        shape['key'] = deep_merge(shape['key'], key_shape).slice(*key_keys)
+      end
+
+      def map_value(id, shape)
+        value_id = "#{id}$value"
+        return unless apply_shape_exists?(value_id)
+
+        value_shape = shape(value_id)
+        value_keys = shape['value'].keys
+        shape['value'] = deep_merge(shape['value'], value_shape).slice(*value_keys)
+      end
+
+      def apply_shape_exists?(id)
+        @model['shapes'][id] && @model['shapes'][id]['type'] == 'apply'
+      end
+    end
+  end
+end

data/lib/smithy/model/operation_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Model
+    # @api private
+    class OperationParser
+      def initialize(model)
+        @model = model
+        @structure_parser = StructureParser.new(model)
+      end
+
+      def shapes_for(operation)
+        shapes = {}
+        _id, operation = operation.first
+        parse_input_output(operation['input'], shapes)
+        parse_input_output(operation['output'], shapes)
+        parse_errors(operation['errors'], shapes)
+        shapes
+      end
+
+      private
+
+      def parse_input_output(structure_shape, shapes)
+        target = structure_shape['target']
+        return if target == 'smithy.api#Unit'
+
+        shape = Model.shape(@model, target)
+        shapes[target] = shape
+        shapes.merge!(@structure_parser.shapes_for({ target => shape }))
+      end
+
+      def parse_errors(errors, shapes)
+        errors&.each do |error|
+          target = error['target']
+          shape = Model.shape(@model, target)
+          shapes[target] = shape
+          shapes.merge!(@structure_parser.shapes_for({ target => shape }))
+        end
+      end
+    end
+  end
+end

data/lib/smithy/model/rbs.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Model
+    # @api private
+    class RBS
+      class << self
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def type(model, id, shape)
+          case shape['type']
+          when 'blob', 'string', 'enum' then 'String'
+          when 'boolean' then 'bool'
+          when 'byte', 'short', 'integer', 'bigInteger', 'long', 'intEnum' then 'Integer'
+          when 'bigDecimal' then 'BigDecimal'
+          when 'float', 'double' then 'Float'
+          when 'timestamp' then 'Time'
+          when 'document' then 'Smithy::Schema::document'
+          when 'list'
+            list_type(model, shape)
+          when 'map'
+            map_type(model, shape)
+          when 'structure', 'union'
+            structure_type(id)
+          else
+            'untyped'
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        private
+
+        def structure_type(id)
+          if id == 'smithy.api#Unit'
+            'Smithy::Schema::EmptyStructure'
+          else
+            "Types::#{Model::Shape.name(id)}"
+          end
+        end
+
+        def map_type(model, shape)
+          key_target = Model.shape(model, shape['key']['target'])
+          value_target = Model.shape(model, shape['value']['target'])
+          sparse = shape.fetch('traits', {}).key?('smithy.api#sparse')
+          key_type = type(model, shape['key']['target'], key_target)
+          value_type = type(model, shape['value']['target'], value_target)
+          "Hash[#{key_type}, #{value_type}#{'?' if sparse}]"
+        end
+
+        def list_type(model, shape)
+          member_target = Model.shape(model, shape['member']['target'])
+          sparse = shape.fetch('traits', {}).key?('smithy.api#sparse')
+          "Array[#{type(model, shape['member']['target'], member_target)}#{'?' if sparse}]"
+        end
+      end
+    end
+  end
+end

data/lib/smithy/model/service_index.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Model
+    # Finds sets of shapes for a service.
+    class ServiceIndex
+      # @param [Hash] model Model
+      def initialize(model)
+        @model = model
+        @service_parser = ServiceParser.new(model)
+        @operation_parser = OperationParser.new(model)
+        @structure_parser = StructureParser.new(model)
+      end
+
+      # @param [Hash] service Service shape
+      # @return [Hash<String, Hash>] The operations for the service.
+      def operations_for(service)
+        @operations_for ||= begin
+          shapes = @service_parser.operations_for(service)
+          shapes.sort_by { |k, _v| k }.to_h
+        end
+      end
+
+      # @param [Hash] service Service shape
+      # @return [Hash<String, Hash>] The shapes for the service.
+      def shapes_for(service)
+        @shapes_for ||= begin
+          shapes = {}
+          parse_errors(service, shapes)
+          operations_for(service).each do |id, operation|
+            shapes.merge!(@operation_parser.shapes_for({ id => operation }))
+          end
+          shapes.sort_by { |k, _v| k }.to_h
+        end
+      end
+
+      private
+
+      def parse_errors(service, shapes)
+        _, service = service.first
+
+        service['errors']&.each do |error|
+          target = error['target']
+          shape = Model.shape(@model, target)
+          shapes[target] = shape
+          shapes.merge!(@structure_parser.shapes_for({ target => shape }))
+        end
+      end
+    end
+  end
+end

data/lib/smithy/model/service_parser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Smithy
+  module Model
+    # @api private
+    class ServiceParser
+      RESOURCE_LIFECYCLE_KEYS = %w[create put read update delete list].freeze
+
+      def initialize(model)
+        @model = model
+      end
+
+      def operations_for(service)
+        operations = {}
+        _, service = service.first
+        parse_service_operations(service, operations)
+        parse_service_resources(service, operations)
+        operations
+      end
+
+      private
+
+      def parse_service_operations(service, operations)
+        service['operations']&.collect do |shape|
+          target = shape['target']
+          operations[target] = Model.shape(@model, target)
+        end
+      end
+
+      def parse_service_resources(service, operations)
+        service['resources']&.collect do |shape|
+          target = shape['target']
+          resource_shape = Model.shape(@model, target)
+          parse_resource(resource_shape, operations)
+        end
+      end
+
+      def parse_resource(resource, operations)
+        parse_lifecycles(resource, operations)
+        parse_resource_operations(resource, operations)
+        parse_resource_collection_operations(resource, operations)
+
+        resource['resources']&.collect do |shape|
+          target = shape['target']
+          resource_shape = Model.shape(@model, target)
+          parse_resource(resource_shape, operations)
+        end
+      end
+
+      def parse_lifecycles(resource, operations)
+        RESOURCE_LIFECYCLE_KEYS.each do |key|
+          next unless resource[key]
+
+          target = resource[key]['target']
+          operations[target] = Model.shape(@model, target)
+        end
+      end
+
+      def parse_resource_operations(resource, operations)
+        resource['operations']&.collect do |shape|
+          target = shape['target']
+          operations[target] = Model.shape(@model, target)
+        end
+      end
+
+      def parse_resource_collection_operations(resource, operations)
+        resource['collectionOperations']&.collect do |shape|
+          target = shape['target']
+          operations[target] = Model.shape(@model, target)
+        end
+      end
+    end
+  end
+end