modern 0.4.2

data/lib/modern/app/request_handling/output_handling.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'modern/errors/web_errors'
+
+require "modern/util/header_parsing"
+
+module Modern
+  class App
+    module RequestHandling
+      module OutputHandling
+        private
+
+        def determine_output_converter(request, route)
+          accept_header = request.env["HTTP_ACCEPT"] || "*/*"
+
+          requested_types =
+            Modern::Util::HeaderParsing.parse_accept_header(accept_header) \
+                                       .select { |c| route.content_types.any? { |ct| File.fnmatch(c, ct) } }
+
+          ret =
+            route.output_converters.find do |oc|
+              requested_types.find do |c|
+                File.fnmatch(c, oc.media_type)
+              end
+            end
+
+          raise Errors::NotAcceptableError, "No servable types in Accept header: #{accept_header || 'nil'}" \
+            if ret.nil?
+
+          ret
+        end
+
+        def validate_output!(content, retval, request, route)
+          if content.type.nil?
+            retval
+          else
+            content.type[retval]
+          end
+        rescue Dry::Types::ConstraintError,
+               Dry::Types::MissingKeyError,
+               Dry::Struct::Error => err
+          if @configuration.validate_responses != 'no'
+            request.logger.error "Bad validation for response to #{route.id}, " \
+                                "content type #{content.media_type}", err
+
+            raise err if @configuration.validate_responses == 'error'
+          end
+
+          retval
+        end
+      end
+    end
+  end
+end

data/lib/modern/app/request_handling/request_container.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Modern
+  class App
+    module RequestHandling
+      # Encapsulates all non-derived portions of the request to run security
+      # actions inside of it.
+      class PartialRequestContainer
+        attr_reader :logger
+        attr_reader :configuration
+        attr_reader :services
+        attr_reader :route
+
+        attr_reader :request
+        attr_reader :response
+
+        def initialize(logger, configuration, services, route, request, response)
+          @logger = logger
+          @configuration = configuration
+          @services = services
+          @route = route
+
+          @request = request
+          @response = response
+        end
+
+        def with_logger_fields(fields = {})
+          original_logger = @logger
+          @logger = original_logger.child(fields)
+
+          ret = yield
+
+          @logger = original_logger
+
+          ret
+        end
+      end
+
+      # Encapsulates all portions of the request, including params and body,
+      # to have a route action run inside of it. This will be subclassed by
+      # {Modern::Descriptor::Route}s that incorporate helper libraries.
+      class FullRequestContainer < PartialRequestContainer
+        attr_reader :params
+        attr_reader :body
+
+        def initialize(logger, configuration, services, route, request, response, params, body)
+          super(logger, configuration, services, route, request, response)
+
+          @params = params
+          @body = body
+        end
+      end
+    end
+  end
+end

data/lib/modern/app/request_handling.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'modern/errors/web_errors'
+
+require 'modern/app/request_handling/request_container'
+require 'modern/app/request_handling/input_handling'
+require 'modern/app/request_handling/output_handling'
+
+module Modern
+  class App
+    module RequestHandling
+      include Modern::App::RequestHandling::InputHandling
+      include Modern::App::RequestHandling::OutputHandling
+
+      private
+
+      # Encapsulates the full request handler for the app, given the route from
+      # the router. Handles security scheme checks, parameter validation, etc.
+      def process_request(request, response, route)
+        route_logger = request.logger.child(id: route.id)
+
+        output_converter = determine_output_converter(request, route)
+        raise Errors::NotAcceptableError \
+          if output_converter.nil? || !route.content_types.include?(output_converter.media_type)
+
+        container = PartialRequestContainer.new(
+          route_logger, @configuration, @services, route, request, response
+        )
+
+        raise Errors::UnauthorizedError \
+          if !route.security.empty? && route.security.all? { |s| s.validate(container) == false }
+
+        params = parse_parameters(request, route)
+        body = parse_request_body(request, route) unless route.request_body.nil?
+        raise Errors::BadRequestError \
+          if body.nil? && route.request_body&.required
+
+        begin
+          # Creates a FullRequestContainer and runs through it
+          container = route.request_container_class.new(
+            route_logger, @configuration, @services, route, request, response, params, body
+          )
+          retval = container.instance_exec(&route.action)
+
+          # Leaving a hole for people to bypass responses and dump whatever
+          # they want through the underlying `Rack::Response`.
+          unless response.bypass
+            route_code = route.responses_by_code.key?(response.status) ? response.status : :default
+
+            route_response = route.responses_by_code[route_code]
+            route_content = route_response.content_by_type[output_converter.media_type]
+
+            if route_content.nil?
+              raise Errors::InternalServiceError,
+                    "no content for '#{output_converter.media_type}' for code #{route_code}"
+            end
+
+            retval = validate_output!(route_content, retval, request, route)
+
+            response.headers["Content-Type"] = output_converter.media_type
+            response.write(output_converter.converter.call(route_content.type, retval))
+          end
+        rescue StandardError => err
+          route_logger.error(err)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/modern/app/router.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'modern/descriptor/route'
+
+module Modern
+  class App
+    class Router < Dry::Struct
+      attribute :routes, Modern::Types::Strict::Array.of(
+        Modern::Types.Instance(Modern::Descriptor::Route)
+      )
+
+      def initialize(inputs)
+        super(inputs)
+      end
+
+      def resolve(_http_method, _path)
+        raise "#{self.class.name}#resolve must be implemented."
+      end
+
+      private
+
+      def process_routes
+        raise "#{self.class.name}#process_routes must be implemented."
+      end
+    end
+  end
+end

