grape-oas 1.0.2 → 1.1.0

data/lib/grape_oas/api_model_builders/request_params_support/schema_enhancer.rb

@@ -14,7 +14,8 @@ module GrapeOAS
           nullable = extract_nullable(spec, doc)
 
           schema.description ||= doc[:desc]
-          schema.nullable = nullable if schema.respond_to?(:nullable=)
+          # Preserve existing nullable: true (e.g., from [Type, Nil] optimization)
+          schema.nullable = (schema.nullable || nullable) if schema.respond_to?(:nullable=)
 
           apply_additional_properties(schema, doc)
           apply_format_and_example(schema, doc)
@@ -61,6 +62,8 @@ module GrapeOAS
           # Applies values from spec[:values] - converts Range to min/max,
           # evaluates Proc (arity 0), and sets enum for arrays.
           # Skips Proc/Lambda validators (arity > 0) used for custom validation.
+          # For array schemas, applies enum to items (since values constrain array elements).
+          # For oneOf schemas, applies enum to each non-null variant.
           def apply_values(schema, spec)
             values = spec[:values]
             return unless values
@@ -80,7 +83,79 @@ module GrapeOAS
             if values.is_a?(Range)
               apply_range_values(schema, values)
             elsif values.is_a?(Array) && values.any?
-              schema.enum = values if schema.respond_to?(:enum=)
+              apply_enum_values(schema, values)
+            end
+          end
+
+          def apply_enum_values(schema, values)
+            # For oneOf schemas, apply enum to each variant that supports enum
+            if one_of_schema?(schema)
+              schema.one_of.each do |variant|
+                # Skip null types - they don't have enums
+                next if null_type_schema?(variant)
+
+                # Filter values to those compatible with this variant's type
+                compatible_values = filter_compatible_values(variant, values)
+
+                # Only apply enum if there are compatible values
+                variant.enum = compatible_values if compatible_values.any? && variant.respond_to?(:enum=)
+              end
+            elsif array_schema_with_items?(schema)
+              # For array schemas, apply enum to items (values constrain array elements)
+              schema.items.enum = values if schema.items.respond_to?(:enum=)
+            elsif schema.respond_to?(:enum=)
+              # For regular schemas, apply enum directly
+              schema.enum = values
+            end
+          end
+
+          def one_of_schema?(schema)
+            schema.respond_to?(:one_of) && schema.one_of.is_a?(Array) && schema.one_of.any?
+          end
+
+          def null_type_schema?(schema)
+            return false unless schema.respond_to?(:type)
+
+            schema.type.nil? || schema.type == "null"
+          end
+
+          def array_schema_with_items?(schema)
+            schema.respond_to?(:type) &&
+              schema.type == Constants::SchemaTypes::ARRAY &&
+              schema.respond_to?(:items) &&
+              schema.items
+          end
+
+          # Filters enum values to those compatible with the schema variant's type.
+          # For mixed-type enums like ["a", 1], returns only values matching the variant type.
+          def filter_compatible_values(schema, values)
+            return values unless schema.respond_to?(:type) && schema.type
+            return [] if values.nil? || values.empty?
+
+            case schema.type
+            when Constants::SchemaTypes::STRING,
+                 Constants::SchemaTypes::INTEGER,
+                 Constants::SchemaTypes::NUMBER,
+                 Constants::SchemaTypes::BOOLEAN
+              values.select { |value| enum_value_compatible_with_type?(schema.type, value) }
+            else
+              values # Return all values for unknown types
+            end
+          end
+
+          # Checks if a single enum value is compatible with the given schema type.
+          def enum_value_compatible_with_type?(schema_type, value)
+            case schema_type
+            when Constants::SchemaTypes::STRING
+              value.is_a?(String) || value.is_a?(Symbol)
+            when Constants::SchemaTypes::INTEGER
+              value.is_a?(Integer)
+            when Constants::SchemaTypes::NUMBER
+              value.is_a?(Numeric)
+            when Constants::SchemaTypes::BOOLEAN
+              [true, false].include?(value)
+            else
+              true
             end
           end
 

data/lib/grape_oas/api_model_builders/response.rb

