grape-oas 1.0.0

data/lib/grape_oas/introspectors/dry_introspector_support/constraint_applier.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Applies extracted constraints to ApiModel::Schema objects.
+      class ConstraintApplier
+        def initialize(schema, constraints, meta = {})
+          @schema = schema
+          @constraints = constraints
+          @meta = meta
+        end
+
+        def apply_meta
+          case schema.type
+          when Constants::SchemaTypes::STRING
+            apply_string_meta
+          when Constants::SchemaTypes::INTEGER, Constants::SchemaTypes::NUMBER
+            apply_numeric_meta
+          when Constants::SchemaTypes::ARRAY
+            apply_array_meta
+          end
+        end
+
+        def apply_rule_constraints
+          return unless constraints
+
+          apply_type_specific_constraints
+          apply_common_constraints
+          apply_extension_constraints
+          attach_unhandled
+        end
+
+        private
+
+        attr_reader :schema, :constraints, :meta
+
+        def apply_string_meta
+          min_length = meta[:min_size] || meta[:min_length]
+          max_length = meta[:max_size] || meta[:max_length]
+          schema.min_length = min_length if min_length
+          schema.max_length = max_length if max_length
+          schema.pattern = meta[:pattern] if meta[:pattern]
+        end
+
+        def apply_array_meta
+          min_items = meta[:min_size] || meta[:min_items]
+          max_items = meta[:max_size] || meta[:max_items]
+          schema.min_items = min_items if min_items
+          schema.max_items = max_items if max_items
+        end
+
+        def apply_numeric_meta
+          if meta[:gt]
+            schema.minimum = meta[:gt]
+            schema.exclusive_minimum = true
+          elsif meta[:gteq]
+            schema.minimum = meta[:gteq]
+          end
+
+          if meta[:lt]
+            schema.maximum = meta[:lt]
+            schema.exclusive_maximum = true
+          elsif meta[:lteq]
+            schema.maximum = meta[:lteq]
+          end
+        end
+
+        def apply_type_specific_constraints
+          case schema.type
+          when Constants::SchemaTypes::STRING
+            apply_string_constraints
+          when Constants::SchemaTypes::ARRAY
+            apply_array_constraints
+          when Constants::SchemaTypes::INTEGER, Constants::SchemaTypes::NUMBER
+            apply_numeric_constraints
+          end
+        end
+
+        def apply_string_constraints
+          schema.min_length ||= constraints.min_size if constraints.min_size
+          schema.max_length ||= constraints.max_size if constraints.max_size
+          schema.pattern ||= constraints.pattern if constraints.pattern
+        end
+
+        def apply_array_constraints
+          schema.min_items ||= constraints.min_size if constraints.min_size
+          schema.max_items ||= constraints.max_size if constraints.max_size
+        end
+
+        def apply_numeric_constraints
+          numeric_min = constraints.minimum || constraints.min_size
+          numeric_max = constraints.maximum || constraints.max_size
+          schema.minimum ||= numeric_min if numeric_min
+          schema.maximum ||= numeric_max if numeric_max
+          schema.exclusive_minimum ||= constraints.exclusive_minimum
+          schema.exclusive_maximum ||= constraints.exclusive_maximum
+        end
+
+        def apply_common_constraints
+          schema.enum ||= constraints.enum if constraints.enum
+          schema.nullable = true if constraints.nullable
+          schema.format ||= constraints.format if constraints.format
+        end
+
+        def apply_extension_constraints
+          apply_extension("multipleOf", constraints.extensions&.dig("multipleOf"))
+          apply_extension("x-excludedValues", constraints.excluded_values)
+          apply_extension("x-typePredicate", constraints.type_predicate)
+          apply_extension("x-numberParity", constraints.parity&.to_s)
+        end
+
+        def apply_extension(key, value)
+          return unless value
+
+          schema.extensions ||= {}
+          schema.extensions[key] ||= value
+        end
+
+        def attach_unhandled
+          return unless constraints&.unhandled_predicates
+
+          filtered = Array(constraints.unhandled_predicates) - ignored_predicates
+          return if filtered.empty?
+
+          schema.extensions ||= {}
+          schema.extensions["x-unhandledPredicates"] = filtered
+        end
+
+        def ignored_predicates
+          %i[key? key str? int? bool? boolean? array? hash? number? float?]
+        end
+      end
+    end
+  end
+end

