skooma 0.1.0

data/lib/skooma/objects/media_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # https://spec.openapis.org/oas/v3.1.0#media-type-object
+    class MediaType < Base
+      def kw_classes
+        [
+          Keywords::OAS31::Schema
+        ]
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/components.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        class Components < JSONSkooma::Keywords::Base
+          self.key = "components"
+          self.value_schema = :schema
+          self.schema_value_class = Objects::Components
+
+          def each_schema(&block)
+            return super unless json.type == "object"
+
+            json.each_value do |s|
+              s.each_value(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/info.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        class Info < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "info"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/json_schema_dialect.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        class JSONSchemaDialect < JSONSkooma::Keywords::Base
+          self.key = "jsonSchemaDialect"
+          self.static = true
+
+          def initialize(parent_schema, value)
+            super
+
+            uri = URI.parse(value)
+            parent_schema.json_schema_dialect_uri = uri
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/openapi.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        class OpenAPI < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "openapi"
+
+          def initialize(parent_schema, value)
+            unless value.to_s.start_with? "3.1."
+              raise Error, "Only OpenAPI version 3.1.x is supported, got #{value}"
+            end
+
+            parent_schema.metaschema_uri = "https://spec.openapis.org/oas/3.1/schema-base/2022-10-07"
+            parent_schema.json_schema_dialect_uri = "https://spec.openapis.org/oas/3.1/dialect/base"
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/paths.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        class Paths < JSONSkooma::Keywords::Base
+          self.key = "paths"
+          self.value_schema = :object_of_schemas
+          self.schema_value_class = Objects::PathItem
+
+          ROUTE_REGEXP = /\{([^}]+)}/.freeze
+
+          def initialize(parent_schema, value)
+            super
+            @regexp_map = json.filter_map do |path, subschema|
+              next unless path.include?("{") && path.include?("}")
+
+              path_regex = path.gsub(ROUTE_REGEXP, "(?<\\1>[^/?#]+)")
+              path_regex = Regexp.new("\\A#{path_regex}\\z")
+
+              [path, path_regex, subschema]
+            end
+          end
+
+          def evaluate(instance, result)
+            path, attributes, path_schema = find_route(instance["path"])
+
+            return result.failure("Path #{instance["path"]} not found in schema") unless path
+
+            result.call(instance, path) do |subresult|
+              subresult.annotate({"path_attributes" => attributes})
+              path_schema.evaluate(instance, subresult)
+
+              if subresult.passed?
+                result.success
+              else
+                result.failure("Path #{instance["path"]} is invalid")
+              end
+            end
+          end
+
+          private
+
+          def find_route(instance_path)
+            return [instance_path, {}, json[instance_path]] if json.key?(instance_path)
+
+            @regexp_map.reduce(nil) do |result, (path, path_regex, subschema)|
+              next result unless path.include?("{") && path.include?("}")
+
+              match = instance_path.match(path_regex)
+              next result if match.nil?
+              next result if result && result[1].length <= match.named_captures.length
+
+              [path, match.named_captures, subschema]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/security.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        class Security < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "security"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi/keywords/webhooks.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class OpenAPI
+      module Keywords
+        # Map[string, Path Item Object | Reference Object] ]
+        # example: https://github.com/OAI/OpenAPI-Specification/blob/main/examples/v3.1/webhook-example.yaml
+        class Webhooks < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "webhooks"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/openapi.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # OpenAPI Object – the root object of the OpenAPI document.
+    # https://spec.openapis.org/oas/v3.1.0#openapi-object
+    class OpenAPI < Base
+      attr_writer :json_schema_dialect_uri
+
+      def kw_classes
+        [
+          Keywords::Info,
+          Keywords::JSONSchemaDialect,
+          Keywords::Paths,
+          Keywords::Webhooks,
+          Keywords::Components,
+          Base::Keywords::Servers,
+          Base::Keywords::Security,
+          Base::Keywords::Tags,
+          Skooma::Keywords::OAS31::Dialect::ExternalDocs
+        ]
+      end
+
+      def bootstrap(value)
+        # always evaluate openapi to check version,
+        # and set metaschema_uri and json_schema_dialect_uri
+        add_keyword(Keywords::OpenAPI.new(self, value["openapi"]))
+      end
+
+      def evaluate(instance, result = nil)
+        super(Instance.new(instance), result)
+      end
+
+      def json_schema_dialect_uri
+        @json_schema_dialect_uri || parent_schema&.json_schema_dialect_uri
+      end
+    end
+  end
+end