@@ -8,7 +8,7 @@ module GrapeOAS
 
       # Default response parsers in priority order
       # DocumentationResponsesParser has highest priority (most comprehensive)
-      # HttpCodesParser handles legacy grape-swagger formats
+      # HttpCodesParser handles legacy grape-swagger formats and desc blocks
       # DefaultResponseParser is the fallback
       DEFAULT_PARSERS = [
         ResponseParsers::DocumentationResponsesParser,
@@ -61,15 +61,63 @@ module GrapeOAS
       end
 
       # Builds a response from a group of specs with the same status code
-      # If multiple specs have `as:` keys, they are merged into a single object schema
+      # If any spec has `as:`, build a merged object response using only `as:` entries
+      # Else if any spec has `one_of:`, build a oneOf response from one_of entries and
+      # any regular specs in the group (this branch only runs when no `as:` entries exist)
       def build_response_from_group(group_specs)
-        if group_specs.any? { |s| s[:as] }
-          build_merged_response(group_specs)
+        has_one_of = group_specs.any? { |s| s[:one_of] && !s[:one_of].empty? }
+        has_as = group_specs.any? { |s| !s[:as].nil? }
+
+        if has_as
+          build_merged_response(group_specs.select { |s| s[:as] })
+        elsif has_one_of
+          build_one_of_response(group_specs)
         else
           build_response_from_spec(group_specs.first)
         end
       end
 
+      # Builds a oneOf response for multiple possible response schemas
+      def build_one_of_response(specs)
+        first_spec = specs.first
+
+        all_schemas = []
+        specs.each do |spec|
+          if spec[:one_of]
+            spec[:one_of].each do |one_of_spec|
+              one_of_entity = one_of_spec.is_a?(Hash) ? (one_of_spec[:model] || one_of_spec[:entity]) : nil
+              raise ArgumentError, "one_of items must include :model or :entity" unless one_of_entity
+
+              is_array = one_of_spec.key?(:is_array) ? one_of_spec[:is_array] : spec[:is_array]
+              schema = build_schema(one_of_entity)
+              schema = array_schema(schema) if is_array
+              all_schemas << schema if schema
+            end
+          else
+            schema = build_schema(spec[:entity])
+            schema = array_schema(schema) if spec[:is_array]
+            all_schemas << schema if schema
+          end
+        end
+
+        schema = GrapeOAS::ApiModel::Schema.new(one_of: all_schemas)
+        media_types = Array(response_content_types).map do |mime|
+          build_media_type(mime_type: mime, schema: schema)
+        end
+
+        message = first_spec[:message]
+        description = message.is_a?(String) ? message : message&.to_s
+
+        GrapeOAS::ApiModel::Response.new(
+          http_status: first_spec[:code].to_s,
+          description: description || "Success",
+          media_types: media_types,
+          headers: normalize_headers(first_spec[:headers]) || headers_from_route,
+          extensions: first_spec[:extensions] || extensions_from_route,
+          examples: merge_examples(specs),
+        )
+      end
+
       # Builds a merged response for multiple present with `as:` keys
       def build_merged_response(specs)
         first_spec = specs.first
@@ -78,7 +126,8 @@ module GrapeOAS
           build_media_type(mime_type: mime, schema: schema)
         end
 
-        description = first_spec[:message].is_a?(String) ? first_spec[:message] : first_spec[:message].to_s
+        message = first_spec[:message]
+        description = message.is_a?(String) ? message : message&.to_s
 
         GrapeOAS::ApiModel::Response.new(
           http_status: first_spec[:code].to_s,
@@ -136,7 +185,8 @@ module GrapeOAS
           )
         end
 
-        description = spec[:message].is_a?(String) ? spec[:message] : spec[:message].to_s
+        message = spec[:message]
+        description = message.is_a?(String) ? message : message&.to_s
 
         GrapeOAS::ApiModel::Response.new(
           http_status: spec[:code].to_s,
@@ -148,6 +198,13 @@ module GrapeOAS
         )
       end
 
+      def array_schema(schema)
+        GrapeOAS::ApiModel::Schema.new(
+          type: Constants::SchemaTypes::ARRAY,
+          items: schema,
+        )
+      end
+
       def extensions_from_route
         extract_extensions(route.options[:documentation])
       end

data/lib/grape_oas/api_model_builders/response_parsers/http_codes_parser.rb

@@ -9,27 +9,116 @@ module GrapeOAS
         include Base
 
         def applicable?(route)
-          route.options[:http_codes] || route.options[:failure] || route.options[:success]
+          options_applicable?(route) || desc_block?(route)
         end
 
         def parse(route)
-          specs = []
+          specs = parse_from_options(route)
+          return specs unless specs.empty?
 
-          specs.concat(parse_option(route, :http_codes)) if route.options[:http_codes]
-          specs.concat(parse_option(route, :failure)) if route.options[:failure]
-          specs.concat(parse_option(route, :success)) if route.options[:success]
+          parse_from_desc(route)
+        end
+
+        private
+
+        def parse_from_options(route)
+          specs = parse_values(route.options, route)
+          entity_value = route.options[:entity]
+          return specs unless entity_value
+
+          # Append entity from options unless desc block has explicit :success definition
+          # that should take precedence (stored via `success({ code: X, model: Y })` syntax)
+          should_append = (specs.empty? || desc_block?(route)) && !desc_block_has_explicit_success?(route)
+          return append_entity_spec(specs, entity_value, route) if should_append
 
           specs
         end
 
-        private
+        def parse_from_desc(route)
+          data = desc_data(route)
+          return [] unless data
+
+          specs = parse_values(data, route)
+          specs = append_entity_spec(specs, data[:entity], route) if data[:entity]
+          specs
+        end
+
+        def parse_values(data, route)
+          return [] unless data.is_a?(Hash)
 
-        def parse_option(route, option_key)
-          value = route.options[option_key]
+          %i[http_codes failure success].flat_map do |key|
+            parse_value(data[key], route)
+          end
+        end
+
+        def parse_value(value, route)
           return [] unless value
 
-          items = value.is_a?(Hash) ? [value] : Array(value)
-          items.map { |entry| normalize_entry(entry, route) }
+          entries_for(value).map { |entry| normalize_entry(entry, route) }
+        end
+
+        def entries_for(value)
+          return [value] if value.is_a?(Hash)
+          return [] if value.is_a?(Array) && value.empty?
+          return value if value.is_a?(Array) && (value.first.is_a?(Hash) || value.first.is_a?(Array))
+
+          [value]
+        end
+
+        def desc_data(route)
+          data = route.settings&.dig(:description)
+          data if data.is_a?(Hash)
+        end
+
+        def options_applicable?(route)
+          entity_hash = route.options[:entity].is_a?(Hash) ? route.options[:entity] : nil
+          route.options[:http_codes] || route.options[:failure] || route.options[:success] ||
+            (entity_hash && (entity_hash[:code] || entity_hash[:model] || entity_hash[:entity] || entity_hash[:one_of]))
+        end
+
+        def desc_block?(route)
+          data = desc_data(route)
+          data && (data[:success] || data[:failure] || data[:http_codes] || data[:entity])
+        end
+
+        def desc_block_has_explicit_success?(route)
+          desc_data(route)&.key?(:success)
+        end
+
+        def append_entity_spec(specs, entity_value, route)
+          entity_spec = build_entity_spec(entity_value, route)
+          return specs if specs.any? { |spec| spec[:code].to_i == entity_spec[:code].to_i }
+
+          specs + [entity_spec]
+        end
+
+        def build_entity_spec(entity_value, route)
+          if entity_value.is_a?(Hash)
+            # Hash format: { code: 201, model: Entity, message: "Created" }
+            {
+              code: entity_value[:code] || 200,
+              message: entity_value[:message],
+              entity: extract_entity(entity_value, nil),
+              headers: entity_value[:headers],
+              examples: entity_value[:examples],
+              as: entity_value[:as],
+              one_of: entity_value[:one_of],
+              is_array: entity_value[:is_array] || route.options[:is_array],
+              required: entity_value[:required]
+            }
+          else
+            # Plain entity class
+            {
+              code: 200,
+              message: nil,
+              entity: entity_value,
+              headers: nil,
+              examples: nil,
+              as: nil,
+              is_array: route.options[:is_array],
+              required: nil
+            }
+          end
         end
 
         def normalize_entry(entry, route)
@@ -38,6 +127,9 @@ module GrapeOAS
             normalize_hash_entry(entry, route)
           when Array
             normalize_array_entry(entry, route)
+          when Class, Module
+            # Plain entity class (e.g., success TestEntity)
+            normalize_entity_entry(entry, route)
           else
             normalize_plain_entry(entry, route)
           end
@@ -52,6 +144,7 @@ module GrapeOAS
             headers: entry[:headers],
             examples: entry[:examples],
             as: entry[:as],
+            one_of: entry[:one_of],
             is_array: entry[:is_array] || route.options[:is_array],
             required: entry[:required]
           }