data/lib/grape_oas/introspectors/dry_introspector_support/constraint_extractor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Extracts constraint information from Dry::Schema AST nodes.
+      # Delegates AST walking to AstWalker and merging to ConstraintMerger.
+      class ConstraintExtractor
+        # Value object holding all possible constraints extracted from a Dry contract.
+        ConstraintSet = Struct.new(
+          :enum,
+          :nullable,
+          :min_size,
+          :max_size,
+          :minimum,
+          :maximum,
+          :exclusive_minimum,
+          :exclusive_maximum,
+          :pattern,
+          :excluded_values,
+          :unhandled_predicates,
+          :required,
+          :type_predicate,
+          :parity,
+          :format,
+          :extensions,
+          keyword_init: true,
+        )
+
+        def self.extract(contract)
+          new(contract).extract
+        end
+
+        def initialize(contract)
+          @contract = contract
+          @ast_walker = AstWalker.new(ConstraintSet)
+        end
+
+        def extract
+          constraints = Hash.new { |h, k| h[k] = ConstraintSet.new(unhandled_predicates: []) }
+
+          extract_from_rules(constraints)
+          extract_from_types(constraints)
+
+          constraints
+        rescue NoMethodError, TypeError
+          {}
+        end
+
+        private
+
+        attr_reader :contract, :ast_walker
+
+        def extract_from_rules(constraints)
+          return unless contract.respond_to?(:rules)
+
+          contract.rules.each do |name, rule|
+            ast = rule.respond_to?(:to_ast) ? rule.to_ast : rule
+            c = walk_ast(ast)
+            # infer requiredness: required rules are usually :and, optional via :implication
+            c.required = ast[0] != :implication if ast.is_a?(Array)
+            ConstraintMerger.merge(constraints[name], c)
+          end
+        end
+
+        def extract_from_types(constraints)
+          return unless contract.respond_to?(:types)
+
+          contract.types.each do |name, dry_type|
+            next unless dry_type.respond_to?(:rule_ast) || (dry_type.respond_to?(:meta) && dry_type.meta[:rules])
+
+            asts = dry_type.respond_to?(:rule_ast) ? dry_type.rule_ast : dry_type.meta[:rules]
+            Array(asts).each do |ast|
+              ConstraintMerger.merge(constraints[name], walk_ast(ast))
+            end
+          end
+        end
+
+        def walk_ast(ast)
+          ast_walker.walk(ast)
+        end
+      end
+    end
+  end
+end

data/lib/grape_oas/introspectors/dry_introspector_support/constraint_merger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Merges constraint sets, combining values from source into target.
+      module ConstraintMerger
+        module_function
+
+        def merge(target, source)
+          return unless source
+
+          merge_basic_constraints(target, source)
+          merge_bound_constraints(target, source)
+          merge_extension_constraints(target, source)
+        end
+
+        def merge_basic_constraints(target, source)
+          target.enum ||= source.enum
+          target.nullable ||= source.nullable
+          target.pattern ||= source.pattern if source.pattern
+          target.format ||= source.format if source.format
+          target.required = source.required unless source.required.nil?
+          target.type_predicate ||= source.type_predicate if source.type_predicate
+          target.parity ||= source.parity if source.parity
+        end
+        private_class_method :merge_basic_constraints
+
+        def merge_bound_constraints(target, source)
+          target.min_size ||= source.min_size if source.min_size
+          target.max_size ||= source.max_size if source.max_size
+          target.minimum ||= source.minimum if source.minimum
+          target.maximum ||= source.maximum if source.maximum
+          target.exclusive_minimum ||= source.exclusive_minimum
+          target.exclusive_maximum ||= source.exclusive_maximum
+        end
+        private_class_method :merge_bound_constraints
+
+        def merge_extension_constraints(target, source)
+          target.excluded_values ||= source.excluded_values if source.excluded_values
+          target.unhandled_predicates |= Array(source.unhandled_predicates) if source.unhandled_predicates
+        end
+        private_class_method :merge_extension_constraints
+      end
+    end
+  end
+end