data/lib/modern/app/trie_router.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'diff/lcs'
+
+require "modern/app/router"
+
+require 'modern/util/trie_node'
+
+module Modern
+  class App
+    class TrieRouter < Router
+      def initialize(inputs)
+        super(inputs)
+
+        @trie = build_trie(routes)
+      end
+
+      def resolve(http_method, path)
+        trie_path = path.sub(%r|^/|, "").split("/") + [http_method.to_s.upcase]
+        @trie.get(trie_path)
+      end
+
+      private
+
+      def build_trie(routes)
+        trie = Modern::Util::TrieNode.new
+        routes.each do |route|
+          route.path_matcher # pre-seed the path matcher
+
+          trie.add(route.route_tokens + [route.http_method], route, raise_if_present: true)
+        end
+
+        trie
+      end
+    end
+  end
+end

data/lib/modern/app.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "rack"
+
+require "deep_dup"
+require "ice_nine"
+
+require "ougai"
+
+require "modern/configuration"
+require "modern/descriptor"
+require "modern/services"
+
+require "modern/request"
+require "modern/response"
+
+require "modern/app/error_handling"
+require "modern/app/request_handling"
+require "modern/app/trie_router"
+
+require "modern/doc_generator/open_api3"
+
+require "modern/errors"
+require "modern/redirect"
+
+module Modern
+  # `App` is the core of Modern. Some Rack application frameworks have you
+  # inherit from them to generate your application; however, that makes it
+  # pretty difficult to control immutability of the underlying routes. Since we
+  # have a need to generate an OpenAPI specification off of our routes and
+  # our behaviors, this is not an acceptable trade-off. As such, Modern expects
+  # to be passed a {Modern::Description::Descriptor}, which specifies a set of
+  # {Modern::Description::Route}s. The app then dispatches requests based on
+  # these routes.
+  class App
+    include Modern::App::ErrorHandling
+    include Modern::App::RequestHandling
+
+    attr_reader :logger
+    attr_reader :services
+
+    def initialize(descriptor, configuration = Modern::Configuration.new, services = Services.new)
+      @descriptor = IceNine.deep_freeze(DeepDup.deep_dup(descriptor))
+      @configuration = IceNine.deep_freeze(DeepDup.deep_dup(configuration))
+      @services = services
+
+      # TODO: figure out a good componentized naming scheme for Modern's own logs
+      #       so as to clearly differentiate them from user logs.
+      @logger = @services.base_logger
+
+      @router = Modern::App::TrieRouter.new(
+        routes: Modern::DocGenerator::OpenAPI3.new.decorate_with_openapi_routes(@configuration, @descriptor)
+      )
+    end
+
+    def call(env)
+      request = Modern::Request.new(env, logger)
+      response = Modern::Response.new(request)
+      response.headers["X-Request-Id"] = request.request_id
+
+      route = @router.resolve(request.request_method, request.path_info)
+
+      begin
+        raise Modern::Errors::NotFoundError if route.nil?
+
+        process_request(request, response, route)
+        response.finish
+      rescue Modern::Redirect => redirect
+        response.redirect(redirect.redirect_to, redirect.status)
+      rescue Modern::Errors::WebError => err
+        catch_web_error(response, err)
+      rescue StandardError => err
+        catch_unhandled_error(response, err)
+      ensure
+        response.finish
+        request.cleanup
+      end
+
+      response.to_a
+    end
+  end
+end