@@ -70,6 +163,17 @@ module GrapeOAS
           }
         end
 
+        def normalize_entity_entry(entity_class, route)
+          # Plain entity class (e.g., success TestEntity)
+          {
+            code: route.options[:default_status] || 200,
+            message: nil,
+            entity: entity_class,
+            headers: nil,
+            is_array: route.options[:is_array]
+          }
+        end
+
         def normalize_plain_entry(entry, route)
           # Plain status code (e.g., 404)
           {

data/lib/grape_oas/constants.rb

@@ -57,34 +57,47 @@ module GrapeOAS
       File => SchemaTypes::FILE
     }.freeze
 
-    # String type name to schema type mapping (lowercase).
+    # String type name to schema type and format mapping (lowercase).
     # Supports lookup with any case via primitive_type helper.
-    # Note: float and bigdecimal both map to NUMBER as they represent
-    # the same OpenAPI numeric type.
+    # Each entry contains :type and optional :format for OpenAPI schema generation.
+    #
+    # @see https://swagger.io/specification/#data-types
+    # @see https://spec.openapis.org/registry/format/
     PRIMITIVE_TYPE_MAPPING = {
-      "float" => SchemaTypes::NUMBER,
-      "bigdecimal" => SchemaTypes::NUMBER,
-      "string" => SchemaTypes::STRING,
-      "integer" => SchemaTypes::INTEGER,
-      "number" => SchemaTypes::NUMBER,
-      "boolean" => SchemaTypes::BOOLEAN,
-      "grape::api::boolean" => SchemaTypes::BOOLEAN,
-      "trueclass" => SchemaTypes::BOOLEAN,
-      "falseclass" => SchemaTypes::BOOLEAN,
-      "array" => SchemaTypes::ARRAY,
-      "hash" => SchemaTypes::OBJECT,
-      "object" => SchemaTypes::OBJECT,
-      "file" => SchemaTypes::FILE,
-      "rack::multipart::uploadedfile" => SchemaTypes::FILE
+      "float" => { type: SchemaTypes::NUMBER, format: "float" },
+      "bigdecimal" => { type: SchemaTypes::NUMBER, format: "double" },
+      "string" => { type: SchemaTypes::STRING },
+      "integer" => { type: SchemaTypes::INTEGER, format: "int32" },
+      "number" => { type: SchemaTypes::NUMBER, format: "double" },
+      "boolean" => { type: SchemaTypes::BOOLEAN },
+      "grape::api::boolean" => { type: SchemaTypes::BOOLEAN },
+      "trueclass" => { type: SchemaTypes::BOOLEAN },
+      "falseclass" => { type: SchemaTypes::BOOLEAN },
+      "array" => { type: SchemaTypes::ARRAY },
+      "hash" => { type: SchemaTypes::OBJECT },
+      "object" => { type: SchemaTypes::OBJECT },
+      "file" => { type: SchemaTypes::FILE },
+      "rack::multipart::uploadedfile" => { type: SchemaTypes::FILE }
     }.freeze
 
     # Resolves a primitive type name to its OpenAPI schema type.
     # Normalizes the key to lowercase for consistent lookup.
     #
