openapi_parser_firetail 1.0.0

data/lib/openapi_parser/schema_validator/base.rb

@@ -0,0 +1,39 @@
+class OpenAPIParser::SchemaValidator
+  class Base
+    def initialize(validatable, coerce_value)
+      @validatable = validatable
+      @coerce_value = coerce_value
+    end
+
+    attr_reader :validatable
+
+    # need override
+    def coerce_and_validate(_value, _schema, **_keyword_args)
+      raise 'need implement'
+    end
+
+    def validate_discriminator_schema(discriminator, value, parent_discriminator_schemas: [])
+      property_name = discriminator.property_name
+      if property_name.nil? || !value.key?(property_name)
+        return [nil, OpenAPIParser::NotExistDiscriminatorPropertyName.new(discriminator.property_name, value, discriminator.object_reference)]
+      end
+      mapping_key = value[property_name]
+
+      # it's allowed to have discriminator without mapping, then we need to lookup discriminator.property_name
+      # but the format is not the full path, just model name in the components
+      mapping_target = discriminator.mapping&.[](mapping_key) || "#/components/schemas/#{mapping_key}"
+
+      # Find object does O(n) search at worst, then caches the result, so this is ok for repeated search
+      resolved_schema = discriminator.root.find_object(mapping_target)
+
+      unless resolved_schema
+        return [nil, OpenAPIParser::NotExistDiscriminatorMappedSchema.new(mapping_target, discriminator.object_reference)]
+      end
+      validatable.validate_schema(
+        value,
+        resolved_schema,
+        **{discriminator_property_name: discriminator.property_name, parent_discriminator_schemas: parent_discriminator_schemas}
+      )
+    end
+  end
+end

data/lib/openapi_parser/schema_validator/boolean_validator.rb

@@ -0,0 +1,29 @@
+class OpenAPIParser::SchemaValidator
+  class BooleanValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+
+    TRUE_VALUES = ['true', '1'].freeze
+    FALSE_VALUES = ['false', '0'].freeze
+
+    def coerce_and_validate(value, schema, **_keyword_args)
+      value = coerce(value) if @coerce_value
+
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(TrueClass) || value.kind_of?(FalseClass)
+
+      value, err = check_enum_include(value, schema)
+      return [nil, err] if err
+
+      [value, nil]
+    end
+
+    private
+
+      def coerce(value)
+        return true if TRUE_VALUES.include?(value)
+
+        return false if FALSE_VALUES.include?(value)
+
+        value
+      end
+  end
+end

data/lib/openapi_parser/schema_validator/enumable.rb

@@ -0,0 +1,13 @@
+class OpenAPIParser::SchemaValidator
+  module Enumable
+    # check enum value by schema
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def check_enum_include(value, schema)
+      return [value, nil] unless schema.enum
+      return [value, nil] if schema.enum.include?(value)
+
+      [nil, OpenAPIParser::NotEnumInclude.new(value, schema.object_reference)]
+    end
+  end
+end

data/lib/openapi_parser/schema_validator/float_validator.rb

@@ -0,0 +1,34 @@
+class OpenAPIParser::SchemaValidator
+  class FloatValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+    include ::OpenAPIParser::SchemaValidator::MinimumMaximum
+
+    # validate float value by schema
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema, **_keyword_args)
+      value = coerce(value) if @coerce_value
+
+      return validatable.validate_integer(value, schema) if value.kind_of?(Integer)
+
+      coercer_and_validate_numeric(value, schema)
+    end
+
+    private
+
+      def coercer_and_validate_numeric(value, schema)
+        return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Numeric)
+
+        value, err = check_enum_include(value, schema)
+        return [nil, err] if err
+
+        check_minimum_maximum(value, schema)
+      end
+
+      def coerce(value)
+        Float(value)
+      rescue ArgumentError, TypeError
+        value
+      end
+  end
+end

data/lib/openapi_parser/schema_validator/integer_validator.rb

@@ -0,0 +1,32 @@
+class OpenAPIParser::SchemaValidator
+  class IntegerValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+    include ::OpenAPIParser::SchemaValidator::MinimumMaximum
+
+    # validate integer value by schema
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema, **_keyword_args)
+      value = coerce(value) if @coerce_value
+
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Integer)
+
+      value, err = check_enum_include(value, schema)
+      return [nil, err] if err
+
+      check_minimum_maximum(value, schema)
+    end
+
+    private
+
+      def coerce(value)
+        return value if value.kind_of?(Integer)
+
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          value
+        end
+      end
+  end
+end