data/lib/skooma/objects/operation/keywords/callbacks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Operation
+      module Keywords
+        class Callbacks < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "callbacks"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/operation/keywords/operation_id.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Operation
+      module Keywords
+        class OperationId < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "operationId"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/operation/keywords/parameters.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Operation
+      module Keywords
+        class Parameters < JSONSkooma::Keywords::Base
+          self.key = "parameters"
+          self.value_schema = :array_of_schemas
+          self.schema_value_class = Objects::Parameter
+
+          def initialize(parent_schema, value)
+            super
+            keys = json.filter_map { |v| v["in"] && [v["in"].value, v["name"].value] }
+            parent_params = (parent_schema.parent["parameters"] || [])
+            parent_params.reject! do |v|
+              v["in"] && keys.include?([v["in"].value, v["name"].value])
+            end
+            @parent_params = parent_params
+          end
+
+          def evaluate(instance, result)
+            return result.discard unless instance.key?("request")
+            return result.discard if json&.value&.empty? && @parent_params.empty?
+
+            errors = []
+            process_parameter(json, instance, result) do |subresult|
+              errors << [subresult.schema_node["in"], subresult.schema_node["name"]] unless subresult.passed?
+            end
+            process_parameter(@parent_params, instance, result.parent.sibling(instance, "parameters")) do |subresult|
+              key = [subresult.schema_node["in"], subresult.schema_node["name"]]
+              errors << key unless subresult.passed?
+            end
+            return if errors.empty?
+
+            result.failure("The following parameters are invalid: #{errors}")
+          end
+
+          private
+
+          def process_parameter(v, instance, result)
+            v.each.with_index do |param, index|
+              result.call(instance["request"], index.to_s) do |subresult|
+                param.evaluate(instance["request"], subresult)
+                yield subresult
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/operation/keywords/request_body.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Operation
+      module Keywords
+        class RequestBody < JSONSkooma::Keywords::Base
+          self.key = "requestBody"
+          self.value_schema = :schema
+          self.schema_value_class = Objects::RequestBody
+
+          def evaluate(instance, result)
+            return result.discard unless instance.key?("request")
+
+            json.evaluate(instance["request"], result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/operation/keywords/responses.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Operation
+      module Keywords
+        class Responses < JSONSkooma::Keywords::Base
+          self.key = "responses"
+          self.value_schema = :object_of_schemas
+          self.schema_value_class = Objects::Response
+
+          def evaluate(instance, result)
+            response = instance["response"] || {}
+            return result.discard unless response["status"]
+
+            status = find_status(response)
+
+            return result.failure("Status #{response["status"]} not found for #{instance["method"].upcase} #{instance["path"]}") unless status
+
+            result.annotate(status)
+            result.call(response["status"], status) do |status_result|
+              json[status].evaluate(response, status_result)
+
+              if status_result.passed?
+                result.annotate(status)
+              else
+                result.failure("Res #{response["status"]} is invalid")
+              end
+            end
+          end
+
+          private
+
+          def find_status(response)
+            response_status = response["status"].to_s
+            if json.key?(response_status)
+              response_status
+            elsif json.key?("#{response_status[0]}XX")
+              "#{response_status[0]}XX"
+            elsif json.key?("default")
+              "default"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/operation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # Describes a single API operation on a path.
+    # https://spec.openapis.org/oas/v3.1.0#operation-object
+    class Operation < Base
+      def kw_classes
+        [
+          Base::Keywords::Tags,
+          Base::Keywords::Summary,
+          Base::Keywords::Description,
+          Skooma::Keywords::OAS31::Dialect::ExternalDocs,
+          Keywords::OperationId,
+          Keywords::Parameters,
+          Keywords::RequestBody,
+          Keywords::Responses,
+          Keywords::Callbacks,
+          Base::Keywords::Deprecated,
+          Base::Keywords::Security,
+          Base::Keywords::Servers
+        ]
+      end
+
+      def bootstrap(value)
+        # always evaluate parameters to check parent parameters
+        add_keyword(Keywords::Parameters.new(self, value["parameters"] || []))
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/allow_empty_value.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class AllowEmptyValue < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "allowEmptyValue"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/allow_reserved.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class AllowReserved < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "allowReserved"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/content.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class Content < Header::Keywords::Content
+          self.key = "content"
+          self.value_schema = :object_of_schemas
+          self.schema_value_class = Objects::MediaType
+
+          def evaluate(instance, result)
+            return if instance.value.nil?
+
+            super(ValueParser.call(instance, result), result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/in.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class In < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "in"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/name.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class Name < JSONSkooma::Keywords::BaseAnnotation
+          self.key = "name"
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/required.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class Required < JSONSkooma::Keywords::Base
+          self.key = "required"
+
+          def evaluate(instance, result)
+            if json.value && ValueParser.call(instance, result)&.value.nil?
+              result.failure("Parameter is required")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        class Schema < Skooma::Keywords::OAS31::Schema
+          self.key = "schema"
+          self.depends_on = %w[in name style explode allowReserved allowEmptyValue]
+
+          def evaluate(instance, result)
+            value = ValueParser.call(instance, result)
+            return result.discard if value.nil?
+
+            super(value, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter/keywords/value_parser.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Skooma
+  module Objects
+    class Parameter
+      module Keywords
+        module ValueParser
+          class << self
+            def call(instance, result)
+              type = result.sibling(instance, "in").annotation
+              key = result.sibling(instance, "name").annotation
+              raise Error, "Missing key: #{key}" unless key
+
+              case type
+              when "query"
+                parse_query(instance)[key]
+              when "header"
+                instance["headers"][key]
+              when "path"
+                path_item_result = result.parent
+                path_item_result = path_item_result.parent until path_item_result.key.start_with?("/")
+
+                Instance::Attribute.new(
+                  path_item_result.annotation["path_attributes"][key],
+                  key: "path",
+                  parent: instance["path"]
+                )
+              when "cookie"
+                # instance["headers"]["Cookie"]
+              else
+                raise Error, "Unknown location: #{result.sibling(instance, "in").annotation}"
+              end
+            end
+
+            private
+
+            def parse_query(instance)
+              params = {}
+              instance["query"]&.value.to_s.split(/[&;]/).each do |pairs|
+                key, value = pairs.split("=", 2).collect { |v| CGI.unescape(v) }
+                next unless key
+
+                params[key] = value
+              end
+
+              Instance::Attribute.new(
+                params,
+                key: "query",
+                parent: instance["query"]
+              )
+            end
+
+            def style(value, instance, result)
+              case result.sibling(instance, "style")
+              when "simple"
+                value
+              when "label"
+                value.split(".")
+              when "matrix"
+                value.split(";")
+              when "form"
+                value.split("&")
+              when "spaceDelimited"
+                value.split(" ")
+              when "pipeDelimited"
+                value.split("|")
+              when "deepObject"
+                raise Error, "Not implemented yet"
+              else
+                raise Error, "Unknown style: #{result.sibling(instance, "style")}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skooma/objects/parameter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    # https://spec.openapis.org/oas/v3.1.0#parameter-object
+    # Describes a single operation parameter.
+    class Parameter < RefBase
+      def kw_classes
+        [
+          Keywords::Name,
+          Keywords::In,
+          Base::Keywords::Description,
+          Base::Keywords::Deprecated,
+          Header::Keywords::Style,
+          Header::Keywords::Explode,
+          Keywords::AllowEmptyValue,
+          Keywords::AllowReserved,
+          Keywords::Required,
+          Keywords::Schema,
+          Header::Keywords::Example,
+          Header::Keywords::Examples,
+          Keywords::Content
+        ]
+      end
+    end
+  end
+end

data/lib/skooma/objects/path_item/keywords/base_operation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Skooma
+  module Objects
+    class PathItem
+      module Keywords
+        class BaseOperation < JSONSkooma::Keywords::Base
+          def evaluate(instance, result)
+            return result.discard unless instance["method"] == key
+
+            json.evaluate(instance, result)
+            return result.success if result.passed?
+
+            path_item_result = result.parent
+            path_item_result = path_item_result.parent until path_item_result.key.start_with?("/")
+
+            path = path_item_result.annotation["path"]
+
+            result.failure("Path #{path}/#{key} is invalid")
+          end
+        end
+      end
+    end
+  end
+end