grape-oas 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d956b648ef9686c13b90db7a16bba4038bf505ed069634131ade6cac17b3f8bf
-  data.tar.gz: 740148b7d4a9cb0d09675d53465a6e4b798b5c042245070b7de145401ac47820
+  metadata.gz: 6f97a967ef31212399ee7765f184a358e755b4364578cbc43d3fdaf75a919638
+  data.tar.gz: c56afb98329feaa1227d6ee252cbf5866ddc0144eac15dc6db8e34f9718d4731
 SHA512:
-  metadata.gz: a9e134fc9ad362b0b2aa505d7dcab8b24cf35697356365fda1d0bc20f081893b675811b2205aca46507aeb6da66ea547cee8bb3a01a5c6de301f097bb7990948
-  data.tar.gz: 3a2c13601c299600272d5ff3e5cccb648f658b61b0a3d1a8cf43c66b0bb35cadae8979f74bffd820ec217ccbd18e8eb65b25c28de9f6b4b67a1972914b524f92
+  metadata.gz: efed55aaa9f34d9045e495b2c8cbccea7b4da8381b4d2c58628e20785947319f42cc3a1e9952bac87219cb290cdbb81ac31bca7107acc3be3db13e027087c1ac
+  data.tar.gz: aa0eebcf7dd0b7122346150adfdf6e5dbfc8ed0287470ecedfe18ff9a95afca3376479899e0dc1e6298be3e65da3711238988b329839b4af68d48dd622bcd1f0