data/lib/modern/capsule.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'docile'
+
+module Modern
+  class Capsule
+    attr_reader :block
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def self.define(&block)
+      Capsule.new(&block)
+    end
+  end
+end

data/lib/modern/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'modern/struct'
+
+module Modern
+  class Configuration < Modern::Struct
+    # TODO: once Modern is done, figure out sane defaults.
+    attribute :show_errors, Modern::Types::Strict::Bool.default(true)
+    attribute :log_input_converter_errors, Modern::Types::Strict::Bool.default(true)
+
+    attribute :validate_responses, Modern::Types::Strict::String.default("log").enum("no", "log", "error")
+
+    attribute :open_api_json_path, Modern::Types::Strict::String.default("/openapi.json")
+    attribute :open_api_yaml_path, Modern::Types::Strict::String.default("/openapi.yaml")
+  end
+end

data/lib/modern/core_ext/array.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Array
+  def subsequences
+    (0..length).map do |n|
+      self[0, n]
+    end
+  end
+
+  def duplicates
+    group_by(&:itself).map { |e| e[0] if e[1][1] }.compact
+  end
+
+  def deep_compact!
+    each do |v|
+      if v.is_a?(Hash) || v.respond_to?(:values)
+        v.values.deep_compact!
+      elsif v.is_a?(Array) || v.respond_to?(:each)
+        v.deep_compact!
+      end
+    end
+  end
+end

data/lib/modern/core_ext/hash.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Hash
+  def deep_compact!
+    compact!
+
+    each_value do |v|
+      if v.is_a?(Hash) || v.respond_to?(:values)
+        v.deep_compact!
+      elsif v.is_a?(Array) || v.respond_to?(:each)
+        v.deep_compact!
+      end
+    end
+
+    self
+  end
+end

data/lib/modern/descriptor/content.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "modern/struct"
+
+module Modern
+  module Descriptor
+    class Content < Modern::Struct
+      Type = Types.Instance(self)
+
+      attribute :media_type, Types::MIMEType
+      attribute :type, (Types::Type | Types::Struct).optional.default(nil)
+    end
+  end
+end

data/lib/modern/descriptor/converters/input/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'content-type'
+
+module Modern
+  module Descriptor
+    module Converters
+      module Input
+        # An input converter takes a raw HTTP request body (as a `StringIO`) and
+        # returns a Ruby object. A JSON converter would return a hash, for
+        # example; a converter for 'image/* might return the `StringIO` object
+        # without alteration. The results of this converter will be passed into
+        # against a {Modern::Types::Type} if one has been provided (which will
+        # cause a validation check) before being passed into the route action.
+        class Base < Modern::Struct
+          attr_reader :content_type
+
+          def initialize(fields)
+            super
+            @content_type = ContentType.parse(media_type).freeze
+          end
+
+          attribute :media_type, Types::MIMEType
+          attribute :converter, Types.Instance(Proc)
+        end
+      end
+    end
+  end
+end

