verquest 0.6.3 → 0.7.0

data/lib/verquest/conditions/branch.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    # The `then` or `else` part of a condition
+    #
+    # A branch is a DSL scope: `field`, `object` and the rest add properties
+    # through {#add}, and rule methods add rules through {#add_rule}. The
+    # properties are listed at the scope level by
+    # {Verquest::HelperMethods::ConditionalProperties}, so the branch schema
+    # only holds rules: the required names, the rule fragments and `false`
+    # for the names the other branch declares.
+    class Branch
+      include HelperMethods::RequiredProperties
+
+      # @!attribute [r] properties
+      #   @return [Hash<String, Verquest::Properties::Base>] The properties declared in the branch
+      #
+      # @!attribute [r] documentation
+      #   @return [Hash<String, Object>] The title, description and deprecated flag of the branch's oneOf variant
+      attr_reader :properties, :documentation
+
+      # Initialize an empty branch
+      #
+      # The documentation is used only when the condition is documented as a oneOf.
+      #
+      # @param title [String, nil] Title of the branch's oneOf variant
+      # @param description [String, nil] Description of the branch's oneOf variant
+      # @param deprecated [Boolean, nil] Whether the branch's oneOf variant is deprecated
+      def initialize(title: nil, description: nil, deprecated: nil)
+        @properties = {}
+        @rules = RuleSet.new
+        @documentation = {"title" => title, "description" => description, "deprecated" => deprecated}.compact
+      end
+
+      # Add a property declared in the branch
+      #
+      # @param property [Verquest::Properties::Base] The property to add
+      # @return [Verquest::Properties::Base] The added property
+      # @raise [ArgumentError] If the property is a oneOf
+      def add(property)
+        raise ArgumentError, "one_of can not be declared inside a condition" if property.is_a?(Properties::OneOf)
+
+        properties[property.name] = property
+      end
+
+      # Add a rule
+      #
+      # @param rule [#to_schema, #property_names] The rule to add
+      # @return [Array] The rules
+      def add_rule(rule)
+        rules.add_rule(rule)
+      end
+
+      # Returns the names of the properties the rules use
+      #
+      # @return [Array<String>] The property names, without duplicates
+      def rule_property_names
+        rules.property_names
+      end
+
+      # Builds the branch schema fragment
+      #
+      # @param forbidden [Array<String>] Property names the branch forbids (declared by the other branch only)
+      # @return [Hash] The schema fragment
+      # @raise [ArgumentError] If two rules conflict or the branch requires a forbidden name
+      def to_schema(forbidden: [])
+        FragmentMerge.call([required_schema, rules.to_schema, forbidden_schema(forbidden)]).tap do |schema|
+          check_satisfiable!(schema, forbidden)
+        end
+      end
+
+      private
+
+      # @!attribute [r] rules
+      #   @return [Verquest::Conditions::RuleSet] The rules of the branch
+      attr_reader :rules
+
+      # Builds the fragment for the branch properties' requiredness
+      #
+      # @return [Hash] The `required` and `dependentRequired` fragment
+      def required_schema
+        {}.tap do |schema|
+          schema["required"] = required_properties if required_properties.any?
+          schema["dependentRequired"] = dependent_required_properties if dependent_required_properties.any?
+        end
+      end
+
+      # Checks that the branch doesn't require a name it forbids
+      #
+      # @param schema [Hash] The branch schema fragment
+      # @param forbidden [Array<String>] The forbidden property names
+      # @return [void]
+      # @raise [ArgumentError] If a required name is forbidden, which no payload could satisfy
+      def check_satisfiable!(schema, forbidden)
+        conflict = schema.fetch("required", []) & forbidden
+        raise ArgumentError, "Branch requires #{conflict.join(", ")}, which only the other branch declares" if conflict.any?
+      end
+
+      # Builds the fragment that forbids properties
+      #
+      # @param names [Array<String>] The forbidden property names
+      # @return [Hash] The `properties` fragment with a `false` schema per name
+      def forbidden_schema(names)
+        return {} if names.empty?
+
+        {"properties" => names.to_h { |name| [name, false] }}
+      end
+    end
+  end
+end