data/lib/grape_oas/introspectors/dry_introspector_support/contract_resolver.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Resolves contract class, schema, and metadata from a Dry contract.
+      # Handles both class and instance contracts.
+      class ContractResolver
+        def initialize(contract)
+          @contract = contract
+        end
+
+        # Gets the contract class (handles both class and instance).
+        #
+        # @return [Class] the contract class
+        def contract_class
+          @contract.is_a?(Class) ? @contract : @contract.class
+        end
+
+        # Gets the schema from contract (handles both class and instance).
+        #
+        # @return [Object] the contract schema
+        def contract_schema
+          if @contract.is_a?(Class)
+            @contract.respond_to?(:schema) ? @contract.schema : @contract
+          else
+            @contract.respond_to?(:schema) ? @contract.class.schema : @contract
+          end
+        end
+
+        # Gets canonical name for contracts and schemas.
+        # - For Dry::Validation::Contract: uses class name
+        # - For Dry::Schema with schema_name: uses the defined schema_name
+        #
+        # @return [String, nil] the canonical name or nil
+        def canonical_name
+          return contract_class.name if validation_contract?
+
+          # Check for schema_name on Dry::Schema objects
+          return @contract.schema_name if @contract.respond_to?(:schema_name) && @contract.schema_name
+
+          nil
+        end
+
+        # Checks if this is a Dry::Validation::Contract (class or instance).
+        #
+        # @return [Boolean] true if validation contract
+        def validation_contract?
+          return false unless defined?(Dry::Validation::Contract)
+
+          if @contract.is_a?(Class)
+            @contract < Dry::Validation::Contract
+          else
+            @contract.is_a?(Dry::Validation::Contract)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape_oas/introspectors/dry_introspector_support/inheritance_handler.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Handles contract inheritance detection and allOf schema building.
+      class InheritanceHandler
+        def initialize(contract_resolver, stack:, registry:)
+          @contract_resolver = contract_resolver
+          @stack = stack
+          @registry = registry
+        end
+
+        # Finds parent contract class if this contract inherits from another.
+        #
+        # @return [Class, nil] the parent contract class or nil
+        def find_parent_contract
+          return nil unless defined?(Dry::Validation::Contract)
+
+          parent = @contract_resolver.contract_class.superclass
+          return nil unless parent && parent < Dry::Validation::Contract && parent != Dry::Validation::Contract
+          return nil unless parent.respond_to?(:schema)
+
+          parent
+        end
+
+        # Checks if the contract has a parent contract.
+        #
+        # @return [Boolean] true if inherited
+        def inherited?
+          !find_parent_contract.nil?
+        end
+
+        # Builds an inherited schema using allOf composition.
+        #
+        # @param parent_contract [Class] the parent contract class
+        # @param type_schema_builder [TypeSchemaBuilder] builder for type schemas
+        # @return [ApiModel::Schema] the composed schema
+        def build_inherited_schema(parent_contract, type_schema_builder)
+          # Build parent schema first
+          parent_schema = DryIntrospector.new(parent_contract, stack: @stack, registry: @registry).build
+
+          # Build child-only properties
+          child_schema = build_child_only_schema(parent_contract, type_schema_builder)
+
+          # Create allOf schema
+          schema = ApiModel::Schema.new(
+            canonical_name: @contract_resolver.contract_class.name,
+            all_of: [parent_schema, child_schema],
+          )
+
+          @registry[@contract_resolver.contract_class] = schema
+          schema
+        end
+
+        # Gets type keys from parent contract.
+        #
+        # @param parent_contract [Class] the parent contract class
+        # @return [Array<String>] list of parent type keys
+        def parent_contract_types(parent_contract)
+          return [] unless parent_contract.respond_to?(:schema)
+
+          parent_contract.schema.types.keys.map(&:to_s)
+        end
+
+        private
+
+        def build_child_only_schema(parent_contract, type_schema_builder)
+          child_schema = ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT)
+          parent_keys = parent_contract_types(parent_contract)
+          rule_constraints = ConstraintExtractor.extract(@contract_resolver.contract_schema)
+
+          @contract_resolver.contract_schema.types.each do |name, dry_type|
+            # Skip inherited properties
+            next if parent_keys.include?(name.to_s)
+
+            constraints = rule_constraints[name]
+            prop_schema = type_schema_builder.build_schema_for_type(dry_type, constraints)
+            child_schema.add_property(name, prop_schema, required: type_schema_builder.required?(dry_type, constraints))
+          end
+
+          child_schema
+        end
+      end
+    end
+  end
+end