data/lib/modern/descriptor/converters/input/json.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'modern/descriptor/converters/input/base'
+
+require 'json'
+
+module Modern
+  module Descriptor
+    module Converters
+      module Input
+        JSON = Base.new(
+          media_type: "application/json",
+          converter: proc do |io|
+            str = io.read
+            str.empty? ? nil : ::JSON.parse(str)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/modern/descriptor/converters/output/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Modern
+  module Descriptor
+    module Converters
+      module Output
+        # An output converter takes a Ruby object and returns the raw contents of
+        # an HTTP response body. A JSON converter would invoke `JSON.generate` on
+        # a Ruby object to yield UTF-8 text; a binary converter would take an IO
+        # and dump its contents into the HTTP stream.
+        class Base < Modern::Struct
+          attr_reader :content_type
+
+          def initialize(fields)
+            super
+            @content_type = ContentType.parse(media_type).freeze
+          end
+
+          attribute :media_type, Types::MIMEType
+          attribute :converter, Types.Instance(Proc)
+        end
+      end
+    end
+  end
+end

data/lib/modern/descriptor/converters/output/json.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'modern/descriptor/converters/output/base'
+
+require 'json'
+
+# it gets confused by the blank line after the retval reassignment.
+# rubocop:disable Layout/EmptyLinesAroundArguments
+
+module Modern
+  module Descriptor
+    module Converters
+      module Output
+        JSON = Base.new(
+          media_type: "application/json",
+          converter: proc do |_type, retval|
+            retval =
+              if retval.is_a?(Hash)
+                retval.compact
+              elsif retval.is_a?(Dry::Struct)
+                retval.to_h.compact
+              else
+                retval
+              end
+
+            if retval.respond_to?(:as_json)
+              ::JSON.generate(retval.as_json)
+            elsif retval.respond_to?(:to_json)
+              retval.to_json
+            else
+              ::JSON.generate(retval)
+            end
+          end
+        )
+
+        # We use this because we pre-bake the OpenAPI3 spec JSON and
+        # want the content type. However, our route invokes
+        # {Modern::Response#bypass!}, so this will never be called.
+        JSONBypass = Base.new(
+          media_type: "application/json",
+          converter: proc { raise "this should never be called!" }
+        )
+      end
+    end
+  end
+end
+
+# rubocop:enable Layout/EmptyLinesAroundArguments

data/lib/modern/descriptor/converters/output/yaml.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'modern/descriptor/converters/output/base'
+
+module Modern
+  module Descriptor
+    module Converters
+      module Output
+        # We use this because we pre-bake the OpenAPI3 spec JSON and
+        # want the content type. However, our route invokes
+        # {Modern::Response#bypass!}, so this will never be called.
+        YAMLBypass = Base.new(
+          media_type: "application/yaml",
+          converter: proc { raise "this should never be called!" }
+        )
+      end
+    end
+  end
+end
+
+# rubocop:enable Layout/EmptyLinesAroundArguments

data/lib/modern/descriptor/converters.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+Dir["#{__dir__}/converters/input/**/*.rb"].each { |f| require_relative f }
+Dir["#{__dir__}/converters/output/**/*.rb"].each { |f| require_relative f }

data/lib/modern/descriptor/core.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "modern/struct"
+
+require "modern/core_ext/array"
+
+require "modern/descriptor/info"
+require "modern/descriptor/server"
+require "modern/descriptor/converters"
+require "modern/descriptor/route"
+
+module Modern
+  module Descriptor
+    # The class that encapsulates all routes, along with their configuration and
+    # metadata. This class can recursively include itself to mount other
+    # instances inside of itself; this is used by {Modern::App} to generate
+    # OpenAPI documentation and design routing accordingly.
+    class Core < Modern::Struct
+      attribute :info, Modern::Descriptor::Info
+      attribute :servers, Types.array_of(Server)
+
+      attribute :routes, Types.array_of(Modern::Descriptor::Route)
+
+      attr_reader :securities_by_name
+      attr_reader :root_schemas
+      attr_reader :routes_by_id
+      attr_reader :routes_by_path
+
+      def initialize(fields)
+        super
+
+        securities = routes.map(&:security).flatten.uniq
+        duplicate_names = securities.map(&:name).duplicates
+
+        raise "Duplicate but not identical securities by names: #{duplicate_names.join(', ')}" \
+          unless duplicate_names.empty?
+
+        @securities_by_name = securities.map { |s| [s.name, s] }.to_h.freeze
+
+        # This could be a set, but I like being able to just pull values in debug and this is
+        # only iterated over.
+        @root_schemas =
+          routes.map do |route|
+            [
+              route.request_body&.type,
+              route.responses.map(&:content).flatten.map(&:type)
+            ]
+          end.flatten.compact.uniq.freeze
+
+        @routes_by_path = {}
+        routes.each do |route|
+          @routes_by_path[route.path] ||= {}
+          @routes_by_path[route.path][route.http_method] = route
+        end
+        @routes_by_path.freeze
+
+        @routes_by_id = routes.map { |route| [route.id, route] }.to_h.freeze
+      end
+    end
+  end
+end

data/lib/modern/descriptor/info.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "modern/struct"
+
+module Modern
+  module Descriptor
+    class Info < Modern::Struct
+      class Contact < Modern::Struct
+        attribute :name, Types::Strict::String.optional.default(nil)
+        attribute :url, Types::Strict::String.optional.default(nil)
+        attribute :email, Types::Strict::String.optional.default(nil)
+      end
+
+      class License < Modern::Struct
+        attribute :name, Types::Strict::String
+        attribute :url, Types::Strict::String.optional.default(nil)
+      end
+
+      attribute :title, Types::Strict::String
+      attribute :description, Types::Strict::String.optional.default(nil)
+      attribute :terms_of_service, Types::Strict::String.optional.default(nil)
+      attribute :contact, Contact.optional.default(nil)
+      attribute :license, License.optional.default(nil)
+      attribute :version, Types::Strict::String
+    end
+  end
+end