grape-oas 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb455b84bab348e43f6f512e31a9c306ec7deb76ddb5e6267231a3c7495615e7
-  data.tar.gz: 7096893822180fa7da1976ebbc7b20eaea31108aa8829595d2f4b4764e7350da
+  metadata.gz: 2d771c74ede3e601d65419900f26aa0ad36d785a649e09184a9e6755f4749fe7
+  data.tar.gz: 55bef62d1b83ccbd6f57cc469ec6ff81aea4b00c38fef892542fa5bc2f0588b0
 SHA512:
-  metadata.gz: 3cd2cb8c1c03fc8c14c427eb247de87d2a7cc782be02e41bc435e1f400a6eb0d1972dd1ea51e6c8e11f6854b4c4d646692fb80191db9d68b65e4e271604c3772
-  data.tar.gz: ba055b0ad8596358370103f503f009c80a6dd8395983077b6a1573aab4798c9bd5b5fa1d872c6210a57892151ef70d2a19538d3629823f076322e56274e8be4e
+  metadata.gz: 9d3f8cc1eeee662d60fdd0574970ed350416dcc9770df2536b7d7d7f017292bcc4338f47cb203cd2d486189d32d614b56d12c74efa83f4c52eabfb69df171b0d
+  data.tar.gz: 86d67570e32b7aafa0290963801c2b0f673fce6d1dde815b93cc2fd5ee8794c898541987382b7910b217e62b58807fdd5f9a6e940d427f82371a23b9ecbfaf84