data/lib/openapi_parser/schema_validator/minimum_maximum.rb

@@ -0,0 +1,38 @@
+class OpenAPIParser::SchemaValidator
+  module MinimumMaximum
+    # check minimum and maximum value by schema
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def check_minimum_maximum(value, schema)
+      include_min_max = schema.minimum || schema.maximum
+      return [value, nil] unless include_min_max
+
+      validate(value, schema)
+      [value, nil]
+    rescue OpenAPIParser::OpenAPIError => e
+      return [nil, e]
+    end
+
+    private
+
+      def validate(value, schema)
+        reference = schema.object_reference
+
+        if schema.minimum
+          if schema.exclusiveMinimum && value <= schema.minimum
+            raise OpenAPIParser::LessThanExclusiveMinimum.new(value, reference)
+          elsif value < schema.minimum
+            raise OpenAPIParser::LessThanMinimum.new(value, reference)
+          end
+        end
+
+        if schema.maximum
+          if schema.exclusiveMaximum && value >= schema.maximum
+            raise OpenAPIParser::MoreThanExclusiveMaximum.new(value, reference)
+          elsif value > schema.maximum
+            raise OpenAPIParser::MoreThanMaximum.new(value, reference)
+          end
+        end
+      end
+  end
+end

data/lib/openapi_parser/schema_validator/nil_validator.rb

@@ -0,0 +1,11 @@
+class OpenAPIParser::SchemaValidator
+  class NilValidator < Base
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema, **_keyword_args)
+      return [value, nil] if schema.nullable
+
+      [nil, OpenAPIParser::NotNullError.new(schema.object_reference)]
+    end
+  end
+end

data/lib/openapi_parser/schema_validator/object_validator.rb

@@ -0,0 +1,56 @@
+class OpenAPIParser::SchemaValidator
+  class ObjectValidator < Base
+    # @param [Hash] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    # @param [Boolean] parent_all_of true if component is nested under allOf
+    # @param [String, nil] discriminator_property_name discriminator.property_name to ignore checking additional_properties
+    def coerce_and_validate(value, schema, parent_all_of: false, parent_discriminator_schemas: [], discriminator_property_name: nil)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Hash)
+
+      properties = schema.properties || {}
+
+      required_set = schema.required ? schema.required.to_set : Set.new
+      remaining_keys = value.keys
+
+      if schema.discriminator && !parent_discriminator_schemas.include?(schema)
+        return validate_discriminator_schema(
+          schema.discriminator,
+          value,
+          parent_discriminator_schemas: parent_discriminator_schemas + [schema]
+        )
+      else
+        remaining_keys.delete('discriminator')
+      end
+
+      coerced_values = value.map do |name, v|
+        s = properties[name]
+        coerced, err = if s
+                         remaining_keys.delete(name)
+                         validatable.validate_schema(v, s)
+                       else
+                         # TODO: we need to perform a validation based on schema.additional_properties here, if
+                         # additionalProperties are defined
+                         [v, nil]
+                       end
+
+        return [nil, err] if err
+
+        required_set.delete(name)
+        [name, coerced]
+      end
+
+      remaining_keys.delete(discriminator_property_name) if discriminator_property_name
+
+      if !remaining_keys.empty? && !parent_all_of && !schema.additional_properties
+        # If object is nested in all of, the validation is already done in allOf validator. Or if
+        # additionalProperties are defined, we will validate using that
+        return [nil, OpenAPIParser::NotExistPropertyDefinition.new(remaining_keys, schema.object_reference)]
+      end
+      return [nil, OpenAPIParser::NotExistRequiredKey.new(required_set.to_a, schema.object_reference)] unless required_set.empty?
+
+      value.merge!(coerced_values.to_h) if @coerce_value
+
+      [value, nil]
+    end
+  end
+end

data/lib/openapi_parser/schema_validator/one_of_validator.rb

@@ -0,0 +1,22 @@
+class OpenAPIParser::SchemaValidator
+  class OneOfValidator < Base
+    # @param [Object] value
+    # @param [OpenAPIParser::Schemas::Schema] schema
+    def coerce_and_validate(value, schema, **_keyword_args)
+      if schema.discriminator
+        return validate_discriminator_schema(schema.discriminator, value)
+      end
+
+      # if multiple schemas are satisfied, it's not valid
+      result = schema.one_of.one? do |s|
+        _coerced, err = validatable.validate_schema(value, s)
+        err.nil?
+      end
+      if result
+        [value, nil]
+      else
+        [nil, OpenAPIParser::NotOneOf.new(value, schema.object_reference)]
+      end
+    end
+  end
+end

