rack-json_schema 1.0.0

data/lib/rack/json_schema/error.rb

@@ -0,0 +1,30 @@
+module Rack
+  module JsonSchema
+    class Error < StandardError
+      # @return [Array] Rack response
+      def to_rack_response
+        [status, headers, [body]]
+      end
+
+      private
+
+      # @note Override this
+      def status
+        500
+      end
+
+      # @note Override this
+      def id
+        "internal_server_error"
+      end
+
+      def headers
+        { "Content-Type" => "application/json" }
+      end
+
+      def body
+        MultiJson.encode({ id: id, message: message }, pretty: true) + "\n"
+      end
+    end
+  end
+end

data/lib/rack/json_schema/error_handler.rb

@@ -0,0 +1,19 @@
+module Rack
+  module JsonSchema
+    class ErrorHandler
+      # Behaves as a rack middleware
+      # @param app [Object] Rack application
+      def initialize(app)
+        @app = app
+      end
+
+      # Behaves as a rack middleware
+      # @param env [Hash] Rack env
+      def call(env)
+        @app.call(env)
+      rescue Rack::JsonSchema::Error => exception
+        exception.to_rack_response
+      end
+    end
+  end
+end

data/lib/rack/json_schema/mock.rb

@@ -0,0 +1,93 @@
+module Rack
+  module JsonSchema
+    class Mock
+      # Behaves as a rack-middleware
+      # @param app [Object] Rack application
+      # @param schema [Hash] Schema object written in JSON schema format
+      # @raise [JsonSchema::SchemaError]
+      def initialize(app, schema: nil)
+        @app = app
+        @schema = Schema.new(schema)
+      end
+
+      # @param env [Hash] Rack env
+      def call(env)
+        RequestHandler.call(app: @app, env: env, schema: @schema)
+      end
+
+      class RequestHandler < BaseRequestHandler
+        # @param app [Object] Rack application
+        def initialize(app: nil, **args)
+          @app = app
+          super(**args)
+        end
+
+        # Returns dummy response if JSON schema is defined for the current link
+        # @return [Array] Rack response
+        def call
+          if has_link_for_current_action?
+            dummy_response
+          else
+            @app.call(@env)
+          end
+        end
+
+        private
+
+        def dummy_response
+          [dummy_status, dummy_headers, [dummy_body]]
+        end
+
+        def dummy_status
+          method == "POST" ? 201 : 200
+        end
+
+        def dummy_headers
+          { "Content-Type" => "application/json" }
+        end
+
+        def dummy_body
+          document = ResponseGenerator.call(schema_for_current_link)
+          document = [document] if has_list_data?
+          MultiJson.encode(document, pretty: true) + "\n"
+        end
+      end
+
+      class ResponseGenerator
+        # Generates example response Hash from given schema
+        # @return [Hash]
+        # @example
+        #   Rack::JsonSchema::Mock::ResponseGenerator(schema) #=> { "id" => 1, "name" => "example" }
+        def self.call(schema)
+          schema.properties.inject({}) do |result, (key, value)|
+            result.merge(
+              key => case
+              when !value.properties.empty?
+                call(value)
+              when !value.data["example"].nil?
+                value.data["example"]
+              when value.type.include?("null")
+                nil
+              else
+                raise ExampleNotFound, "No example found for #{schema.pointer}/#{key}"
+              end
+            )
+          end
+        end
+      end
+
+      class Error < Error
+      end
+
+      class ExampleNotFound < Error
+        def id
+          "example_not_found"
+        end
+
+        def status
+          500
+        end
+      end
+    end
+  end
+end

data/lib/rack/json_schema/request_validation.rb