data/lib/verquest/conditions/condition.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    # One `if` / `then` / `else`
+    #
+    # Holds the `given` rule set (the `if`) and up to two branches. A property
+    # declared in one branch only is forbidden in the other, so when only one
+    # branch declares properties, the other one is generated.
+    #
+    # @example
+    #   condition = Condition.new(name: :pricing)
+    #   condition.open(:given).add_rule(Rules::Present.new(%i[percentages]))
+    #   condition.open(:then).add(Properties::Field.new(name: :percentages, type: :number, required: true))
+    #   condition.to_schema
+    #   # => {
+    #   #   "if" => {"required" => ["percentages"]},
+    #   #   "then" => {"required" => ["percentages"]},
+    #   #   "else" => {"properties" => {"percentages" => false}}
+    #   # }
+    class Condition
+      # The scope class for each part of a condition
+      PARTS = {given: RuleSet, then: Branch, else: Branch}.freeze
+
+      # The ways a condition can be rendered in `to_schema` instead of `if` / `then` / `else`
+      DOCUMENT_AS = %i[one_of].freeze
+
+      # @!attribute [r] name
+      #   @return [String, nil] The condition name, used to exclude it in a later version
+      #
+      # @!attribute [r] document_as
+      #   @return [Symbol, nil] `:one_of` when `to_schema` renders the condition as a oneOf
+      attr_reader :name, :document_as
+
+      # Initialize a new Condition
+      #
+      # @param name [Symbol, String, nil] Optional name
+      # @param document_as [Symbol, nil] `:one_of` to render the condition as a oneOf in `to_schema`
+      # @raise [ArgumentError] If document_as is not supported
+      def initialize(name: nil, document_as: nil)
+        raise ArgumentError, "document_as must be :one_of (got #{document_as.inspect})" unless document_as.nil? || DOCUMENT_AS.include?(document_as)
+
+        @name = name&.to_s
+        @document_as = document_as
+        @parts = {}
+      end
+
+      # Starts one part of the condition
+      #
+      # @param part [Symbol] :given, :then or :else
+      # @param options [Hash] Branch documentation (title, description, deprecated), for :then and :else only
+      # @return [Verquest::Conditions::RuleSet, Verquest::Conditions::Branch] The new part, used as the DSL scope
+      # @raise [ArgumentError] If the part was already declared
+      def open(part, **options)
+        raise ArgumentError, "#{part} can be declared only once in #{label}" if parts.key?(part)
+
+        parts[part] = PARTS.fetch(part).new(**options)
+      end
+
+      # Rejects properties declared outside a branch
+      #
+      # @param _property [Verquest::Properties::Base] The property that was declared
+      # @raise [ArgumentError] Always
+      def add(_property)
+        raise ArgumentError, "Properties of #{label} must be declared inside then_apply or else_apply"
+      end
+
+      # Checks the shape of the condition and the names its rules use
+      #
+      # @param property_names [Array<String>] The names declared in the scope and in its branches
+      # @return [nil]
+      # @raise [ArgumentError] If `given` has no rules, neither branch is declared, or a rule uses an unknown name
+      def validate!(property_names)
+        raise ArgumentError, "#{label} needs a given block with at least one rule" if given.rules.empty?
+        raise ArgumentError, "#{label} needs a then_apply or else_apply block" unless parts.key?(:then) || parts.key?(:else)
+
+        unknown = rule_property_names - property_names
+        raise ArgumentError, "#{label} uses unknown properties: #{unknown.join(", ")}" if unknown.any?
+      end
+
+      # Returns the branch properties to list at the scope level
+      #
+      # @return [Hash<String, Verquest::Properties::Base>] The properties of both branches
+      # @raise [ArgumentError] If the branches declare the same name differently
+      def properties
+        PropertyMerge.call([branch(:then).properties, branch(:else).properties])
+      end
+
+      # Returns the names of the properties the rules use
+      #
+      # @return [Array<String>] The property names, without duplicates
+      def rule_property_names
+        (given.property_names + branch(:then).rule_property_names + branch(:else).rule_property_names).uniq
+      end
+
+      # Builds the `if` / `then` / `else` keywords
+      #
+      # @return [Hash] The keywords, without empty branches
+      def to_schema
+        {
+          "if" => given.to_schema(in_given: true),
+          "then" => branch_schema(:then, other: :else),
+          "else" => branch_schema(:else, other: :then)
+        }.reject { |_, fragment| fragment.empty? }
+      end
+
+      # Builds a oneOf with one variant per branch, for documentation
+      #
+      # Each variant holds the scope's properties without the ones only the
+      # other branch declares, plus its branch's rules. The `then` variant also
+      # holds the `given` rules, and the `else` variant their negation, unless
+      # the variant already rules `given` out. So exactly one variant matches
+      # every payload the `if` / `then` / `else` schema accepts.
+      #
+      # @param scope_schema [Hash] The scope schema with every property listed
+      # @return [Hash] The scope description and the `oneOf` variants
+      def to_one_of_schema(scope_schema)
+        {"description" => scope_schema["description"], "oneOf" => [variant_schema(scope_schema, :then, other: :else), variant_schema(scope_schema, :else, other: :then)]}.compact
+      end
+
+      private
+
+      # @!attribute [r] parts
+      #   @return [Hash<Symbol, Object>] The declared parts, keyed by :given, :then and :else
+      attr_reader :parts
+
+      # @return [Verquest::Conditions::RuleSet] The `given` rules, empty if not declared
+      def given
+        parts.fetch(:given) { RuleSet.new }
+      end
+
+      # @param part [Symbol] :then or :else
+      # @return [Verquest::Conditions::Branch] The branch, empty if not declared
+      def branch(part)
+        parts.fetch(part) { Branch.new }
+      end
+
+      # Builds one branch, forbidding the names only the other branch declares
+      #
+      # @param part [Symbol] :then or :else
+      # @param other [Symbol] The other branch
+      # @return [Hash] The branch schema fragment
+      def branch_schema(part, other:)
+        branch(part).to_schema(forbidden: branch(other).properties.keys - branch(part).properties.keys)
+      end
+
+      # Builds the oneOf variant for one branch
+      #
+      # @param scope_schema [Hash] The scope schema with every property listed
+      # @param part [Symbol] :then or :else
+      # @param other [Symbol] The other branch
+      # @return [Hash] The variant schema
+      def variant_schema(scope_schema, part, other:)
+        excluded = branch(other).properties.keys - branch(part).properties.keys
+        base = {"type" => scope_schema["type"]}.merge(branch(part).documentation, scope_schema.except("description"))
+        base["properties"] = variant_properties(scope_schema, excluded)
+
+        Conjunction.call([base, branch(part).to_schema, (part == :then) ? given.to_schema(in_given: true) : {}]).tap do |variant|
+          variant["not"] = given.to_schema(in_given: true) if part == :else && given_possible?(variant)
+        end
+      end
+
+      # Lists the properties of a variant
+      #
+      # The excluded names are dropped. When the scope allows additional
+      # properties, they are forbidden with a `false` schema instead.
+      #
+      # @param scope_schema [Hash] The scope schema with every property listed
+      # @param excluded [Array<String>] The names only the other branch declares
+      # @return [Hash] The variant properties
+      def variant_properties(scope_schema, excluded)
+        properties = scope_schema["properties"].except(*excluded)
+        return properties if scope_schema["additionalProperties"] == false
+
+        properties.merge(excluded.to_h { |property_name| [property_name, false] })
+      end
+
+      # Checks whether a payload matching the variant could still match `given`
+      #
+      # @param variant [Hash] The variant schema
+      # @return [Boolean] false when the variant forbids a name `given` requires
+      def given_possible?(variant)
+        given.to_schema(in_given: true).fetch("required", []).none? do |property_name|
+          variant["properties"][property_name] == false || (!variant["properties"].key?(property_name) && variant["additionalProperties"] == false)
+        end
+      end
+
+      # @return [String] The condition name for error messages
+      def label
+        name ? "Condition '#{name}'" : "Condition"
+      end
+    end
+  end
+end