data/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - 2026-03-02
+
+### Added
+
+- [#36](https://github.com/numbata/grape-oas/pull/36): Add extensible TypeResolvers for resolving Grape's stringified parameter types to OpenAPI schemas with rich metadata (format, enum, nullable) - [@numbata](https://github.com/numbata).
+- [#37](https://github.com/numbata/grape-oas/pull/37): Replace boolean `nullable_keyword` with configurable `nullable_strategy` - [@numbata](https://github.com/numbata).
+
+### Fixed
+
+- [#41](https://github.com/numbata/grape-oas/pull/41): Fix `Set` enum values being silently dropped and `maybe(Coercible::Integer)` resolving to `string` instead of `integer` - [@numbata](https://github.com/numbata).
+- [#40](https://github.com/numbata/grape-oas/pull/40): Remove dead `spec[:allow_nil]` and `spec[:nullable]` checks from `extract_nullable` — these values were never set by Grape or grape-swagger - [@numbata](https://github.com/numbata).
+- [#39](https://github.com/numbata/grape-oas/pull/39): Support `documentation: { x: { nullable: true } }` on nested Hash params — nullable flag was ignored for object container schemas - [@numbata](https://github.com/numbata).
+- [#38](https://github.com/numbata/grape-oas/pull/38): Wrap `$ref` in `allOf` when `description` or `nullable` is present — fixes sibling properties being ignored per OpenAPI spec - [@numbata](https://github.com/numbata).
+- [#37](https://github.com/numbata/grape-oas/pull/37): Fix OAS 3.0 `nullable` keyword being constructed but not emitted in the generated output - [@numbata](https://github.com/numbata).
+
 ## [1.1.0] - 2026-01-23
 
 ### Added

data/lib/grape_oas/api_model/api.rb

@@ -11,7 +11,7 @@ module GrapeOAS
     class API < Node
       attr_accessor :title, :version, :paths, :servers, :tag_defs, :components,
                     :host, :base_path, :schemes, :security_definitions, :security,
-                    :registered_schemas, :suppress_default_error_response
+                    :registered_schemas, :suppress_default_error_response, :nullable_strategy
 
       def initialize(title:, version:)
         super()
@@ -28,6 +28,7 @@ module GrapeOAS
         @security = []
         @registered_schemas = []
         @suppress_default_error_response = false
+        @nullable_strategy = nil
       end
 
       def add_path(path)

data/lib/grape_oas/api_model_builder.rb

@@ -19,6 +19,7 @@ module GrapeOAS
       @api.servers = build_servers(options)
       @api.registered_schemas = build_registered_schemas(options[:models])
       @api.suppress_default_error_response = options[:suppress_default_error_response] || false
+      @api.nullable_strategy = options[:nullable_strategy]
 
       @namespace_filter = options[:namespace]
       @apis = []

data/lib/grape_oas/api_model_builders/concerns/type_resolver.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require "bigdecimal"
+begin
+  require "bigdecimal"
+rescue LoadError
+  # BigDecimal is an optional default gem dependency.
+end
 
 module GrapeOAS
   module ApiModelBuilders
@@ -8,11 +12,11 @@ module GrapeOAS
       # Centralizes Ruby type to OpenAPI schema type resolution.
       # Used by request builders and introspectors to avoid duplicated type switching logic.
       module TypeResolver
-        # Regex to match Grape's typed array notation like "[String]", "[Integer]"
-        TYPED_ARRAY_PATTERN = /^\[(\w+)\]$/
+        # Regex to match Grape's typed array notation like "[String]", "[Integer]", "[MyModule::MyType]"
+        TYPED_ARRAY_PATTERN = /\A\[(\w+(?:::\w+)*)\]\z/
 
         # Regex to match Grape's multi-type notation like "[String, Integer]", "[String, Float]"
-        MULTI_TYPE_PATTERN = /^\[(\w+(?:::\w+)*(?:,\s*\w+(?:::\w+)*)+)\]$/
+        MULTI_TYPE_PATTERN = /\A\[(\w+(?:::\w+)*(?:,\s*\w+(?:::\w+)*)+)\]\z/
 
         # Resolves a Ruby class or type name to its OpenAPI schema type string.
         # Handles both Ruby classes (Integer, Float) and string type names ("integer", "float").
@@ -27,7 +31,8 @@ module GrapeOAS
           # Handle Ruby classes directly
           if type.is_a?(Class)
             # Check static mapping first
-            return Constants::RUBY_TYPE_MAPPING[type] if Constants::RUBY_TYPE_MAPPING.key?(type)
+            mapped = Constants::RUBY_TYPE_MAPPING[type]
+            return mapped if mapped
 
             # Handle Grape::API::Boolean dynamically (may not be loaded at constant definition time)
             return Constants::SchemaTypes::BOOLEAN if grape_boolean_type?(type)

data/lib/grape_oas/api_model_builders/request.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "bigdecimal"
-
 module GrapeOAS
   module ApiModelBuilders
     class Request
@@ -202,162 +200,9 @@ module GrapeOAS
 
         # First try direct lookup (for Ruby class values like String, Integer)
         # Then try class-based lookup (for actual runtime values like "hello", 123)
-        Constants::RUBY_TYPE_MAPPING.fetch(value) do
-          Constants::RUBY_TYPE_MAPPING.fetch(value.class, Constants::SchemaTypes::STRING)
-        end
-      end
-
-      def schema_from_types(types_hash, rule_constraints)
-        schema = GrapeOAS::ApiModel::Schema.new(type: Constants::SchemaTypes::OBJECT)
-        types_hash.each do |name, dry_type|
-          prop_schema = schema_for_type(dry_type)
-          merge_rule_constraints(prop_schema, rule_constraints[name]) if rule_constraints[name]
-          required = true
-          required = false if dry_type.respond_to?(:optional?) && dry_type.optional?
-          required = false if dry_type.respond_to?(:meta) && dry_type.meta[:omittable]
-          schema.add_property(name, prop_schema, required: required)
-        end
-        schema
-      end
-
-      def schema_for_type(dry_type)
-        if dry_type.respond_to?(:primitive) && dry_type.primitive == Array && dry_type.respond_to?(:member)
-          items_schema = schema_for_type(dry_type.member)
-          schema = GrapeOAS::ApiModel::Schema.new(type: Constants::SchemaTypes::ARRAY, items: items_schema)
-          apply_array_meta_constraints(schema, dry_type.respond_to?(:meta) ? dry_type.meta : {})
-          return schema
-        end
-
-        primitive, member = derive_primitive_and_member(dry_type)
-        if dry_type.respond_to?(:primitive) && dry_type.primitive == Array
-          member ||= dry_type.respond_to?(:member) ? dry_type.member : nil
-          primitive = Array
-        end
-        meta = dry_type.respond_to?(:meta) ? dry_type.meta : {}
-        nullable = dry_type.respond_to?(:optional?) && dry_type.optional?
-        enum_vals = dry_type.respond_to?(:values) ? dry_type.values : nil
-
-        schema = if primitive == Array
-                   items_schema = member ? schema_for_type(member) : default_string_schema
-                   s = GrapeOAS::ApiModel::Schema.new(type: Constants::SchemaTypes::ARRAY, items: items_schema)
-                   apply_array_meta_constraints(s, meta)
-                   s
-                 else
-                   build_schema_for_primitive(primitive)
-                 end
-
-        schema.nullable = nullable
-        schema.enum = enum_vals if enum_vals
-        apply_string_meta_constraints(schema, meta) if primitive == String
-        apply_numeric_meta_constraints(schema, meta) if [Integer, Float, BigDecimal].include?(primitive)
-        schema
-      end
-
-      def derive_primitive_and_member(dry_type)
-        if defined?(Dry::Types::Array::Member) && dry_type.respond_to?(:type) && dry_type.type.is_a?(Dry::Types::Array::Member)
-          return [Array, dry_type.type.member]
-        end
-
-        return [Array, dry_type.member] if dry_type.respond_to?(:member)
-
-        primitive = dry_type.respond_to?(:primitive) ? dry_type.primitive : nil
-        [primitive, nil]
-      end
-
-      def apply_string_meta_constraints(schema, meta)
-        min_length = extract_min_constraint(meta)
-        max_length = extract_max_constraint(meta)
-        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_constraints(schema, meta)
-        min_items = extract_min_constraint(meta, :min_items)
-        max_items = extract_max_constraint(meta, :max_items)
-        schema.min_items = min_items if min_items
-        schema.max_items = max_items if max_items
-      end
-
-      # Extract minimum constraint, supporting multiple key names
-      def extract_min_constraint(meta, specific_key = :min_length)
-        meta[:min_size] || meta[specific_key]
-      end
-
-      # Extract maximum constraint, supporting multiple key names
-      def extract_max_constraint(meta, specific_key = :max_length)
-        meta[:max_size] || meta[specific_key]
-      end
-
-      def apply_numeric_meta_constraints(schema, 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 merge_rule_constraints(schema, rule_constraints)
-        return unless rule_constraints
-
-        schema.enum ||= rule_constraints[:enum]
-        schema.nullable ||= rule_constraints[:nullable]
-        schema.min_length ||= rule_constraints[:min] if rule_constraints[:min]
-        schema.max_length ||= rule_constraints[:max] if rule_constraints[:max]
-        schema.minimum ||= rule_constraints[:minimum] if rule_constraints[:minimum]
-        schema.maximum ||= rule_constraints[:maximum] if rule_constraints[:maximum]
-        schema.exclusive_minimum ||= rule_constraints[:exclusive_minimum]
-        schema.exclusive_maximum ||= rule_constraints[:exclusive_maximum]
-      end
-
-      # Very small parser for FakeType rule_ast used in tests
-      def extract_rule_constraints(schema_obj)
-        return {} unless schema_obj.respond_to?(:rules)
-
-        # Only supports FakeSchema/FakeType used in tests
-        constraints = Hash.new { |h, k| h[k] = {} }
-        if schema_obj.respond_to?(:types)
-          schema_obj.types.each do |name, dry_type|
-            next unless dry_type.respond_to?(:rule_ast)
-
-            rules = dry_type.rule_ast
-            Array(rules).each do |rule|
-              next unless rule.is_a?(Array)
-
-              _, pred = rule
-              next unless pred.is_a?(Array)
-
-              pname, pargs = pred
-              case pname
-              when :size?
-                min, max = Array(pargs).first
-                constraints[name][:min] = min
-                constraints[name][:max] = max
-              when :maybe
-                constraints[name][:nullable] = true
-              end
-            end
-          end
-        end
-        constraints
-      rescue NoMethodError, TypeError
-        {}
-      end
-
-      def extract_enum_from_core_values(core)
-        return unless core.respond_to?(:values)
-
-        vals = core.values
-        vals if vals.is_a?(Array)
-      rescue NoMethodError
-        nil
+        Constants::RUBY_TYPE_MAPPING[value] ||
+          Constants::RUBY_TYPE_MAPPING[value.class] ||
+          Constants::SchemaTypes::STRING
       end
 
       def convert_contract_schema_to_params(schema)

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

@@ -148,6 +148,8 @@ module GrapeOAS
           schema.unevaluated_properties = doc[:unevaluated_properties] if doc.key?(:unevaluated_properties)
           schema.format = doc[:format] if doc[:format]
           schema.examples = doc[:example] if doc[:example]
+          nullable = SchemaEnhancer.extract_nullable(doc)
+          schema.nullable = (schema.nullable || nullable) if schema.respond_to?(:nullable=)
         end
       end
     end

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

@@ -37,9 +37,13 @@ module GrapeOAS
           return build_entity_schema(raw_type) if grape_entity?(raw_type)
           return build_elements_array_schema(spec) if array_with_elements?(raw_type, spec)
           return build_multi_type_schema(raw_type) if multi_type?(raw_type)
-          return build_typed_array_schema(raw_type) if typed_array?(raw_type)
           return build_simple_array_schema if simple_array?(raw_type)
 
+          # Use TypeResolvers registry for arrays, Dry::Types, and primitives
+          # This resolves stringified types back to actual classes and extracts rich metadata
+          resolved_schema = GrapeOAS.type_resolvers.build_schema(raw_type)
+          return resolved_schema if resolved_schema
+
           build_primitive_schema(raw_type, doc)
         end
 
@@ -170,29 +174,11 @@ module GrapeOAS
           !!resolve_entity_class(type)
         end
 
-        # Checks if type is a Grape typed array notation like "[String]"
-        def typed_array?(type)
-          type.is_a?(String) && type.match?(TYPED_ARRAY_PATTERN)
-        end
-
         # Checks if type is a simple Array (class or string)
         def simple_array?(type)
           type == Array || type.to_s == "Array"
         end
 
-        # Builds schema for Grape's typed array notation like "[String]", "[Integer]"
-        def build_typed_array_schema(type)
-          member_type = extract_typed_array_member(type)
-          items_type = resolve_schema_type(member_type)
-          ApiModel::Schema.new(
-            type: Constants::SchemaTypes::ARRAY,
-            items: ApiModel::Schema.new(
-              type: items_type,
-              format: Constants.format_for_type(member_type),
-            ),
-          )
-        end
-
         def resolve_entity_class(type)
           return nil unless defined?(Grape::Entity)
           return type if type.is_a?(Class) && type <= Grape::Entity

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

@@ -11,7 +11,7 @@ module GrapeOAS
         # @param spec [Hash] the parameter specification
         # @param doc [Hash] the documentation hash
         def self.apply(schema, spec, doc)
-          nullable = extract_nullable(spec, doc)
+          nullable = extract_nullable(doc)
 
           schema.description ||= doc[:desc]
           # Preserve existing nullable: true (e.g., from [Type, Nil] optimization)
@@ -23,13 +23,12 @@ module GrapeOAS
           apply_values(schema, spec)
         end
 
-        # Extracts nullable flag from spec and documentation.
+        # Extracts nullable flag from a documentation hash.
         #
-        # @param spec [Hash] the parameter specification
         # @param doc [Hash] the documentation hash
         # @return [Boolean] true if nullable
-        def self.extract_nullable(spec, doc)
-          spec[:allow_nil] || spec[:nullable] || doc[:nullable] || false
+        def self.extract_nullable(doc)
+          doc[:nullable] || (doc[:x].is_a?(Hash) && doc[:x][:nullable]) || false
         end
 
         class << self
@@ -82,8 +81,9 @@ module GrapeOAS
 
             if values.is_a?(Range)
               apply_range_values(schema, values)
-            elsif values.is_a?(Array) && values.any?
-              apply_enum_values(schema, values)
+            else
+              enum_values = defined?(Set) && values.is_a?(Set) ? values.to_a : values
+              apply_enum_values(schema, enum_values) if enum_values.is_a?(Array) && enum_values.any?
             end
           end
 

data/lib/grape_oas/constants.rb

@@ -35,6 +35,18 @@ module GrapeOAS
       ALL = [JSON, XML, FORM_URLENCODED, MULTIPART_FORM].freeze
     end
 
+    # Nullable representation strategies for different OpenAPI versions.
+    # Passed via `nullable_strategy:` option to control how nullable fields
+    # are represented in the generated schema.
+    module NullableStrategy
+      # OAS 3.0: emits `"nullable": true` alongside the type
+      KEYWORD = :keyword
+      # OAS 3.1: emits `"type": ["string", "null"]` (JSON Schema style)
+      TYPE_ARRAY = :type_array
+      # OAS 2.0: emits `"x-nullable": true` extension
+      EXTENSION = :extension
+    end
+
     # Default values for OpenAPI spec when not provided by user
     module Defaults
       LICENSE_NAME = "Proprietary"
@@ -49,13 +61,16 @@ module GrapeOAS
     RUBY_TYPE_MAPPING = {
       Integer => SchemaTypes::INTEGER,
       Float => SchemaTypes::NUMBER,
-      BigDecimal => SchemaTypes::NUMBER,
       TrueClass => SchemaTypes::BOOLEAN,
       FalseClass => SchemaTypes::BOOLEAN,
       Array => SchemaTypes::ARRAY,
       Hash => SchemaTypes::OBJECT,
       File => SchemaTypes::FILE
-    }.freeze
+    }.tap do |mapping|
+      mapping.default_proc = lambda do |_hash, key|
+        key.is_a?(Class) && key.to_s == "BigDecimal" ? SchemaTypes::NUMBER : nil
+      end
+    end.freeze
 
     # String type name to schema type and format mapping (lowercase).
     # Supports lookup with any case via primitive_type helper.

data/lib/grape_oas/exporter/oas2/operation.rb

@@ -10,11 +10,13 @@ module GrapeOAS
 
         # OAS2-specific fields: consumes, produces, parameters (including body)
         def build_version_specific_fields
+          strategy = @options[:nullable_strategy]
+
           {
             "consumes" => consumes,
             "produces" => produces,
-            "parameters" => Parameter.new(@op, @ref_tracker).build,
-            "responses" => Response.new(@op.responses, @ref_tracker).build
+            "parameters" => Parameter.new(@op, @ref_tracker, nullable_strategy: strategy).build,
+            "responses" => Response.new(@op.responses, @ref_tracker, nullable_strategy: strategy).build
           }
         end
 

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

@@ -18,9 +18,10 @@ module GrapeOAS
           "uuid" => { type: Constants::SchemaTypes::STRING, format: "uuid" }
         }.freeze
 
-        def initialize(operation, ref_tracker = nil)
+        def initialize(operation, ref_tracker = nil, nullable_strategy: nil)
           @op = operation
           @ref_tracker = ref_tracker
+          @nullable_strategy = nullable_strategy
         end
 
         def build
@@ -140,7 +141,7 @@ module GrapeOAS
             ref_name = schema.canonical_name.gsub("::", "_")
             { "$ref" => "#/definitions/#{ref_name}" }
           else
-            Schema.new(schema, @ref_tracker).build
+            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
           end
         end
       end

data/lib/grape_oas/exporter/oas2/paths.rb

@@ -11,6 +11,7 @@ module GrapeOAS
         # Build OAS2-specific operation
         def build_operation(operation)
           Operation.new(operation, @ref_tracker,
+                        nullable_strategy: @options[:nullable_strategy],
                         suppress_default_error_response: @options[:suppress_default_error_response],).build
         end
       end

data/lib/grape_oas/exporter/oas2/response.rb

@@ -4,9 +4,10 @@ module GrapeOAS
   module Exporter
     module OAS2
       class Response
-        def initialize(responses, ref_tracker = nil)
+        def initialize(responses, ref_tracker = nil, nullable_strategy: nil)
           @responses = responses
           @ref_tracker = ref_tracker
+          @nullable_strategy = nullable_strategy
         end
 
         def build
@@ -36,7 +37,7 @@ module GrapeOAS
             ref_name = schema.canonical_name.gsub("::", "_")
             { "$ref" => "#/definitions/#{ref_name}" }
           else
-            Schema.new(schema, @ref_tracker).build
+            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
           end
         end
 

data/lib/grape_oas/exporter/oas2/schema.rb

@@ -4,9 +4,10 @@ module GrapeOAS
   module Exporter
     module OAS2
       class Schema
-        def initialize(schema, ref_tracker = nil)
+        def initialize(schema, ref_tracker = nil, nullable_strategy: nil)
           @schema = schema
           @ref_tracker = ref_tracker
+          @nullable_strategy = nullable_strategy
         end
 
         def build
@@ -57,11 +58,16 @@ module GrapeOAS
         end
 
         def apply_extensions(schema_hash)
+          schema_hash["x-nullable"] = true if @nullable_strategy == Constants::NullableStrategy::EXTENSION && nullable?
           schema_hash.merge!(@schema.extensions) if @schema.extensions
         end
 
         private
 
+        def nullable?
+          @schema.respond_to?(:nullable) && @schema.nullable
+        end
+
         # Build schema from oneOf/anyOf by using first type (OAS2 doesn't support these)
         # Extensions are merged to allow x-anyOf/x-oneOf for consumers that support them
         def build_first_of_schema(composition_type)
@@ -100,9 +106,20 @@ module GrapeOAS
           if schema.respond_to?(:canonical_name) && schema.canonical_name
             @ref_tracker << schema.canonical_name if @ref_tracker
             ref_name = schema.canonical_name.gsub("::", "_")
-            { "$ref" => "#/definitions/#{ref_name}" }
+            ref_hash = { "$ref" => "#/definitions/#{ref_name}" }
+            result = {}
+            if @nullable_strategy == Constants::NullableStrategy::EXTENSION && schema.respond_to?(:nullable) && schema.nullable
+              result["x-nullable"] = true
+            end
+            result["description"] = schema.description.to_s if schema.description
+            if result.empty?
+              ref_hash
+            else
+              result["allOf"] = [ref_hash]
+              result
+            end
           else
-            Schema.new(schema, @ref_tracker).build
+            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
           end
         end
 

data/lib/grape_oas/exporter/oas2_schema.rb

@@ -66,8 +66,13 @@ module GrapeOAS
         media_types.empty? ? [Constants::MimeTypes::JSON] : media_types
       end
 
+      def nullable_strategy
+        @api.nullable_strategy
+      end
+
       def build_paths
         OAS2::Paths.new(@api, @ref_tracker,
+                        nullable_strategy: nullable_strategy,
                         suppress_default_error_response: @api.suppress_default_error_response,).build
       end
 
@@ -82,7 +87,7 @@ module GrapeOAS
       end
 
       def build_schema(schema)
-        OAS2::Schema.new(schema, @ref_tracker).build
+        OAS2::Schema.new(schema, @ref_tracker, nullable_strategy: nullable_strategy).build
       end
 
       def build_definitions
@@ -103,7 +108,7 @@ module GrapeOAS
 
           ref_name = canonical_name.gsub("::", "_")
           schema = find_schema_by_canonical_name(canonical_name)
-          definitions[ref_name] = OAS2::Schema.new(schema, @ref_tracker).build if schema
+          definitions[ref_name] = OAS2::Schema.new(schema, @ref_tracker, nullable_strategy: nullable_strategy).build if schema
           collect_refs(schema, pending) if schema
 
           @ref_tracker.to_a.each do |cn|

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

@@ -10,12 +10,12 @@ module GrapeOAS
 
         # OAS3-specific fields: parameters (no body), requestBody, responses
         def build_version_specific_fields
-          nullable_keyword = @options.key?(:nullable_keyword) ? @options[:nullable_keyword] : true
+          strategy = @options[:nullable_strategy] || Constants::NullableStrategy::KEYWORD
 
           {
-            "parameters" => Parameter.new(@op, @ref_tracker, nullable_keyword: nullable_keyword).build,
-            "requestBody" => RequestBody.new(@op.request_body, @ref_tracker, nullable_keyword: nullable_keyword).build,
-            "responses" => Response.new(@op.responses, @ref_tracker, nullable_keyword: nullable_keyword).build
+            "parameters" => Parameter.new(@op, @ref_tracker, nullable_strategy: strategy).build,
+            "requestBody" => RequestBody.new(@op.request_body, @ref_tracker, nullable_strategy: strategy).build,
+            "responses" => Response.new(@op.responses, @ref_tracker, nullable_strategy: strategy).build
           }
         end
       end

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

@@ -4,10 +4,10 @@ module GrapeOAS
   module Exporter
     module OAS3
       class Parameter
-        def initialize(operation, ref_tracker = nil, nullable_keyword: true)
+        def initialize(operation, ref_tracker = nil, nullable_strategy: Constants::NullableStrategy::KEYWORD)
           @op = operation
           @ref_tracker = ref_tracker
-          @nullable_keyword = nullable_keyword
+          @nullable_strategy = nullable_strategy
         end
 
         def build
@@ -19,7 +19,7 @@ module GrapeOAS
               "description" => param.description,
               "style" => param.style,
               "explode" => param.explode,
-              "schema" => Schema.new(param.schema, @ref_tracker, nullable_keyword: @nullable_keyword).build
+              "schema" => Schema.new(param.schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
             }.compact
           end.presence
         end

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

@@ -8,11 +8,10 @@ module GrapeOAS
       class Paths < Base::Paths
         private
 
-        # Build OAS3-specific operation with nullable_keyword option
+        # Build OAS3-specific operation with nullable_strategy option
         def build_operation(operation)
-          nullable_keyword = @options.key?(:nullable_keyword) ? @options[:nullable_keyword] : true
           Operation.new(operation, @ref_tracker,
-                        nullable_keyword: nullable_keyword,
+                        nullable_strategy: @options[:nullable_strategy] || Constants::NullableStrategy::KEYWORD,
                         suppress_default_error_response: @options[:suppress_default_error_response],).build
         end
       end

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

@@ -4,10 +4,10 @@ module GrapeOAS
   module Exporter
     module OAS3
       class RequestBody
-        def initialize(request_body, ref_tracker = nil, nullable_keyword: true)
+        def initialize(request_body, ref_tracker = nil, nullable_strategy: Constants::NullableStrategy::KEYWORD)
           @request_body = request_body
           @ref_tracker = ref_tracker
-          @nullable_keyword = nullable_keyword
+          @nullable_strategy = nullable_strategy
         end
 
         def build
@@ -45,7 +45,7 @@ module GrapeOAS
             ref_name = schema.canonical_name.gsub("::", "_")
             { "$ref" => "#/components/schemas/#{ref_name}" }
           else
-            Schema.new(schema, @ref_tracker, nullable_keyword: @nullable_keyword).build
+            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
           end
         end
       end

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

@@ -4,10 +4,10 @@ module GrapeOAS
   module Exporter
     module OAS3
       class Response
-        def initialize(responses, ref_tracker = nil, nullable_keyword: true)
+        def initialize(responses, ref_tracker = nil, nullable_strategy: Constants::NullableStrategy::KEYWORD)
           @responses = responses
           @ref_tracker = ref_tracker
-          @nullable_keyword = nullable_keyword
+          @nullable_strategy = nullable_strategy
         end
 
         def build
@@ -76,7 +76,7 @@ module GrapeOAS
             ref_name = schema.canonical_name.gsub("::", "_")
             { "$ref" => "#/components/schemas/#{ref_name}" }
           else
-            Schema.new(schema, @ref_tracker, nullable_keyword: @nullable_keyword).build
+            Schema.new(schema, @ref_tracker, nullable_strategy: @nullable_strategy).build
           end
         end
       end