data/lib/grape_oas/introspectors/dry_introspector_support/predicate_handler.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Handles Dry::Schema predicate nodes and updates constraints accordingly.
+      class PredicateHandler
+        def initialize(constraints)
+          @constraints = constraints
+        end
+
+        HANDLED_PREDICATES = %i[
+          key? size? min_size? max_size? range? empty? bytesize? max_bytesize? min_bytesize?
+          maybe nil? filled?
+          included_in? excluded_from? eql? true? false?
+          gt? gteq? min? lt? lteq? max? multiple_of? divisible_by?
+          format? uuid? uri? url? email? date? time? date_time?
+          str? int? array? hash? number? float? bool? boolean? type?
+          odd? even?
+        ].freeze
+
+        def handle(pred_node)
+          return unless pred_node.is_a?(Array)
+
+          name = pred_node[0]
+          args = Array(pred_node[1])
+
+          dispatch_predicate(name, args)
+          constraints.unhandled_predicates << name unless HANDLED_PREDICATES.include?(name)
+        end
+
+        private
+
+        attr_reader :constraints
+
+        def dispatch_predicate(name, args)
+          case name
+          when :key? then constraints.required = true if constraints.required.nil?
+          when :size?, :min_size? then handle_size(name, args)
+          when :max_size? then constraints.max_size = ArgumentExtractor.extract_numeric(args.first)
+          when :range? then handle_range(args)
+          when :empty? then constraints.min_size = constraints.max_size = 0
+          when :bytesize?, :max_bytesize?, :min_bytesize? then handle_bytesize(name, args)
+          when :maybe, :nil? then constraints.nullable = true
+          when :filled? then constraints.nullable = false
+          when :included_in? then apply_enum_from_list(args)
+          when :excluded_from? then apply_excluded_from_list(args)
+          when :eql? then apply_enum_from_literal(args)
+          when :true? then constraints.enum = [true]
+          when :false? then constraints.enum = [false]
+          when :gt? then apply_exclusive_minimum(args)
+          when :gteq?, :min? then constraints.minimum = ArgumentExtractor.extract_numeric(args.first)
+          when :lt? then apply_exclusive_maximum(args)
+          when :lteq?, :max? then constraints.maximum = ArgumentExtractor.extract_numeric(args.first)
+          when :multiple_of?, :divisible_by? then handle_multiple_of(args)
+          when :format? then apply_pattern(args)
+          when :uuid? then constraints.format = "uuid"
+          when :uri?, :url? then constraints.format = "uri"
+          when :email? then constraints.format = "email"
+          when :date? then constraints.format = "date"
+          when :time?, :date_time? then constraints.format = "date-time"
+          when :bool?, :boolean? then constraints.type_predicate ||= :boolean
+          when :type? then constraints.type_predicate = ArgumentExtractor.extract_literal(args.first)
+          when :odd? then constraints.parity = :odd
+          when :even? then constraints.parity = :even
+          end
+        end
+
+        def apply_enum_from_list(args)
+          vals = ArgumentExtractor.extract_list(args.first)
+          constraints.enum = vals if vals
+        end
+
+        def apply_excluded_from_list(args)
+          vals = ArgumentExtractor.extract_list(args.first)
+          constraints.excluded_values = vals if vals
+        end
+
+        def apply_enum_from_literal(args)
+          val = ArgumentExtractor.extract_literal(args.first)
+          constraints.enum = [val] unless val.nil?
+        end
+
+        def apply_exclusive_minimum(args)
+          constraints.minimum = ArgumentExtractor.extract_numeric(args.first)
+          constraints.exclusive_minimum = true if constraints.minimum
+        end
+
+        def apply_exclusive_maximum(args)
+          constraints.maximum = ArgumentExtractor.extract_numeric(args.first)
+          constraints.exclusive_maximum = true if constraints.maximum
+        end
+
+        def apply_pattern(args)
+          pat = ArgumentExtractor.extract_pattern(args.first)
+          constraints.pattern = pat if pat
+        end
+
+        def handle_size(name, args)
+          min_val = ArgumentExtractor.extract_numeric(args[0])
+          max_val = ArgumentExtractor.extract_numeric(args[1]) if name == :size?
+          constraints.min_size = min_val if min_val
+          constraints.max_size = max_val if max_val
+        end
+
+        def handle_range(args)
+          rng = args.first.is_a?(Range) ? args.first : ArgumentExtractor.extract_range(args.first)
+          return unless rng
+
+          constraints.minimum = rng.begin if rng.begin
+          constraints.maximum = rng.end if rng.end
+          constraints.exclusive_maximum = rng.exclude_end?
+        end
+
+        def handle_multiple_of(args)
+          val = ArgumentExtractor.extract_numeric(args.first)
+          constraints.extensions ||= {}
+          constraints.extensions["multipleOf"] ||= val if val
+        end
+
+        def handle_bytesize(name, args)
+          min_val = ArgumentExtractor.extract_numeric(args[0]) if %i[bytesize? min_bytesize?].include?(name)
+          max_source = name == :bytesize? ? args[1] : args[0]
+          max_val = ArgumentExtractor.extract_numeric(max_source) if %i[bytesize? max_bytesize?].include?(name)
+          constraints.min_size = min_val if min_val
+          constraints.max_size = max_val if max_val
+        end
+      end
+    end
+  end
+end