data/lib/verquest/conditions/conjunction.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    # Combines schema fragments that must all hold
+    #
+    # Unlike FragmentMerge, a clash is not an error here: the fragments are
+    # requirements on the same payload, so a fragment that can't be merged
+    # (for example `note: false` against `note: {type: string}`) is added to
+    # `allOf` instead. Used for the documented oneOf variants, which join the
+    # scope schema, the branch rules and the `given` rules.
+    #
+    # @example
+    #   Conjunction.call([{"properties" => {"note" => {"type" => "string"}}}, {"properties" => {"note" => false}}])
+    #   # => {"properties" => {"note" => {"type" => "string"}}, "allOf" => [{"properties" => {"note" => false}}]}
+    module Conjunction
+      module_function
+
+      # Combines the fragments in order
+      #
+      # @param fragments [Array<Hash>] The schema fragments that must all hold
+      # @return [Hash] The combined fragment
+      def call(fragments)
+        fragments.reduce({}) { |combined, fragment| conjoin(combined, fragment) }
+      end
+
+      # Merges two fragments, or adds the second to `allOf` when they clash
+      #
+      # @param left [Hash] The fragment combined so far
+      # @param right [Hash] The fragment to add
+      # @return [Hash] The combined fragment
+      def conjoin(left, right)
+        FragmentMerge.merge(left, right)
+      rescue ArgumentError
+        left.merge("allOf" => left.fetch("allOf", []) + [right])
+      end
+    end
+  end
+end