data/lib/openapi_parser/schema_validator/options.rb

@@ -0,0 +1,29 @@
+class OpenAPIParser::SchemaValidator
+  class Options
+    # @!attribute [r] coerce_value
+    #   @return [Boolean] coerce value option on/off
+    # @!attribute [r] datetime_coerce_class
+    #   @return [Object, nil] coerce datetime string by this Object class
+    # @!attribute [r] validate_header
+    #   @return [Boolean] validate header or not
+    attr_reader :coerce_value, :datetime_coerce_class, :validate_header
+
+    def initialize(coerce_value: nil, datetime_coerce_class: nil, validate_header: true)
+      @coerce_value = coerce_value
+      @datetime_coerce_class = datetime_coerce_class
+      @validate_header = validate_header
+    end
+  end
+
+  # response body validation option
+  class ResponseValidateOptions
+    # @!attribute [r] strict
+    #   @return [Boolean] validate by strict (when not exist definition, raise error)
+    attr_reader :strict, :validate_header
+
+    def initialize(strict: false, validate_header: true)
+      @strict = strict
+      @validate_header = validate_header
+    end
+  end
+end

data/lib/openapi_parser/schema_validator/string_validator.rb

@@ -0,0 +1,108 @@
+class OpenAPIParser::SchemaValidator
+  class StringValidator < Base
+    include ::OpenAPIParser::SchemaValidator::Enumable
+
+    def initialize(validator, coerce_value, datetime_coerce_class)
+      super(validator, coerce_value)
+      @datetime_coerce_class = datetime_coerce_class
+    end
+
+    def coerce_and_validate(value, schema, **_keyword_args)
+      return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(String)
+
+      value, err = check_enum_include(value, schema)
+      return [nil, err] if err
+
+      value, err = pattern_validate(value, schema)
+      return [nil, err] if err
+
+      value, err = validate_max_min_length(value, schema)
+      return [nil, err] if err
+
+      value, err = validate_email_format(value, schema)
+      return [nil, err] if err
+
+      value, err = validate_uuid_format(value, schema)
+      return [nil, err] if err
+
+      value, err = validate_date_format(value, schema)
+      return [nil, err] if err
+
+      value, err = validate_datetime_format(value, schema)
+      return [nil, err] if err
+
+      [value, nil]
+    end
+
+    private
+
+      # @param [OpenAPIParser::Schemas::Schema] schema
+      def pattern_validate(value, schema)
+        # pattern support string only so put this
+        return [value, nil] unless schema.pattern
+        return [value, nil] if value =~ /#{schema.pattern}/
+
+        [nil, OpenAPIParser::InvalidPattern.new(value, schema.pattern, schema.object_reference, schema.example)]
+      end
+
+      def validate_max_min_length(value, schema)
+        return [nil, OpenAPIParser::MoreThanMaxLength.new(value, schema.object_reference)] if schema.maxLength && value.size > schema.maxLength
+        return [nil, OpenAPIParser::LessThanMinLength.new(value, schema.object_reference)] if schema.minLength && value.size < schema.minLength
+
+        [value, nil]
+      end
+
+      def validate_email_format(value, schema)
+        return [value, nil] unless schema.format == 'email'
+
+        # match? method is good performance.
+        # So when we drop ruby 2.3 support we use match? method because this method add ruby 2.4
+        #return [value, nil] if value.match?(URI::MailTo::EMAIL_REGEXP)
+        return [value, nil] if value.match(URI::MailTo::EMAIL_REGEXP)
+
+        return [nil, OpenAPIParser::InvalidEmailFormat.new(value, schema.object_reference)]
+      end
+
+      def validate_uuid_format(value, schema)
+        return [value, nil] unless schema.format == 'uuid'
+
+        return [value, nil] if value.match(/[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/)
+
+        return [nil, OpenAPIParser::InvalidUUIDFormat.new(value, schema.object_reference)]
+      end
+
+      def validate_date_format(value, schema)
+        return [value, nil] unless schema.format == 'date'
+
+        begin
+          Date.strptime(value, "%Y-%m-%d")
+        rescue ArgumentError
+          return [nil, OpenAPIParser::InvalidDateFormat.new(value, schema.object_reference)]
+        end
+
+        return [value, nil]
+      end
+
+      def validate_datetime_format(value, schema)
+        return [value, nil] unless schema.format == 'date-time'
+
+        begin
+          if @datetime_coerce_class.nil?
+            # validate only
+            DateTime.rfc3339(value)
+            [value, nil]
+          else
+            # validate and coerce
+            if @datetime_coerce_class == Time
+              [DateTime.rfc3339(value).to_time, nil]
+            else
+              [@datetime_coerce_class.rfc3339(value), nil]
+            end
+          end
+        rescue ArgumentError
+          # when rfc3339(value) failed
+          [nil, OpenAPIParser::InvalidDateTimeFormat.new(value, schema.object_reference)]
+        end
+      end
+  end
+end

data/lib/openapi_parser/schema_validator/unspecified_type_validator.rb

@@ -0,0 +1,8 @@
+class OpenAPIParser::SchemaValidator
+  class UnspecifiedTypeValidator < Base
+    # @param [Object] value
+    def coerce_and_validate(value, _schema, **_keyword_args)
+      [value, nil]
+    end
+  end
+end

data/lib/openapi_parser/schema_validator.rb

@@ -0,0 +1,164 @@
+require_relative 'schema_validator/options'
+require_relative 'schema_validator/enumable'
+require_relative 'schema_validator/minimum_maximum'
+require_relative 'schema_validator/base'
+require_relative 'schema_validator/string_validator'
+require_relative 'schema_validator/integer_validator'
+require_relative 'schema_validator/float_validator'
+require_relative 'schema_validator/boolean_validator'
+require_relative 'schema_validator/object_validator'
+require_relative 'schema_validator/array_validator'
+require_relative 'schema_validator/any_of_validator'
+require_relative 'schema_validator/all_of_validator'
+require_relative 'schema_validator/one_of_validator'
+require_relative 'schema_validator/nil_validator'
+require_relative 'schema_validator/unspecified_type_validator'
+
+class OpenAPIParser::SchemaValidator
+  # validate value by schema
+  # this module for SchemaValidators::Base
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  module Validatable
+    def validate_schema(value, schema, **keyword_args)
+      raise 'implement'
+    end
+
+    # validate integer value by schema
+    # this method use from float_validator because number allow float and integer
+    # @param [Object] _value
+    # @param [OpenAPIParser::Schemas::Schema] _schema
+    def validate_integer(_value, _schema)
+      raise 'implement'
+    end
+  end
+
+  include Validatable
+
+  class << self
+    # validate schema data
+    # @param [Hash] value
+    # @param [OpenAPIParser::Schemas:v:Schema]
+    # @param [OpenAPIParser::SchemaValidator::Options] options
+    # @return [Object] coerced or original params
+    def validate(value, schema, options)
+      new(value, schema, options).validate_data
+    end
+  end
+
+  # @param [Hash] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  # @param [OpenAPIParser::SchemaValidator::Options] options
+  def initialize(value, schema, options)
+    @value = value
+    @schema = schema
+    @coerce_value = options.coerce_value
+    @datetime_coerce_class = options.datetime_coerce_class
+  end
+
+  # execute validate data
+  # @return [Object] coerced or original params
+  def validate_data
+    coerced, err = validate_schema(@value, @schema)
+    raise err if err
+
+    coerced
+  end
+
+  # validate value eby schema
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_schema(value, schema, **keyword_args)
+    return [value, nil] unless schema
+
+    if (v = validator(value, schema))
+      if keyword_args.empty?
+        return v.coerce_and_validate(value, schema)
+      else
+        return v.coerce_and_validate(value, schema, **keyword_args)
+      end
+    end
+
+    # unknown return error
+    OpenAPIParser::ValidateError.build_error_result(value, schema)
+  end
+
+  # validate integer value by schema
+  # this method use from float_validator because number allow float and integer
+  # @param [Object] value
+  # @param [OpenAPIParser::Schemas::Schema] schema
+  def validate_integer(value, schema)
+    integer_validator.coerce_and_validate(value, schema)
+  end
+
+  private
+
+    # @return [OpenAPIParser::SchemaValidator::Base, nil]
+    def validator(value, schema)
+      return any_of_validator if schema.any_of
+      return all_of_validator if schema.all_of
+      return one_of_validator if schema.one_of
+      return nil_validator if value.nil?
+
+      case schema.type
+      when 'string'
+        string_validator
+      when 'integer'
+        integer_validator
+      when 'boolean'
+        boolean_validator
+      when 'number'
+        float_validator
+      when 'object'
+        object_validator
+      when 'array'
+        array_validator
+      else
+        unspecified_type_validator
+      end
+    end
+
+    def string_validator
+      @string_validator ||= OpenAPIParser::SchemaValidator::StringValidator.new(self, @coerce_value, @datetime_coerce_class)
+    end
+
+    def integer_validator
+      @integer_validator ||= OpenAPIParser::SchemaValidator::IntegerValidator.new(self, @coerce_value)
+    end
+
+    def float_validator
+      @float_validator ||= OpenAPIParser::SchemaValidator::FloatValidator.new(self, @coerce_value)
+    end
+
+    def boolean_validator
+      @boolean_validator ||= OpenAPIParser::SchemaValidator::BooleanValidator.new(self, @coerce_value)
+    end
+
+    def object_validator
+      @object_validator ||= OpenAPIParser::SchemaValidator::ObjectValidator.new(self, @coerce_value)
+    end
+
+    def array_validator
+      @array_validator ||= OpenAPIParser::SchemaValidator::ArrayValidator.new(self, @coerce_value)
+    end
+
+    def any_of_validator
+      @any_of_validator ||= OpenAPIParser::SchemaValidator::AnyOfValidator.new(self, @coerce_value)
+    end
+
+    def all_of_validator
+      @all_of_validator ||= OpenAPIParser::SchemaValidator::AllOfValidator.new(self, @coerce_value)
+    end
+
+    def one_of_validator
+      @one_of_validator ||= OpenAPIParser::SchemaValidator::OneOfValidator.new(self, @coerce_value)
+    end
+
+    def nil_validator
+      @nil_validator ||= OpenAPIParser::SchemaValidator::NilValidator.new(self, @coerce_value)
+    end
+
+    def unspecified_type_validator
+      @unspecified_type_validator ||= OpenAPIParser::SchemaValidator::UnspecifiedTypeValidator.new(self, @coerce_value)
+    end
+end

data/lib/openapi_parser/schemas/base.rb

@@ -0,0 +1,28 @@
+module OpenAPIParser::Schemas
+  class Base
+    include OpenAPIParser::Parser
+    include OpenAPIParser::Findable
+    include OpenAPIParser::Expandable
+
+    attr_reader :parent, :raw_schema, :object_reference, :root
+
+    # @param [OpenAPIParser::Schemas::Base]
+    def initialize(object_reference, parent, root, raw_schema)
+      @raw_schema = raw_schema
+      @parent = parent
+      @root = root
+      @object_reference = object_reference
+
+      load_data
+      after_init
+    end
+
+    # override
+    def after_init
+    end
+
+    def inspect
+      @object_reference
+    end
+  end
+end

data/lib/openapi_parser/schemas/classes.rb

@@ -0,0 +1,22 @@
+# We want to use class name for DSL in class definition so we should define first...
+
+module OpenAPIParser::Schemas
+  class Base; end
+  class Discriminator < Base; end
+  class OpenAPI < Base; end
+  class Operation < Base; end
+  class Parameter < Base; end
+  class PathItem < Base; end
+  class Paths < Base; end
+  class Reference < Base; end
+  class RequestBody < Base; end
+  class Responses < Base; end
+  class Response < Base; end
+  class MediaType < Base; end
+  class Schema < Base; end
+  class Components < Base; end
+  class Header < Base; end
+  class SecuritySchemes < Base; end
+  class Info < Base; end
+  class Security < Base; end
+end

data/lib/openapi_parser/schemas/components.rb

@@ -0,0 +1,32 @@
+# TODO: examples
+# TODO: securitySchemes
+# TODO: links
+# TODO: callbacks
+
+module OpenAPIParser::Schemas
+  class Components < Base
+    # @!attribute [r] parameters
+    #   @return [Hash{String => Parameter}, nil]
+    openapi_attr_hash_object :parameters, Parameter, reference: true
+
+    # @!attribute [r] parameters
+    #   @return [Hash{String => Parameter}, nil]
+    openapi_attr_hash_object :schemas, Schema, reference: true
+
+    # @!attribute [r] responses
+    #   @return [Hash{String => Response}, nil]
+    openapi_attr_hash_object :responses, Response, reference: true
+
+    # @!attribute [r] request_bodies
+    #   @return [Hash{String => RequestBody}, nil]
+    openapi_attr_hash_object :request_bodies, RequestBody, reference: true, schema_key: :requestBodies
+
+    # @!attribute [r] headers
+    #   @return [Hash{String => Header}, nil] header objects
+    openapi_attr_hash_object :headers, Header, reference: true
+
+    # @!attribute [r] security_schemes
+    #   @return [Hash{String => Header}, nil]
+    openapi_attr_hash_object :security_schemes, SecuritySchemes, reference: true, schema_key: :securitySchemes
+  end
+end