-    # @param key [String, Symbol] The type name to resolve
+    # @param key [String, Symbol, Class] The type name to resolve
     # @return [String, nil] The OpenAPI schema type or nil if not found
     def self.primitive_type(key)
-      PRIMITIVE_TYPE_MAPPING[key.to_s.downcase]
+      entry = PRIMITIVE_TYPE_MAPPING[key.to_s.downcase]
+      entry&.fetch(:type, nil)
+    end
+
+    # Resolves the default format for a given type.
+    # Returns nil if no specific format applies (e.g., for strings, booleans).
+    #
+    # @param key [String, Symbol, Class] The type name to resolve format for
+    # @return [String, nil] The OpenAPI format or nil if not applicable
+    def self.format_for_type(key)
+      entry = PRIMITIVE_TYPE_MAPPING[key.to_s.downcase]
+      entry&.fetch(:format, nil)
     end
   end
 end

data/lib/grape_oas/exporter/oas2_schema.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "concerns/tag_builder"
-require_relative "concerns/schema_indexer"
-
 module GrapeOAS
   module Exporter
     class OAS2Schema

data/lib/grape_oas/exporter/oas3/parameter.rb

@@ -17,6 +17,8 @@ module GrapeOAS
               "in" => param.location,
               "required" => param.required,
               "description" => param.description,