data/lib/verquest/conditions/fragment_merge.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    # Deep-merges the schema fragments of several rules into one fragment
+    #
+    # `required` lists are concatenated without duplicates and nested hashes
+    # (like `properties`) are merged. Two different values for the same keyword
+    # raise, so `equals :kind, "a"` and `equals :kind, "b"` in one block fail
+    # instead of silently keeping one of them.
+    #
+    # @example
+    #   FragmentMerge.call([{"required" => ["a"]}, {"required" => ["a", "b"]}])
+    #   # => {"required" => ["a", "b"]}
+    module FragmentMerge
+      module_function
+
+      # Merges the fragments in order
+      #
+      # @param fragments [Array<Hash>] The schema fragments to merge
+      # @return [Hash] The merged fragment
+      # @raise [ArgumentError] If two fragments set the same keyword to different values
+      def call(fragments)
+        fragments.reduce({}) { |merged, fragment| merge(merged, fragment) }
+      end
+
+      # Merges two fragments
+      #
+      # @param left [Hash] The fragment merged so far
+      # @param right [Hash] The fragment to merge into it
+      # @return [Hash] The merged fragment
+      def merge(left, right)
+        left.merge(right) { |key, left_value, right_value| merge_value(key, left_value, right_value) }
+      end
+
+      # Merges two values of the same keyword
+      #
+      # @param key [String] The keyword
+      # @param left_value [Object] The value merged so far
+      # @param right_value [Object] The value to merge into it
+      # @return [Object] The merged value
+      # @raise [ArgumentError] If the values differ and can't be combined
+      def merge_value(key, left_value, right_value)
+        return left_value | right_value if key == "required" && left_value.is_a?(::Array)
+        return merge(left_value, right_value) if left_value.is_a?(Hash) && right_value.is_a?(Hash)
+        return left_value if left_value == right_value
+
+        raise ArgumentError, "Conflicting rules for '#{key}': #{left_value.inspect} and #{right_value.inspect}"
+      end
+    end
+  end
+end

