OpenAPI 3.1

This adds support for the OpenAPI 3.1 schema dialect (`discriminator`
keyword) as well as a schema for validating OpenAPI 3.1 documents.

The dialect is a direct copy of the published schema, similar to the
regular JSON Schema drafts.

`discriminator` is not well defined in the spec and `skip_ref_once!` is
a little janky, but I think this should work and at least it's contained
within that vocab.

The document schema is modeled after the one from this article:
http://json-schema.org/blog/posts/validating-openapi-and-json-schema
with support for all of the existing JSON Schema dialects. There's some
complexity around `jsonSchemaDialect` and `$schema` which is meant to
support validating embedded schemas using the defined (or default)
dialect. It works well for OpenAPI 3.1 and Draft 2020-12 schemas because
they both use `"dynamicAnchor": "meta"`, but earlier drafts will have
trouble with nested schemas that use a different `$schema`. Subschemas
also use `jsonSchemaDialect` instead of inheriting `$schema` from their
parent, so it's probably best to set an explicit `$schema`.

`JSONSchemer.openapi` returns a simple `JSONSchemer::OpenAPI` helper
object with methods for validating the document and for using embedded
schemas to validate data. I'm not sure exactly what will be useful for
people so the API may change in the future.

Author: davishmcclurg

README.md

@@ -1,10 +1,6 @@
 # JSONSchemer
 
-JSON Schema validator. Supports drafts 4, 6, 7, 2019-09, and 2020-12.
-
-## Next
-
-- [ ] openapi
+JSON Schema validator. Supports drafts 4, 6, 7, 2019-09, 2020-12, and OpenAPI 3.1.
 
 ## Installation
 