+              "style" => param.style,
+              "explode" => param.explode,
               "schema" => Schema.new(param.schema, @ref_tracker, nullable_keyword: @nullable_keyword).build
             }.compact
           end.presence

data/lib/grape_oas/exporter/oas3_schema.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "concerns/tag_builder"
-require_relative "concerns/schema_indexer"
-
 module GrapeOAS
   module Exporter
     class OAS3Schema

data/lib/grape_oas/introspectors/dry_introspector.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "dry_introspector_support/contract_resolver"
-require_relative "dry_introspector_support/inheritance_handler"
-require_relative "dry_introspector_support/type_schema_builder"
-
 module GrapeOAS
   module Introspectors
     # Introspector for Dry::Validation contracts and Dry::Schema.
@@ -92,16 +87,30 @@ module GrapeOAS
       end
 
       def build_flat_schema
-        rule_constraints = DryIntrospectorSupport::ConstraintExtractor.extract(contract_resolver.contract_schema)
+        contract_schema = contract_resolver.contract_schema
+
+        constraints_by_path, required_by_object_path =
+          DryIntrospectorSupport::RuleIndex.build(contract_schema)
+
+        type_schema_builder.configure_path_aware_mode(constraints_by_path, required_by_object_path)
+
         schema = ApiModel::Schema.new(
           type: Constants::SchemaTypes::OBJECT,
           canonical_name: contract_resolver.canonical_name,
         )
 
-        contract_resolver.contract_schema.types.each do |name, dry_type|
-          constraints = rule_constraints[name]
-          prop_schema = type_schema_builder.build_schema_for_type(dry_type, constraints)
-          schema.add_property(name, prop_schema, required: type_schema_builder.required?(dry_type, constraints))
+        root_required = required_by_object_path.fetch("", [])
+
+        contract_schema.types.each do |name, dry_type|
+          name_s = name.to_s
+          prop_schema = nil
+
+          type_schema_builder.with_path(name_s) do
+            prop_schema = type_schema_builder.build_schema_for_type(dry_type,
+                                                                    type_schema_builder.constraints_for_current_path,)
+          end
+
+          schema.add_property(name, prop_schema, required: root_required.include?(name_s))
         end
 
         # Use canonical_name as registry key for schema objects (they don't have unique classes),

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

@@ -7,6 +7,15 @@ module GrapeOAS
       module ArgumentExtractor
         module_function
 
+        # AST node tags for collection predicates (included_in?, excluded_from?)
+        LIST_TAGS = %i[list set].freeze
+        # AST node tags for literal value wrappers
+        LITERAL_TAGS = %i[value val literal class left right].freeze
+        # AST node tags for regex patterns
+        PATTERN_TAGS = %i[regexp regex].freeze
+        # Maximum size for converting ranges to enum arrays
+        MAX_ENUM_RANGE_SIZE = 100
+
         def extract_numeric(arg)
           return arg if arg.is_a?(Numeric)
           return arg[1] if arg.is_a?(Array) && arg.size == 2 && arg.first == :num
@@ -17,20 +26,56 @@ module GrapeOAS
         def extract_range(arg)
           return arg if arg.is_a?(Range)
           return arg[1] if arg.is_a?(Array) && arg.first == :range