data/lib/verquest/conditions/property_merge.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    # Merges the properties declared in condition branches into one hash
+    #
+    # A name may be declared in several branches only if every declaration
+    # produces the same schema and has the same `map:`. That keeps the flat
+    # mapping unambiguous.
+    module PropertyMerge
+      module_function
+
+      # Merges property hashes in order, keeping the first declaration of each name
+      #
+      # @param property_hashes [Array<Hash<String, Verquest::Properties::Base>>] The properties to merge
+      # @return [Hash<String, Verquest::Properties::Base>] The merged properties
+      # @raise [ArgumentError] If a name is declared differently
+      def call(property_hashes)
+        property_hashes.reduce({}) do |merged, properties|
+          merged.merge(properties) { |name, declared, other| pick(name, declared, other) }
+        end
+      end
+
+      # Returns the first declaration if both declarations are the same
+      #
+      # @param name [String] The property name
+      # @param declared [Verquest::Properties::Base] The declaration merged so far
+      # @param other [Verquest::Properties::Base] Another declaration of the same name
+      # @return [Verquest::Properties::Base] The first declaration
+      # @raise [ArgumentError] If the declarations differ
+      def pick(name, declared, other)
+        return declared if same?(declared, other)
+
+        raise ArgumentError, "Property '#{name}' is declared differently in several condition branches"
+      end
+
+      # Checks whether two declarations produce the same schema and mapping
+      #
+      # @param declared [Verquest::Properties::Base] The first declaration
+      # @param other [Verquest::Properties::Base] The second declaration
+      # @return [Boolean] true if class, `map:` and schema are the same
+      def same?(declared, other)
+        declared.instance_of?(other.class) && declared.map == other.map && declared.to_schema == other.to_schema
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rule_set.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    # The rules of one block, combined with AND
+    #
+    # Used as the DSL scope of `given`, so rule methods add to it and property
+    # declarations raise. {Rules::Any} and {Rules::None} build on it.
+    #
+    # @example
+    #   rule_set = RuleSet.new
+    #   rule_set.add_rule(Rules::Present.new(%i[percentages]))
+    #   rule_set.to_schema(in_given: true)
+    #   # => {"required" => ["percentages"]}
+    class RuleSet
+      # @!attribute [r] rules
+      #   @return [Array<#to_schema>] The rules in declaration order
+      attr_reader :rules
+
+      # Initialize an empty rule set
+      def initialize
+        @rules = []
+      end
+
+      # Add a rule
+      #
+      # @param rule [#to_schema, #property_names] The rule to add
+      # @return [Array] The rules
+      def add_rule(rule)
+        rules << rule
+      end
+
+      # Rejects property declarations, which are only allowed in branches
+      #
+      # @param _property [Verquest::Properties::Base] The property that was declared
+      # @raise [ArgumentError] Always
+      def add(_property)
+        raise ArgumentError, "Properties can not be declared inside given, any or none"
+      end
+
+      # Returns the names of the properties the rules use
+      #
+      # @return [Array<String>] The property names, without duplicates
+      def property_names
+        rules.flat_map(&:property_names).uniq
+      end
+
+      # Builds the merged schema fragment of all rules
+      #
+      # @param in_given [Boolean] Whether the rules are used inside `given`
+      # @return [Hash] The schema fragment
+      # @raise [ArgumentError] If two rules conflict
+      def to_schema(in_given: false)
+        FragmentMerge.call(rules.map { |rule| rule.to_schema(in_given:) })
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/absent.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Forbids the named properties
+      #
+      # A forbidden property gets the `false` schema, so a payload that sends it
+      # is reported with a single error at the property's pointer.
+      #
+      # @example
+      #   Absent.new(%i[a b]).to_schema(in_given: false)
+      #   # => {"properties" => {"a" => false, "b" => false}}
+      class Absent < NamesRule
+        # Builds the schema fragment for this rule
+        #
+        # @param in_given [Boolean] Whether the rule is used inside `given` (no effect for this rule)
+        # @return [Hash] The schema fragment
+        def to_schema(in_given: false)
+          {"properties" => property_names.to_h { |name| [name, false] }}
+        end
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/alternatives.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Base class for rules whose nested rules are alternatives
+      #
+      # Each rule inside the block becomes one `anyOf` entry, so an empty block
+      # would produce an invalid (`anyOf: []`) or meaningless schema and raises.
+      #
+      # @abstract Subclass and implement `#to_schema(in_given:)` with {#alternatives}
+      class Alternatives < RuleSet
+        private
+
+        # Builds one schema fragment per nested rule
+        #
+        # @param in_given [Boolean] Whether the rule is used inside `given`
+        # @return [Array<Hash>] The fragments, one per alternative
+        # @raise [ArgumentError] If the block declared no rules
+        def alternatives(in_given:)
+          raise ArgumentError, "any and none need at least one rule" if rules.empty?
+
+          rules.map { |rule| rule.to_schema(in_given:) }
+        end
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/any.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Requires at least one of its rules to hold
+      #
+      # Each rule inside the block is one alternative.
+      #
+      # @example
+      #   any = Any.new
+      #   any.add_rule(Present.new(%i[email]))
+      #   any.add_rule(Present.new(%i[phone]))
+      #   any.to_schema(in_given: false)
+      #   # => {"anyOf" => [{"required" => ["email"]}, {"required" => ["phone"]}]}
+      class Any < Alternatives
+        # Builds the schema fragment with one `anyOf` entry per rule
+        #
+        # @param in_given [Boolean] Whether the rule is used inside `given`
+        # @return [Hash] The schema fragment
+        def to_schema(in_given: false)
+          {"anyOf" => alternatives(in_given:)}
+        end
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/equals.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Requires a property to hold one value
+      #
+      # @example
+      #   Equals.new(:kind, "company").to_schema(in_given: false)
+      #   # => {"properties" => {"kind" => {"const" => "company"}}}
+      class Equals < PropertyRule
+        # Initialize a new Equals rule
+        #
+        # @param name [Symbol, String] The property the rule constrains
+        # @param value [Object] The value the property must hold
+        def initialize(name, value)
+          super(name, {"const" => value})
+        end
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/names_rule.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Base class for rules that name one or more properties
+      #
+      # @abstract Subclass and implement `#to_schema(in_given:)`
+      class NamesRule
+        # @!attribute [r] property_names
+        #   @return [Array<String>] The names of the properties the rule uses
+        attr_reader :property_names
+
+        # Initialize a new rule
+        #
+        # @param names [Array<Symbol, String>] The properties the rule names
+        def initialize(names)
+          @property_names = names.map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/none.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Requires none of its rules to hold
+      #
+      # @example
+      #   none = None.new
+      #   none.add_rule(Present.new(%i[email]))
+      #   none.to_schema(in_given: false)
+      #   # => {"not" => {"anyOf" => [{"required" => ["email"]}]}}
+      class None < Alternatives
+        # Builds the schema fragment that negates the alternatives
+        #
+        # @param in_given [Boolean] Whether the rule is used inside `given`
+        # @return [Hash] The schema fragment
+        def to_schema(in_given: false)
+          {"not" => {"anyOf" => alternatives(in_given:)}}
+        end
+      end
+    end
+  end
+end

data/lib/verquest/conditions/rules/present.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Verquest
+  module Conditions
+    module Rules
+      # Requires the named properties to be present
+      #
+      # @example
+      #   Present.new(%i[a b]).to_schema(in_given: false)
+      #   # => {"required" => ["a", "b"]}
+      class Present < NamesRule
+        # Builds the schema fragment for this rule
+        #
+        # @param in_given [Boolean] Whether the rule is used inside `given` (no effect for this rule)
+        # @return [Hash] The schema fragment
+        def to_schema(in_given: false)
+          {"required" => property_names}
+        end
+      end
+    end
+  end
+end