@@ -0,0 +1,184 @@
+module Rack
+  module JsonSchema
+    class RequestValidation
+      # Behaves as a rack-middleware
+      # @param app [Object] Rack application
+      # @param schema [Hash] Schema object written in JSON schema format
+      # @raise [JsonSchema::SchemaError]
+      def initialize(app, schema: nil)
+        @app = app
+        @schema = Schema.new(schema)
+      end
+
+      # @raise [Rack::JsonSchema::RequestValidation::Error] Raises if given request is invalid to JSON Schema
+      # @param env [Hash] Rack env
+      def call(env)
+        Validator.call(env: env, schema: @schema)
+        @app.call(env)
+      end
+
+      class Validator < BaseRequestHandler
+        # Utility wrapper method
+        def self.call(**args)
+          new(**args).call
+        end
+
+        # @param env [Hash] Rack env
+        # @param schema [JsonSchema::Schema] Schema object
+        def initialize(env: nil, schema: nil)
+          @env = env
+          @schema = schema
+        end
+
+        # Raises an error if any error detected
+        # @raise [Rack::JsonSchema::RequestValidation::Error]
+        def call
+          case
+          when !has_link_for_current_action?
+            raise LinkNotFound
+          when has_body? && !has_valid_content_type?
+            raise InvalidContentType
+          when has_body? && !has_valid_json?
+            raise InvalidJson
+          when has_body? && has_schema? && !has_valid_parameter?
+            raise InvalidParameter, "Invalid request.\n#{schema_validation_error_message}"
+          end
+        end
+
+        private
+
+        def has_valid_json?
+          parameters
+          true
+        rescue MultiJson::ParseError
+          false
+        end
+
+        # @return [true, false] True if request parameters are all valid
+        def has_valid_parameter?
+          schema_validation_result[0]
+        end
+
+        # @return [true, false] True if any schema is defined for the current action
+        def has_schema?
+          !!link.schema
+        end
+
+        # @return [true, false] True if request body is not empty
+        def has_body?
+          !body.empty?
+        end
+
+        # @return [true, false] True if no or matched content type given
+        def has_valid_content_type?
+          mime_type.nil? || Rack::Mime.match?(link.enc_type, mime_type)
+        end
+
+        # @return [Array] A result of schema validation for the current action
+        def schema_validation_result
+          @schema_validation_result ||= link.schema.validate(parameters)
+        end
+
+        # @return [Array] Errors of schema validation
+        def schema_validation_errors
+          schema_validation_result[1]
+        end
+
+        # @return [String] Joined error message to the result of schema validation
+        def schema_validation_error_message
+          ::JsonSchema::SchemaError.aggregate(schema_validation_errors).join("\n")
+        end
+
+        # @return [String, nil] Request MIME Type specified in Content-Type header field
+        # @example
+        #   mime_type #=> "application/json"
+        def mime_type
+          request.content_type.split(";").first if request.content_type
+        end
+
+        # @return [String] request body
+        def body
+          if instance_variable_defined?(:@body)
+            @body
+          else
+            @body = request.body.read
+            request.body.rewind
+            @body
+          end
+        end
+
+        # @return [Hash] Request parameters decoded from JSON
+        # @raise [MultiJson::ParseError]
+        def parameters
+          @parameters ||= begin
+            if has_body?
+              MultiJson.decode(body)
+            else
+              {}
+            end
+          end
+        end
+      end
+
+      # Base error class for Rack::JsonSchema::RequestValidation
+      class Error < Error
+      end
+
+      # Error class for case when no link defined for given request
+      class LinkNotFound < Error
+        def initialize
+          super("Not found")
+        end
+
+        def status
+          404
+        end
+
+        def id
+          "link_not_found"
+        end
+      end
+
+      # Error class for invalid request content type
+      class InvalidContentType < Error
+        def initialize
+          super("Invalid content type")
+        end
+
+        def status
+          400
+        end
+
+        def id
+          "invalid_content_type"
+        end
+      end
+
+      # Error class for invalid JSON
+      class InvalidJson < Error
+        def initialize
+          super("Request body wasn't valid JSON")
+        end
+
+        def status
+          400
+        end
+
+        def id
+          "invalid_json"
+        end
+      end
+
+      # Error class for invalid request parameter
+      class InvalidParameter < Error
+        def status
+          400
+        end
+
+        def id
+          "invalid_parameter"
+        end
+      end
+    end
+  end
+end

data/lib/rack/json_schema/response_validation.rb

@@ -0,0 +1,120 @@
+module Rack
+  module JsonSchema
+    class ResponseValidation
+      # Behaves as a rack-middleware
+      # @param app [Object] Rack application
+      # @param schema [Hash] Schema object written in JSON schema format
+      # @raise [JsonSchema::SchemaError]
+      def initialize(app, schema: nil)
+        @app = app
+        @schema = Schema.new(schema)
+      end
+
+      # @raise [Rack::JsonSchema::ResponseValidation::Error]
+      # @param env [Hash] Rack env
+      def call(env)
+        @app.call(env).tap do |response|
+          Validator.call(env: env, response: response, schema: @schema)
+        end
+      end
+
+      class Validator < BaseRequestHandler
+        # @param env [Hash] Rack env
+        # @param response [Array] Rack response
+        # @param schema [JsonSchema::Schema] Schema object
+        def initialize(env: nil, response: nil, schema: nil)
+          @env = env
+          @response = response
+          @schema = schema
+        end
+
+        # Raises an error if any error detected, skipping validation for non-defined link
+        # @raise [Rack::JsonSchema::ResponseValidation::InvalidResponse]
+        def call
+          if has_link_for_current_action?
+            case
+            when !has_json_content_type?
+              raise InvalidResponseContentType
+            when !valid?
+              raise InvalidResponseType, validator.errors
+            end
+          end
+        end
+
+        # @return [true, false] True if response Content-Type is for JSON
+        def has_json_content_type?
+          %r<\Aapplication/.*json> === headers["Content-Type"]
+        end
+
+        # @return [true, false] True if given data is valid to the JSON schema
+        def valid?
+          validator.validate(example_item)
+        end
+
+        # @return [Hash] Choose an item from response data, to be validated
+        def example_item
+          if has_list_data?
+            data.first
+          else
+            data
+          end
+        end
+
+        # @return [Array, Hash] Response body data, decoded from JSON
+        def data
+          MultiJson.decode(body)
+        end
+
+        # @return [JsonSchema::Validator]
+        # @note The result is memoized for returning errors in invalid case
+        def validator
+          @validator ||= ::JsonSchema::Validator.new(schema_for_current_link)
+        end
+
+        # @return [Hash] Response headers
+        def headers
+          @response[1]
+        end
+
+        # @return [String] Response body
+        def body
+          result = ""
+          @response[2].each {|str| result << str }
+          result
+        end
+      end
+
+      # Base error class for Rack::JsonSchema::ResponseValidation
+      class Error < Error
+      end
+
+      class InvalidResponseType < Error
+        def initialize(errors)
+          super ::JsonSchema::SchemaError.aggregate(errors).join(" ")
+        end
+
+        def id
+          "invalid_response_type"
+        end
+
+        def status
+          500
+        end
+      end
+
+      class InvalidResponseContentType < Error
+        def initialize
+          super("Response Content-Type wasn't for JSON")
+        end
+
+        def id
+          "invalid_response_content_type"
+        end
+
+        def status
+          500
+        end
+      end
+    end
+  end
+end