+          return arg[1] if arg.is_a?(Array) && arg.first == :size && arg[1].is_a?(Range)
+          # Handle [:list, range] from included_in? predicates
+          return arg[1] if list_node?(arg) && arg[1].is_a?(Range)
 
           nil
         end
 
         def extract_list(arg)
-          return arg[1] if arg.is_a?(Array) && %i[list set].include?(arg.first)
+          if list_node?(arg)
+            inner = arg[1]
+            # For non-numeric ranges (e.g., 'a'..'z'), expand to array
+            # Numeric ranges should use min/max constraints instead
+            return range_to_enum_array(inner) if inner.is_a?(Range)
+
+            return inner
+          end
           return arg if arg.is_a?(Array)
+          return range_to_enum_array(arg) if arg.is_a?(Range)
 
           nil
         end
 
+        # Converts a non-numeric bounded Range to an array for enum values.
+        # Returns nil for numeric ranges (should use min/max instead).
+        # Returns nil for unbounded (endless/beginless) or excessively large ranges.
+        def range_to_enum_array(range)
+          # Reject unbounded ranges (endless/beginless)
+          return nil if range.begin.nil? || range.end.nil?
+
+          # Numeric ranges should use min/max constraints, not enum
+          return nil if range.begin.is_a?(Numeric) || range.end.is_a?(Numeric)
+
+          # Use bounded iteration to avoid memory exhaustion on large ranges.
+          # Take one more than max to detect oversized ranges without full enumeration.
+          begin
+            array = range.take(MAX_ENUM_RANGE_SIZE + 1)
+          rescue TypeError
+            # Range can't be iterated (e.g., non-discrete types)
+            return nil
+          end
+
+          # Reject ranges exceeding the size limit
+          return nil if array.size > MAX_ENUM_RANGE_SIZE
+
+          array
+        end
+
         def extract_literal(arg)
           return arg unless arg.is_a?(Array)
-          return arg[1] if arg.length == 2 && %i[value val literal class left right].include?(arg.first)
+          return arg[1] if arg.length == 2 && LITERAL_TAGS.include?(arg.first)
           return extract_literal(arg.first) if arg.first.is_a?(Array)
 
           arg
@@ -38,13 +83,19 @@ module GrapeOAS
 
         def extract_pattern(arg)
           return arg.source if arg.is_a?(Regexp)
-          return arg[1].source if arg.is_a?(Array) && arg.first == :regexp && arg[1].is_a?(Regexp)
-          return arg[1] if arg.is_a?(Array) && arg.first == :regexp && arg[1].is_a?(String)
-          return arg[1].source if arg.is_a?(Array) && arg.first == :regex && arg[1].is_a?(Regexp)
-          return arg[1] if arg.is_a?(Array) && arg.first == :regex && arg[1].is_a?(String)
+
+          if arg.is_a?(Array) && PATTERN_TAGS.include?(arg.first)
+            return arg[1].source if arg[1].is_a?(Regexp)
+            return arg[1] if arg[1].is_a?(String)
+          end
 
           nil
         end
+
+        # Helper to check if arg is a list/set AST node
+        def list_node?(arg)
+          arg.is_a?(Array) && LIST_TAGS.include?(arg.first)
+        end
       end
     end
   end

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

@@ -68,15 +68,27 @@ module GrapeOAS
         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_schema = @contract_resolver.contract_schema
 
-          @contract_resolver.contract_schema.types.each do |name, dry_type|
+          constraints_by_path, required_by_object_path =
+            RuleIndex.build(contract_schema)
+
+          type_schema_builder.configure_path_aware_mode(constraints_by_path, required_by_object_path)
+          root_required = required_by_object_path.fetch("", [])
+
+          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))
+            name_s = name.to_s
+            prop_schema = nil
+
+            type_schema_builder.with_path(name_s) do
+              prop_schema = type_schema_builder.build_schema_for_type(dry_type,
+                                                                      type_schema_builder.constraints_for_current_path,)
+            end
+
+            child_schema.add_property(name, prop_schema, required: root_required.include?(name_s))
           end
 
           child_schema