data/lib/grape_oas/introspectors/dry_introspector_support/type_schema_builder.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Introspectors
+    module DryIntrospectorSupport
+      # Builds OpenAPI schemas from Dry types.
+      class TypeSchemaBuilder
+        include ApiModelBuilders::Concerns::TypeResolver
+
+        # Re-export ConstraintSet for external use
+        ConstraintSet = ConstraintExtractor::ConstraintSet
+
+        def initialize
+          # Stateless builder - no initialization needed
+        end
+
+        # Builds a schema for a Dry type.
+        #
+        # @param dry_type [Object] the Dry type
+        # @param constraints [ConstraintSet, nil] extracted constraints
+        # @return [ApiModel::Schema] the built schema
+        def build_schema_for_type(dry_type, constraints = nil)
+          constraints ||= ConstraintSet.new(unhandled_predicates: [])
+          meta = dry_type.respond_to?(:meta) ? dry_type.meta : {}
+
+          # Check for Sum type first (TypeA | TypeB) -> anyOf
+          return build_any_of_schema(dry_type) if TypeUnwrapper.sum_type?(dry_type)
+
+          # Check for Hash schema type (nested schemas like .hash(SomeSchema))
+          return build_hash_schema(dry_type) if hash_schema_type?(dry_type)
+
+          primitive, member = TypeUnwrapper.derive_primitive_and_member(dry_type)
+          enum_vals = extract_enum_from_type(dry_type)
+
+          schema = build_base_schema(primitive, member)
+          schema.nullable = true if nullable?(dry_type, constraints)
+          schema.enum = enum_vals if enum_vals
+          schema.enum = constraints.enum if constraints.enum && schema.enum.nil?
+
+          apply_constraints(schema, constraints, meta)
+          schema
+        end
+
+        # Checks if a type is required.
+        #
+        # @param dry_type [Object] the Dry type
+        # @param constraints [ConstraintSet, nil] extracted constraints
+        # @return [Boolean] true if required
+        def required?(dry_type, constraints = nil)
+          # prefer rule-derived info if present
+          return constraints.required if constraints && !constraints.required.nil?
+
+          meta = dry_type.respond_to?(:meta) ? dry_type.meta : {}
+          return false if dry_type.respond_to?(:optional?) && dry_type.optional?
+          return false if meta[:omittable]
+
+          true
+        end
+
+        private
+
+        def build_any_of_schema(sum_type)
+          types = TypeUnwrapper.extract_sum_types(sum_type)
+
+          any_of_schemas = types.map do |t|
+            build_schema_for_sum_member(t)
+          end
+
+          ApiModel::Schema.new(any_of: any_of_schemas)
+        end
+
+        def build_schema_for_sum_member(dry_type)
+          # Handle Hash schemas (Types::Hash.schema(...))
+          return build_hash_schema(dry_type) if hash_schema_type?(dry_type)
+
+          # Fall back to regular type handling
+          build_schema_for_type(dry_type)
+        end
+
+        def hash_schema_type?(dry_type)
+          return true if dry_type.respond_to?(:keys) && dry_type.keys.any?
+
+          # Check for wrapped types
+          unwrapped = TypeUnwrapper.unwrap(dry_type)
+          unwrapped.respond_to?(:keys) && unwrapped.keys.any?
+        end
+
+        def build_hash_schema(dry_type)
+          schema = ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT)
+          unwrapped = TypeUnwrapper.unwrap(dry_type)
+
+          return schema unless unwrapped.respond_to?(:keys)
+
+          # Dry::Schema keys method returns an array of Key objects, not a Hash
+          schema_keys = unwrapped.keys
+          schema_keys.each do |key|
+            key_name = key.respond_to?(:name) ? key.name.to_s : key.to_s
+            key_type = key.respond_to?(:type) ? key.type : nil
+
+            prop_schema = key_type ? build_schema_for_type(key_type) : default_string_schema
+            req = key.respond_to?(:required?) ? key.required? : true
+            schema.add_property(key_name, prop_schema, required: req)
+          end
+
+          schema
+        end
+
+        def build_base_schema(primitive, member)
+          if primitive == Array
+            items_schema = member ? build_schema_for_type(member) : default_string_schema
+            ApiModel::Schema.new(type: Constants::SchemaTypes::ARRAY, items: items_schema)
+          else
+            build_schema_for_primitive(primitive)
+          end
+        end
+
+        def apply_constraints(schema, constraints, meta)
+          applier = ConstraintApplier.new(schema, constraints, meta)
+          applier.apply_meta
+          applier.apply_rule_constraints
+        end
+
+        def nullable?(dry_type, constraints)
+          meta = dry_type.respond_to?(:meta) ? dry_type.meta : {}
+          return true if dry_type.respond_to?(:optional?) && dry_type.optional?
+          return true if meta[:maybe]
+          return true if constraints&.nullable
+
+          false
+        end
+
+        def extract_enum_from_type(dry_type)
+          return unless dry_type.respond_to?(:values)
+
+          vals = dry_type.values
+          vals if vals.is_a?(Array)
+        rescue NoMethodError
+          nil
+        end
+      end
+    end
+  end
+end