@@ -123,6 +119,7 @@ JSONSchemer.schema(
   # 'http://json-schema.org/draft-06/schema#': JSONSchemer.draft6
   # 'http://json-schema.org/draft-04/schema#': JSONSchemer.draft4
   # 'http://json-schema.org/schema#': JSONSchemer.draft4
+  # 'https://spec.openapis.org/oas/3.1/dialect/base': JSONSchemer.openapi31
   # default: JSONSchemer.draft202012
   meta_schema: 'https://json-schema.org/draft/2020-12/schema',
 
@@ -171,6 +168,55 @@ JSONSchemer.schema(
 )
 ```
 
+## OpenAPI 3.1
+
+```ruby
+document = JSONSchemer.openapi({
+  'openapi' => '3.1.0',
+  'info' => {
+    'title' => 'example'
+  },
+  'components' => {
+    'schemas' => {
+      'example' => {
+        'type' => 'integer'
+      }
+    }
+  }
+})
+
+# document validation using meta schema
+
+document.valid?
+# => false
+
+document.validate.to_a
+# => [{"data"=>{"title"=>"example"},
+#      "data_pointer"=>"/info",
+#      "schema"=>{...info schema},
+#      "schema_pointer"=>"/$defs/info",
+#      "root_schema"=>{...meta schema},
+#      "type"=>"required",
+#      "details"=>{"missing_keys"=>["version"]}},
+#     ...]
+
+# data validation using schema by name (in `components/schemas`)
+
+document.schema('example').valid?(1)
+# => true
+
+document.schema('example').valid?('one')
+# => false
+
+# data validation using schema by ref
+
+document.ref('#/components/schemas/example').valid?(1)
+# => true
+
+document.ref('#/components/schemas/example').valid?('one')
+# => false
+```
+
 ## CLI
 
 The `json_schemer` executable takes a JSON schema file as the first argument followed by one or more JSON data files to validate. If there are any validation errors, it outputs them and returns an error code.

json_schemer.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["David Harsha"]
   spec.email         = ["[email protected]"]
 
-  spec.summary       = "JSON Schema validator. Supports drafts 4, 6, 7, 2019-09, and 2020-12."
+  spec.summary       = "JSON Schema validator. Supports drafts 4, 6, 7, 2019-09, 2020-12, and OpenAPI 3.1."
   spec.homepage      = "https://github.com/davishmcclurg/json_schemer"
   spec.license       = "MIT"
 

lib/json_schemer.rb

@@ -48,17 +48,24 @@
 require 'json_schemer/draft4/meta'
 require 'json_schemer/draft4/vocab/validation'
 require 'json_schemer/draft4/vocab'
+require 'json_schemer/openapi31/meta'
+require 'json_schemer/openapi31/vocab/base'
+require 'json_schemer/openapi31/vocab'
+require 'json_schemer/openapi31/document'
+require 'json_schemer/openapi'
 require 'json_schemer/schema'
 
 module JSONSchemer
   class UnsupportedMetaSchema < StandardError; end
+  class UnsupportedOpenAPIVersion < StandardError; end
   class UnknownRef < StandardError; end
   class UnknownFormat < StandardError; end
   class UnknownVocabulary < StandardError; end
   class UnknownContentEncoding < StandardError; end
   class UnknownContentMediaType < StandardError; end
   class UnknownOutputFormat < StandardError; end
   class InvalidRefResolution < StandardError; end
+  class InvalidRefPointer < StandardError; end
   class InvalidRegexpResolution < StandardError; end
   class InvalidFileURI < StandardError; end
   class InvalidSymbolKey < StandardError; end
@@ -83,7 +90,9 @@ class InvalidEcmaRegexp < StandardError; end
 
     'json-schemer://draft7' => Draft7::Vocab::ALL,
     'json-schemer://draft6' => Draft6::Vocab::ALL,
-    'json-schemer://draft4' => Draft4::Vocab::ALL
+    'json-schemer://draft4' => Draft4::Vocab::ALL,
+
+    'https://spec.openapis.org/oas/3.1/vocab/base' => OpenAPI31::Vocab::BASE
   }
   VOCABULARY_ORDER = VOCABULARIES.transform_values.with_index { |_vocabulary, index| index }
 
@@ -171,6 +180,35 @@ def draft4
         :regexp_resolver => 'ecma'
       )
     end
+
+    def openapi31
+      @openapi31 ||= Schema.new(
+        OpenAPI31::SCHEMA,
+        :base_uri => OpenAPI31::BASE_URI,
+        :ref_resolver => OpenAPI31::Meta::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma',
+        # https://spec.openapis.org/oas/latest.html#data-types
+        :formats => {
+          'int32' => proc { |instance, _value| instance.is_a?(Integer) && instance.bit_length <= 32 },
+          'int64' => proc { |instance, _value| instance.is_a?(Integer) && instance.bit_length <= 64 },
+          'float' => proc { |instance, _value| instance.is_a?(Float) },
+          'double' => proc { |instance, _value| instance.is_a?(Float) },
+          'password' => proc { |_instance, _value| true }
+        }
+      )
+    end
+
+    def openapi31_document
+      @openapi31_document ||= Schema.new(
+        OpenAPI31::Document::SCHEMA_BASE,
+        :ref_resolver => OpenAPI31::Document::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
+
+    def openapi(document, **options)
+      OpenAPI.new(document, **options)
+    end
   end
 
   META_SCHEMA_CALLABLES_BY_BASE_URI_STR = {
@@ -180,7 +218,8 @@ def draft4
     Draft6::BASE_URI.to_s => method(:draft6),
     Draft4::BASE_URI.to_s => method(:draft4),
     # version-less $schema deprecated after Draft 4
-    'http://json-schema.org/schema#' => method(:draft4)
+    'http://json-schema.org/schema#' => method(:draft4),
+    OpenAPI31::BASE_URI.to_s => method(:openapi31)
   }.freeze
 
   META_SCHEMAS_BY_BASE_URI_STR = Hash.new do |hash, base_uri_str|

lib/json_schemer/draft202012/vocab/core.rb

@@ -116,8 +116,28 @@ def parse
         class Comment < Keyword; end
 
         class UnknownKeyword < Keyword
-          def schema!
-            subschema(value)
+          def parse
+            if value.is_a?(Hash)
+              {}
+            elsif value.is_a?(Array)
+              []
+            else
+              value
+            end
+          end
+
+          def fetch_unknown!(token)
+            if value.is_a?(Hash)
+              parsed[token] ||= JSONSchemer::Schema::UNKNOWN_KEYWORD_CLASS.new(value.fetch(token), self, token, schema)
+            elsif value.is_a?(Array)
+              parsed[token.to_i] ||= JSONSchemer::Schema::UNKNOWN_KEYWORD_CLASS.new(value.fetch(token.to_i), self, token, schema)
+            else
+              raise KeyError.new(:receiver => parsed, :key => token)
+            end
+          end
+
+          def unknown_schema!
+            @unknown_schema ||= subschema(value)
           end
 
           def validate(instance, instance_location, keyword_location, _context)

lib/json_schemer/draft202012/vocab/format_annotation.rb

@@ -13,7 +13,7 @@ class Format < Keyword
           end
 
           def parse
-            root.format && root.formats.fetch(value, DEFAULT_FORMAT)
+            root.format && root.formats.fetch(value) { root.meta_schema.formats.fetch(value, DEFAULT_FORMAT) }
           end
 
           def validate(instance, instance_location, keyword_location, _context)

lib/json_schemer/draft202012/vocab/format_assertion.rb

@@ -11,7 +11,7 @@ class Format < Keyword
           end
 
           def parse
-            root.format && root.formats.fetch(value, DEFAULT_FORMAT)
+            root.format && root.formats.fetch(value) { root.meta_schema.formats.fetch(value, DEFAULT_FORMAT) }
           end
 
           def validate(instance, instance_location, keyword_location, _context)

lib/json_schemer/keyword.rb

@@ -5,12 +5,12 @@ class Keyword
 
     attr_reader :value, :parent, :root, :parsed
 
-    def initialize(value, parent, keyword)
+    def initialize(value, parent, keyword, schema = parent)
       @value = value
       @parent = parent
       @root = parent.root
       @keyword = keyword
-      @schema = parent
+      @schema = schema
       @parsed = parse
     end
 
@@ -33,8 +33,8 @@ def parse
     end
 
     def subschema(value, keyword = nil, **options)
-      options[:base_uri] ||= parent.base_uri
-      options[:meta_schema] ||= parent.meta_schema
+      options[:base_uri] ||= schema.base_uri
+      options[:meta_schema] ||= schema.meta_schema
       Schema.new(value, self, root, keyword, **options)
     end
   end

lib/json_schemer/openapi.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module JSONSchemer
+  class OpenAPI
+    def initialize(document, **options)
+      @document = document
+
+      version = document['openapi']
+      @document_schema ||= case version
+      when /\A3\.1\.\d+\z/
+        JSONSchemer.openapi31_document
+      else
+        raise UnsupportedOpenAPIVersion, version
+      end
+
+      json_schema_dialect = document.fetch('jsonSchemaDialect') { OpenAPI31::BASE_URI.to_s }
+      meta_schema = META_SCHEMAS_BY_BASE_URI_STR[json_schema_dialect] || raise(UnsupportedMetaSchema, json_schema_dialect)
+
+      @schema = JSONSchemer.schema(@document, :meta_schema => meta_schema, **options)
+    end
+
+    def valid?
+      @document_schema.valid?(@document)
+    end
+
+    def validate(**options)
+      @document_schema.validate(@document, **options)
+    end
+
+    def ref(value)
+      @schema.resolve_ref(URI.join(@schema.base_uri, value))
+    end
+
+    def schema(name)
+      ref("#/components/schemas/#{name}")
+    end
+  end
+end