data/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.6.0] - 2026-09-21
+
+### Added
+
+- [#89](https://github.com/numbata/grape-oas/pull/89): Add `GrapeOAS.entity_exposure_required_default` to make entity exposures without explicit required metadata optional in generated schemas - [@abeljim8am](https://github.com/abeljim8am).
+
+### Fixed
+
+- [#158](https://github.com/numbata/grape-oas/pull/158): Emit bare item references for nullable arrays of entities instead of redundant `allOf` wrappers - [@numbata](https://github.com/numbata).
+- [#72](https://github.com/numbata/grape-oas/pull/72): Infer `201` for POST success responses without an explicit status; honor entity `default_status:` for all methods, omitting content for bodyless statuses - [@olivier-thatch](https://github.com/olivier-thatch).
+- [#154](https://github.com/numbata/grape-oas/pull/154): Keep nullable enum members aligned with the emitted null representation across OAS versions - [@numbata](https://github.com/numbata).
+- [#153](https://github.com/numbata/grape-oas/pull/153): Reject colliding schema reference names instead of silently overwriting definitions - [@numbata](https://github.com/numbata).
+- [#106](https://github.com/numbata/grape-oas/pull/106): Apply `nullable` to the array, not its items, on `is_array: true` entity exposures - [@olivier-thatch](https://github.com/olivier-thatch).
+
+### Changed
+
+- [#155](https://github.com/numbata/grape-oas/pull/155): Fail generation when explicit `models:` entries cannot be resolved or introspected instead of silently omitting them - [@numbata](https://github.com/numbata).
+
 ## [1.5.1] - 2026-09-16
 
 ### Fixed

data/UPGRADING.md

@@ -1,5 +1,43 @@
 # Upgrading grape-oas
 
+### Upgrading to >= 1.6.0
+
+#### Schema reference-name collisions stop generation
+
+Distinct schemas that map to the same OAS reference name now raise
+`ArgumentError` instead of silently overwriting one schema. The error identifies
+both canonical names and the shared reference name.
+
+Rename one of the schemas or configure a mapping that produces unique names for
+your application. For example, dots distinguish Ruby namespaces from underscores
+while remaining valid in OAS reference names:
+
+```ruby
+GrapeOAS.schema_ref_name = ->(name) { name.gsub("::", ".") }
+```
+
+#### Invalid explicit models stop generation
+
+Entries passed through `models:` that cannot be resolved or introspected now
+stop generation instead of silently disappearing from the generated document.
+Exceptions from custom introspectors propagate with their original type and
+backtrace.
+
+Check model names, remove unsupported entries, and fix errors raised by custom
+introspectors before generating the document again.
+
+#### POST success responses use consistent defaults
+
+POST `success:` declarations without an explicit response code or
+`default_status:` now infer status `201`. Entity response paths that previously
+hardcoded `200` now use the same precedence. Undocumented POST responses already
+inferred `201`.
+
+If a POST endpoint returns `200`, set `code: 200` in the response declaration or
+`default_status: 200` on the route. Explicit response codes take precedence over
+`default_status:`. Entity responses now honor `default_status:` for every HTTP
+method; bodyless statuses such as `204` omit response content.
+
 ### Upgrading to >= 1.5.0
 
 When upgrading from 1.4.0, regenerate your OpenAPI documents and review the diff before regenerating clients.

data/lib/grape_oas/api_model_builder.rb

@@ -54,11 +54,12 @@ module GrapeOAS
     def build_registered_schemas(models)
       return [] unless models
 
-      Array(models).filter_map do |model|
+      Array(models).map do |model|
         model = model.constantize if model.is_a?(String)
-        GrapeOAS.introspectors.build_schema(model, stack: [], registry: {})
-      rescue StandardError
-        nil
+        schema = GrapeOAS.introspectors.build_schema(model, stack: [], registry: {})
+        raise ArgumentError, "No introspector can build a schema for #{model.inspect}" unless schema
+
+        schema
       end
     end
   end

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

@@ -61,6 +61,12 @@ module GrapeOAS
 
           hash.transform_keys { |k| k.is_a?(String) ? k.to_sym : k }
         end
+
+        def default_response_code(route, success:)
+          return route.options[:default_status] if route.options[:default_status]
+
+          success && route.request_method.to_s.upcase == "POST" ? 201 : 200
+        end
       end
     end
   end

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

@@ -3,8 +3,9 @@
 module GrapeOAS
   module ApiModelBuilders
     module ResponseParsers
-      # Parser that creates a default 200 response when no responses are defined
-      # This is the fallback parser used when no other parsers are applicable
+      # Parser that creates a default success response when no responses are defined.
+      # Status code defaults to 201 for POST routes and 200 for all other methods.
+      # This is the fallback parser used when no other parsers are applicable.
       class DefaultResponseParser
         include Base
 
@@ -14,12 +15,8 @@ module GrapeOAS
         end
 
         def parse(route)
-          inferred = route.options[:default_status]
-          inferred ||= route.request_method.to_s.upcase == "POST" ? 201 : 200
-          default_code = inferred.to_s
-
           [{
-            code: default_code,
+            code: default_response_code(route, success: true).to_s,
             message: "Success",
             entity: route.options[:entity],
             headers: nil

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

@@ -58,7 +58,7 @@ module GrapeOAS
           return [] unless data.is_a?(Hash)
 
           specs = %i[http_codes failure success].flat_map do |key|
-            parse_value(data[key], route)
+            parse_value(data[key], route, success: key == :success)
           end
           default_value = data[:default_response] || data[:default]
           return specs unless default_value
@@ -112,10 +112,10 @@ module GrapeOAS
           one_of.map { |entry| normalize_hash_keys(entry) }
         end
 
-        def parse_value(value, route)
+        def parse_value(value, route, success:)
           return [] unless value
 
-          entries_for(value).map { |entry| normalize_entry(entry, route) }
+          entries_for(value).map { |entry| normalize_entry(entry, route, success: success) }
         end
 
         def entries_for(value)
@@ -149,6 +149,9 @@ module GrapeOAS
         end
 
         def append_entity_spec(specs, entity_value, route)
+          explicit_code = (entity_value[:code] if entity_value.is_a?(Hash)) || route.options[:default_status]
+          return specs if !explicit_code && specs.any? { |spec| spec[:code] == "2XX" || (200..299).cover?(spec[:code].to_i) }
+
           entity_spec = build_entity_spec(entity_value, route)
           return specs if specs.any? { |spec| spec[:code].to_i == entity_spec[:code].to_i }
 
@@ -159,7 +162,7 @@ module GrapeOAS
           if entity_value.is_a?(Hash)
             # Hash format: { code: 201, model: Entity, message: "Created" }
             {
-              code: entity_value[:code] || 200,
+              code: entity_value[:code] || default_response_code(route, success: true),
               message: entity_value[:message],
               entity: extract_entity(entity_value, nil),
               headers: entity_value[:headers],
@@ -172,7 +175,7 @@ module GrapeOAS
           else
             # Plain entity class
             {
-              code: 200,
+              code: default_response_code(route, success: true),
               message: nil,
               entity: entity_value,
               headers: nil,
@@ -184,15 +187,15 @@ module GrapeOAS
           end
         end
 
-        def normalize_entry(entry, route)
+        def normalize_entry(entry, route, success:)
           spec = case entry
                  when Hash
-                   normalize_hash_entry(entry, route)
+                   normalize_hash_entry(entry, route, success: success)
                  when Array
                    normalize_array_entry(entry, route)
                  when Class, Module
                    # Plain entity class (e.g., success TestEntity)
-                   normalize_entity_entry(entry, route)
+                   normalize_entity_entry(entry, route, success: success)
                  else
                    normalize_plain_entry(entry, route)
                  end
@@ -200,10 +203,10 @@ module GrapeOAS
           spec
         end
 
-        def normalize_hash_entry(entry, route)
-          default_code = (route.options[:default_status] || 200).to_s
+        def normalize_hash_entry(entry, route, success:)
+          default_code = default_response_code(route, success: success)
           {
-            code: extract_status_code(entry, default_code),
+            code: extract_status_code(entry, default_code.to_s),
             message: extract_description(entry),
             entity: extract_entity(entry, route.options[:entity]),
             headers: entry[:headers],
@@ -228,10 +231,10 @@ module GrapeOAS
           }
         end
 
-        def normalize_entity_entry(entity_class, route)
+        def normalize_entity_entry(entity_class, route, success:)
           # Plain entity class (e.g., success TestEntity)
           {
-            code: route.options[:default_status] || 200,
+            code: default_response_code(route, success: success),
             message: nil,
             entity: entity_class,
             headers: nil,

data/lib/grape_oas/exporter/concerns/enum_normalizer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module GrapeOAS
+  module Exporter
+    module Concerns
+      module EnumNormalizer
+        private
+
+        def normalize_enum(enum_values, type, preserve_nil: false)
+          return nil unless enum_values.is_a?(Array)
+
+          base_type = base_type_for(type)
+          normalized = enum_values.each_with_object([]) do |value, values|
+            next if value.nil?
+
+            normalized_value = case base_type
+                               when Constants::SchemaTypes::INTEGER then value.to_i if value.respond_to?(:to_i)
+                               when Constants::SchemaTypes::NUMBER then value.to_f if value.respond_to?(:to_f)
+                               else value
+                               end
+            values << normalized_value unless normalized_value.nil?
+          end
+
+          normalized.uniq!
+          normalized << nil if preserve_nil && enum_values.include?(nil)
+          normalized unless normalized.empty?
+        end
+
+        def base_type_for(type)
+          type.is_a?(Array) ? (type - [Constants::SchemaTypes::NULL]).first : type
+        end
+      end
+    end
+  end
+end

data/lib/grape_oas/exporter/concerns/schema_indexer.rb

@@ -7,13 +7,30 @@ module GrapeOAS
       # Handles building schema indexes from operations and collecting nested schema references.
       module SchemaIndexer
         def find_schema_by_canonical_name(canonical_name)
-          @ref_schemas[canonical_name] || schema_index[canonical_name]
+          schema = @ref_schemas[canonical_name] || schema_index[canonical_name]
+          ensure_unique_schema_ref_name!(canonical_name) if schema
+          schema
         end
 
         def schema_index
           @schema_index ||= build_schema_index
         end
 
+        def ensure_unique_schema_ref_name!(canonical_name)
+          ref_name = GrapeOAS.schema_ref_name.call(canonical_name)
+          canonical_names_by_ref = @canonical_names_by_ref ||= {}
+          existing_name = canonical_names_by_ref[ref_name]
+
+          if existing_name && existing_name != canonical_name
+            raise ArgumentError,
+                  "Schema reference name #{ref_name.inspect} is generated for both " \
+                  "#{existing_name.inspect} and #{canonical_name.inspect}; " \
+                  "configure GrapeOAS.schema_ref_name to generate unique names"
+          end
+
+          canonical_names_by_ref[ref_name] = canonical_name
+        end
+
         def build_schema_index
           index = {}
           # Index schemas from operations

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

@@ -4,6 +4,8 @@ module GrapeOAS
   module Exporter
     module OAS2
       class Parameter
+        include Concerns::EnumNormalizer
+
         PRIMITIVE_MAPPINGS = {
           Constants::SchemaTypes::INTEGER => { type: Constants::SchemaTypes::INTEGER },
           "long" => { type: Constants::SchemaTypes::INTEGER, format: "int64" },
@@ -134,26 +136,6 @@ module GrapeOAS
           result["default"] = schema.default if schema.respond_to?(:default) && !schema.default.nil?
         end
 
-        def normalize_enum(enum_vals, type)
-          return nil unless enum_vals.is_a?(Array)
-
-          result = enum_vals.each_with_object([]) do |v, acc|
-            next if v.nil?
-
-            coerced_v = case type
-                        when Constants::SchemaTypes::INTEGER then v.to_i if v.respond_to?(:to_i)
-                        when Constants::SchemaTypes::NUMBER then v.to_f if v.respond_to?(:to_f)
-                        else v
-                        end
-            acc << coerced_v unless coerced_v.nil?
-          end
-
-          result.uniq!
-          return nil if result.empty?
-
-          result
-        end
-
         def apply_collection_format(result, param, schema)
           return unless schema.type == Constants::SchemaTypes::ARRAY
 

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

@@ -4,6 +4,8 @@ module GrapeOAS
   module Exporter
     module OAS2
       class Schema
+        include Concerns::EnumNormalizer
+
         def initialize(schema, ref_tracker = nil, nullable_strategy: nil, composition_extensions: false)
           @schema = schema
           @ref_tracker = ref_tracker
@@ -38,7 +40,7 @@ module GrapeOAS
             "description" => @schema.description&.to_s,
             "properties" => build_properties(@schema.properties)
           }
-          schema_hash["enum"] = normalize_enum(@schema.enum, @schema.type, nullable: nullable?) if @schema.enum
+          schema_hash["enum"] = normalize_enum(@schema.enum, @schema.type, preserve_nil: enum_allows_null?(@schema)) if @schema.enum
           if @schema.items
             schema_hash["items"] = build_schema_or_ref(@schema.items, include_metadata: false)
             if !schema_hash["description"] && @schema.items.respond_to?(:description) && @schema.items.description
@@ -99,6 +101,10 @@ module GrapeOAS
           schema_nullable?(@schema)
         end
 
+        def enum_allows_null?(schema)
+          @nullable_strategy == Constants::NullableStrategy::EXTENSION && schema_nullable?(schema)
+        end
+
         # OAS2 keeps a first-alternative fallback for tools that ignore extensions.
         def build_first_of_schema(composition_type)
           schemas = composition_type == :any_of ? @schema.any_of : @schema.one_of
@@ -130,7 +136,7 @@ module GrapeOAS
           result["format"] = @schema.format if @schema.format
           result["description"] = @schema.description.to_s if @schema.description
           result["default"] = @schema.default unless @schema.default.nil?
-          result["enum"] = normalize_enum(@schema.enum, @schema.type, nullable: nullable?) if @schema.enum
+          result["enum"] = normalize_enum(@schema.enum, @schema.type, preserve_nil: enum_allows_null?(@schema)) if @schema.enum
           result.delete("enum") if result.key?("enum") && result["enum"].nil?
           apply_constraints(result)
           apply_extensions(result)
@@ -156,7 +162,7 @@ module GrapeOAS
             result["x-nullable"] = true if @nullable_strategy == Constants::NullableStrategy::EXTENSION && schema_nullable?(schema)
             result["description"] = schema.description.to_s if schema.description
             result["default"] = schema.default unless schema.default.nil?
-            result["enum"] = normalize_enum(schema.enum, schema.type, nullable: schema_nullable?(schema)) if schema.enum
+            result["enum"] = normalize_enum(schema.enum, schema.type, preserve_nil: enum_allows_null?(schema)) if schema.enum
             result.delete("enum") if result.key?("enum") && result["enum"].nil?
             apply_constraints(result, schema)
             result.merge!(schema.extensions) if schema.extensions
@@ -175,29 +181,6 @@ module GrapeOAS
             built
           end
         end
-
-        def normalize_enum(enum_vals, type, nullable: false)
-          return nil unless enum_vals.is_a?(Array)
-
-          has_nil = nullable && enum_vals.include?(nil)
-
-          result = enum_vals.each_with_object([]) do |v, acc|
-            next if v.nil?
-
-            coerced_v = case type
-                        when Constants::SchemaTypes::INTEGER then v.to_i if v.respond_to?(:to_i)
-                        when Constants::SchemaTypes::NUMBER then v.to_f if v.respond_to?(:to_f)
-                        else v
-                        end
-            acc << coerced_v unless coerced_v.nil?
-          end
-
-          result.uniq!
-          result.push(nil) if has_nil
-          return nil if result.empty?
-
-          result
-        end
       end
     end
   end

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

@@ -4,6 +4,8 @@ module GrapeOAS
   module Exporter
     module OAS3
       class Schema
+        include Concerns::EnumNormalizer
+
         def initialize(schema, ref_tracker = nil, nullable_strategy: Constants::NullableStrategy::KEYWORD)
           @schema = schema
           @ref_tracker = ref_tracker
@@ -41,7 +43,11 @@ module GrapeOAS
 
           end
           schema_hash["required"] = @schema.required if @schema.required && !@schema.required.empty?
-          schema_hash["enum"] = normalize_enum(@schema.enum, schema_hash["type"], nullable: nullable?) if @schema.enum
+          if @schema.enum
+            schema_hash["enum"] = normalize_enum(
+              @schema.enum, schema_hash["type"], preserve_nil: enum_allows_null?(@schema, schema_hash["type"]),
+            )
+          end
           schema_hash["default"] = @schema.default unless @schema.default.nil?
           schema_hash
         end
@@ -88,7 +94,11 @@ module GrapeOAS
             if schema_nullable?(schema) && @nullable_strategy == Constants::NullableStrategy::TYPE_ARRAY
               enum_type = Array(enum_type) | ["null"]
             end
-            result["enum"] = normalize_enum(schema.enum, enum_type, nullable: schema_nullable?(schema)) if schema.enum
+            if schema.enum
+              result["enum"] = normalize_enum(
+                schema.enum, enum_type, preserve_nil: enum_allows_null?(schema, enum_type, null_union: true),
+              )
+            end
             sanitize_enum_against_type(result, type: schema.type)
             apply_all_constraints(result, schema)
             result.merge!(schema.extensions) if schema.extensions
@@ -110,12 +120,6 @@ module GrapeOAS
 
         private
 
-        # Returns the primary non-null type from a type value.
-        # Assumes at most one non-null type in the array (e.g. ["integer", "null"]).
-        def base_type_for(type)
-          type.is_a?(Array) ? (type - ["null"]).first : type
-        end
-
         # Rewrites `type: file` (or `type: ["file", "null"]`) to the
         # version-appropriate representation. Type detection lives here;
         # version-specific attributes are set by `apply_file_schema_attributes!`.
@@ -170,7 +174,11 @@ module GrapeOAS
           result["format"] = @schema.format if @schema.format
           result["description"] = @schema.description.to_s if @schema.description
           result["default"] = @schema.default unless @schema.default.nil?
-          result["enum"] = normalize_enum(@schema.enum, result["type"], nullable: nullable?) if @schema.enum
+          if @schema.enum
+            result["enum"] = normalize_enum(
+              @schema.enum, result["type"], preserve_nil: enum_allows_null?(@schema, result["type"], null_union: true),
+            )
+          end
           sanitize_enum_against_type(result)
           apply_all_constraints(result)
           apply_composition_extensions(result)
@@ -305,38 +313,17 @@ module GrapeOAS
           { "type" => Constants::SchemaTypes::OBJECT, "nullable" => true, "enum" => [nil] }
         end
 
-        def normalize_enum(enum_vals, type, nullable: false)
-          return nil unless enum_vals.is_a?(Array)
-
-          nullable = (nullable || (type.is_a?(Array) && type.include?(Constants::SchemaTypes::NULL))) &&
-                     enum_null_supported?(type)
-          resolved_type = base_type_for(type)
-
-          has_nil = nullable && enum_vals.include?(nil)
+        def enum_allows_null?(schema, type, null_union: false)
+          has_null_type = type.is_a?(Array) && type.include?(Constants::SchemaTypes::NULL)
 
-          result = enum_vals.each_with_object([]) do |v, acc|
-            next if v.nil?
-
-            coerced_v = case resolved_type
-                        when Constants::SchemaTypes::INTEGER then v.to_i if v.respond_to?(:to_i)
-                        when Constants::SchemaTypes::NUMBER then v.to_f if v.respond_to?(:to_f)
-                        else v
-                        end
-            acc << coerced_v unless coerced_v.nil?
+          case @nullable_strategy
+          when Constants::NullableStrategy::KEYWORD
+            has_null_type || (schema_nullable?(schema) && (!type.nil? || null_union))
+          when Constants::NullableStrategy::TYPE_ARRAY
+            has_null_type || (schema_nullable?(schema) && null_union)
+          else
+            false
           end
-
-          result.uniq!
-          result.push(nil) if has_nil
-          return nil if result.empty?
-
-          result
-        end
-
-        def enum_null_supported?(type)
-          return true if @nullable_strategy == Constants::NullableStrategy::KEYWORD
-
-          @nullable_strategy == Constants::NullableStrategy::TYPE_ARRAY &&
-            type.is_a?(Array) && type.include?(Constants::SchemaTypes::NULL)
         end
 
         def apply_numeric_constraints(hash, schema = @schema)

data/lib/grape_oas/introspectors/entity_introspector_support/exposure_processor.rb

@@ -118,7 +118,8 @@ module GrapeOAS
 
         # Determines whether a property should be marked required.
         # Explicit doc[:required] takes precedence; conditional exposures
-        # default to false; unconditional exposures default to true.
+        # default to false; unconditional exposures fall back to
+        # GrapeOAS.entity_exposure_required_default (default `true`).
         #
         # @param doc [Hash] normalized documentation hash
         # @param exposure the entity exposure
@@ -127,7 +128,7 @@ module GrapeOAS
           return doc[:required] unless doc[:required].nil?
           return false if conditional?(exposure)
 
-          true
+          GrapeOAS.entity_exposure_required_default
         end
 
         private
@@ -167,10 +168,28 @@ module GrapeOAS
           return prop_schema unless is_array
 
           array_schema = ApiModel::Schema.new(type: Constants::SchemaTypes::ARRAY, items: prop_schema)
+          if PropertyExtractor.extract_nullable(doc)
+            array_schema.nullable = true
+            if bare_single_ref_allof?(prop_schema)
+              array_schema.items = prop_schema.all_of.first
+            else
+              prop_schema.nullable = false
+            end
+          end
           array_schema.examples = doc[:example] if array_valued_example?(doc)
           array_schema
         end
 
+        def bare_single_ref_allof?(schema)
+          return false unless schema.all_of&.one? && schema.all_of.first.canonical_name
+
+          empty_schema = ApiModel::Schema.new
+          # Comparing defaults keeps future schema attributes from being discarded.
+          (ApiModel::Schema::VALID_ATTRIBUTES - %i[nullable all_of]).all? do |attribute|
+            schema.public_send(attribute) == empty_schema.public_send(attribute)
+          end
+        end
+
         # Detects block-based nesting exposures (NestingExposure) that should become
         # inline object schemas. Only triggers when no entity class is via `using:`.
         def nesting_exposure?(exposure)

data/lib/grape_oas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GrapeOAS
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end

data/lib/grape_oas.rb

@@ -91,6 +91,25 @@ module GrapeOAS
 
   module_function :logger, :logger=
 
+  # @return [Boolean] whether entity exposures without required metadata
+  #   default to required
+  def entity_exposure_required_default
+    return true if @entity_exposure_required_default.nil?
+
+    @entity_exposure_required_default
+  end
+
+  # @param value [true, false, nil] `nil` resets to the default (`true`)
+  def entity_exposure_required_default=(value)
+    unless value.nil? || value == true || value == false
+      raise ArgumentError, "entity_exposure_required_default must be true, false, or nil (got #{value.class})"
+    end
+
+    @entity_exposure_required_default = value
+  end
+
+  module_function :entity_exposure_required_default, :entity_exposure_required_default=
+
   # Returns the global introspector registry.
   #
   # The registry manages introspectors that build schemas from various sources

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape-oas
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Andrei Subbota
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-16 00:00:00.000000000 Z
+date: 2026-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -86,6 +86,7 @@ files:
 - lib/grape_oas/exporter.rb
 - lib/grape_oas/exporter/base/operation.rb
 - lib/grape_oas/exporter/base/paths.rb
+- lib/grape_oas/exporter/concerns/enum_normalizer.rb
 - lib/grape_oas/exporter/concerns/schema_indexer.rb
 - lib/grape_oas/exporter/concerns/tag_builder.rb
 - lib/grape_oas/exporter/oas2/operation.rb