rails_ninja 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 437ec40dd224b486cc4b24755700f6b8a1bbb7c77e88dd3523760d59d1af5ff5
-  data.tar.gz: 28600e208c8c37a36d20243614abd2b8b0096a8e3abd1731e728740d466591eb
+  metadata.gz: 9ea5b2dadb986f6d8ccde0b94cef6e57a941cd5336a776182e3462afc15dcdd7
+  data.tar.gz: 344e6aa870b08bb554fc239cc0f5f583721c8fd73d2d0532a9206d01cbe47cf0
 SHA512:
-  metadata.gz: dfa8f772a93844aff65ffdc59bfbb67379a014f26cb0f73569fcdc3e909086b12d49219db008507065a985fc6a05b73ae3ed6588ba9ab234b36619200aafd7d9
-  data.tar.gz: ea13a4f5d9daee6f4cd80c493d55c7518e2d90e78861266e8e575e21617009fde4e3d26d1620c7f2bf42828d10a8937adb9251c269e4879ab3273a07f7f5991f
+  metadata.gz: 22c2dcadc5aba38d8847721739a8562b7266a54ef6ad286b6cd4e4d35508c5127c0731bac09331e9fd9b7e460c25e95e002ba4bd8f42470f4b978f34db06f2bb
+  data.tar.gz: 54889989cb0f46f6e0fb2e5745aa02786361a604cc2a5006d44737dbbfe4f677d12f4964d7106a2e748530a67478224e51567b627e6ca90f43ffd1c7e5f92f9c

data/README.md

@@ -5,7 +5,7 @@ Rails Ninja is a small Rails API framework inspired by
 request validation and response serialization, and generated OpenAPI
 documentation.
 
-Rails Ninja requires Ruby 3 or newer and Rails 7 or newer.
+Rails Ninja requires Ruby 3 or newer and Rails 7.1 or newer.
 
 ## Installation
 
@@ -103,8 +103,8 @@ end
 ```
 
 Fields are required by default. Available scalar types are `String`, `Int`,
-`Float`, and `Boolean` under `RailsNinja::Types`. A field may also contain a
-nested schema or a one-element array of a scalar or schema.
+`Float`, `Boolean`, and `File` under `RailsNinja::Types`. A field may also
+contain a nested schema or a one-element array of a scalar or schema.
 
 JSON input is strictly type-checked. Canonical path, query, and form values are
 decoded first, so an integer query value such as `"20"` becomes `20`. Invalid
@@ -114,6 +114,24 @@ into `params` as symbol keys.
 For `GET` and `DELETE`, a request schema is read from and documented as query
 parameters. `POST`, `PUT`, and `PATCH` use a request body.
 
+### File uploads
+
+```ruby
+schema :DocumentIn do
+  field :title, RailsNinja::Types::String
+  field :attachments, [RailsNinja::Types::File]
+  field :metadata, DocumentMetadata, required: false
+end
+```
+
+A request schema with a `File` field is documented as `multipart/form-data`
+and its values arrive as `ActionDispatch::Http::UploadedFile`. Arrays of files
+accept both `attachments[]` and repeated bare `attachments` parts, which is what
+OpenAPI generated clients send. Nested schema fields may be sent as JSON
+strings in their own part; they are validated with JSON types, not form
+coercion. `File` fields are only supported at the top level of a request
+schema and cannot appear in responses.
+
 Schemas may also be standalone:
 
 ```ruby
@@ -246,6 +264,73 @@ Deprecated paths remain routable and are marked as deprecated in OpenAPI.
 Set `server "https://api.example.com"` on an API to declare its server URL, or
 `docs false` to disable `/docs` and `/openapi.json`.
 
+## OpenAPI documentation in Ruby
+
+Declare descriptions, examples and parameter constraints next to the API schemas.
+The generator includes them in the JSON document without a separate overlay file.
+
+```ruby
+class InventoryApi < RailsNinja::API
+  title "Inventory API"
+  description "Read inventory records."
+  openapi_tag "Records", description: "Inventory records and their availability."
+
+  schema :Record, description: "One inventory record", example: { name: "Widget" } do
+    field :name, RailsNinja::Types::String,
+      description: "Display name", example: "Widget", openapi: { minLength: 1 }
+  end
+
+  schema :ReadError do
+    field :error, RailsNinja::Types::String, description: "Reason the read failed"
+  end
+
+  get "/records/:id",
+    operation_id: "getRecord",
+    summary: "Read an inventory record",
+    description: "Returns the record identified by the supplied ID.",
+    tags: ["Records"],
+    path_params: { id: { description: "Record ID", example: "123", schema: { pattern: "^[0-9]+$" } } },
+    responses: {
+      200 => Record,
+      429 => {
+        schema: ReadError,
+        description: "Wait before retrying the request.",
+        example: { error: "Too many requests" },
+        headers: { "Retry-After" => { description: "Seconds to wait", schema: { type: "integer" }, example: 1 } }
+      }
+    }
+  def read
+    # Fetch the record or render an error response.
+  end
+end
+```
+
+Schema classes can also declare `openapi description: ..., example: ...` inside
+their class body. Field `openapi:` accepts `format`, `pattern`, `minLength`,
+`maxLength`, `minimum`, `maximum`, `default`, `enum` and `oneOf`. These options
+describe constraints enforced by the application; they do not add runtime
+validation or change serialization. Field types and requiredness still come from
+the existing `field` declaration.
+
+GET, DELETE and HEAD request schemas supply query parameters. Their field
+descriptions and examples appear on the parameter, and their constraints appear
+in its schema. Header declarations accept `description:`, `example:` and
+`schema:` alongside `name:` and `required:`. Path annotations refer to the full
+mounted route, including parameters from a mount prefix. Path parameters remain
+required and retain their route names.
+
+For a request body, use `request_description:` on the endpoint. For each response,
+either keep the existing schema shorthand or supply a hash containing `schema:`
+and optional `description:`, `headers:` and `example:` or `examples:`. The two
+example forms are mutually exclusive. Named examples use OpenAPI Example Objects,
+for example `examples: { missing: { value: { error: "Not found" } } }`.
+Schemas can still be arrays or `one_of(...)` declarations.
+
+An explicit `operation_id:` keeps generated client method names stable when Ruby
+handler names change. Authors must choose unique IDs within each API document;
+deprecated route aliases omit the ID. API security descriptions belong in the
+existing `openapi_security_scheme` declaration.
+
 ## Static OpenAPI files
 
 Generate an OpenAPI 3.2 JSON file for every API:
@@ -270,7 +355,7 @@ bundle install
 bundle exec rake test
 ```
 
-CI tests every compatible combination of Action Pack and Active Support 7.0
+CI tests every compatible combination of Action Pack and Active Support 7.1
 through 8.1 with MRI Ruby 3.0 through 4.0. Each lane resolves the latest patch
 release in its minor series.
 

data/lib/rails_ninja/api.rb

@@ -23,6 +23,20 @@ module RailsNinja
         @_title
       end
 
+      def description(value = nil)
+        @_description = value unless value.nil?
+        @_description
+      end
+
+      def openapi_tag(name, description:)
+        _openapi_tags.reject! { |tag| tag[:name] == name.to_s }
+        _openapi_tags << { name: name.to_s, description: description }
+      end
+
+      def _openapi_tags
+        @_openapi_tags ||= []
+      end
+
       def version(value = nil)
         if value
           @_version = value
@@ -85,6 +99,8 @@ module RailsNinja
         super
         subclass.instance_variable_set(:@_openapi_security_schemes, _openapi_security_schemes.transform_values(&:dup))
         subclass.instance_variable_set(:@_openapi_security, _openapi_security.dup)
+        subclass.instance_variable_set(:@_openapi_tags, _openapi_tags.deep_dup)
+        subclass.instance_variable_set(:@_description, description&.dup)
         RailsNinja.registered_apis << subclass
       end
 
@@ -336,6 +352,8 @@ module RailsNinja
 
       if errors.empty?
         params.merge!(validated)
+        # Mounted groups / included endpoints run on their own instance with its own params
+        @_ninja_handler_instance&.params&.merge!(validated)
         return
       end
 
@@ -347,7 +365,9 @@ module RailsNinja
     def request_input(schema_class)
       path = decode_parameters(schema_class, request.path_parameters)
       query = decode_parameters(schema_class, request.query_parameters)
-      body = if FORM_MEDIA_TYPES.include?(request.media_type)
+      body = if request.media_type == "multipart/form-data"
+               Schema::ParameterDecoder.new(schema_class, multipart_parameters(schema_class), wrap_arrays: true).call
+             elsif FORM_MEDIA_TYPES.include?(request.media_type)
                decode_parameters(schema_class, request.request_parameters)
              else
                request.request_parameters.deep_symbolize_keys
@@ -356,6 +376,48 @@ module RailsNinja
       path.merge(query).merge(body)
     end
 
+    # Rack keeps only the last part when a multipart name repeats without "[]",
+    # but OpenAPI clients send arrays exactly that way ("files", "files").
+    # Re-parse the body so repeated bare names accumulate into arrays.
+    module RepeatedMultipartNames
+      def normalize_params(params, name, value, *rest)
+        return super unless params.key?(name) && !name.include?("[")
+
+        existing = params[name]
+        params[name] = existing.is_a?(Array) ? existing << value : [existing, value]
+        params
+      end
+    end
+
+    def multipart_parameters(schema_class)
+      rails_params = request.request_parameters
+      io = request.env["rack.input"]
+      # Rails' parse is already complete unless a list field could have lost repeated parts
+      list_fields = schema_class._fields.values.any? { |f| f.type.is_a?(Array) }
+      return rails_params if io.nil? || rails_params.empty? || !list_fields
+
+      parser = Rack::Utils.default_query_parser.dup.extend(RepeatedMultipartNames)
+
+      raw = if (pairs = request.env["rack.request.form_pairs"])
+              params = parser.make_params
+              pairs.each { |name, value| parser.normalize_params(params, name, value) }
+              params.to_params_hash
+            elsif io.respond_to?(:rewind)
+              io.rewind
+              # parse_multipart replaces the tempfile cleanup list; keep the ones from Rails' parse
+              earlier_tempfiles = Array(request.env["rack.tempfiles"])
+              parsed = Rack::Multipart.parse_multipart(request.env, parser) || {}
+              request.env["rack.tempfiles"] = earlier_tempfiles | Array(request.env["rack.tempfiles"])
+              parsed
+            else
+              raise Error, "multipart bodies need Rack >= 3.1 or a rewindable rack.input " \
+                           "(wrap the app in Rack::RewindableInput::Middleware)"
+            end
+
+      # Same step Rails applies to POST params: turns Rack's file hashes into UploadedFile.
+      ActionDispatch::Request::Utils.normalize_encode_params(raw)
+    end
+
     def decode_parameters(schema_class, parameters)
       Schema::ParameterDecoder.new(schema_class, parameters).call
     end

data/lib/rails_ninja/endpoint_group.rb

@@ -22,8 +22,9 @@ module RailsNinja
       end
 
       # Schema definition DSL
-      def schema(name, &block)
+      def schema(name, **documentation, &block)
         klass = Class.new(Schema::Base)
+        klass.openapi(**documentation)
         klass.class_eval(&block)
 
         # Register as a constant on this class so it's accessible by name

data/lib/rails_ninja/openapi/generator.rb

@@ -33,10 +33,12 @@ module RailsNinja
           components: components,
         }
         spec[:servers] = [{ url: @api_class._server }] if @api_class._server
+        spec[:info][:description] = @api_class.description if @api_class.description
+        spec[:tags] = @api_class._openapi_tags if @api_class._openapi_tags.any?
         if @api_class._openapi_security.any?
           spec[:security] = @api_class._openapi_security.map { |name| { name => [] } }
         end
-        spec
+        spec.deep_dup
       end
 
       def to_json(*_args)
@@ -79,18 +81,22 @@ module RailsNinja
             body_verb = %w[get delete head].exclude?(verb)
 
             operation = { summary: endpoint.summary }
+            operation[:description] = endpoint.description if endpoint.description
             operation[:tags] = endpoint.tags if endpoint.tags&.any?
             operation[:responses] = build_responses(endpoint)
             # Deprecated aliases share a handler with the primary endpoint; only the
             # current path carries the operationId to keep it unique across the spec.
-            operation[:operationId] = build_operation_id(endpoint) unless endpoint.deprecated?
+            operation[:operationId] = endpoint.operation_id || build_operation_id(endpoint) unless endpoint.deprecated?
             operation[:deprecated] = true if endpoint.deprecated?
 
             if endpoint.request_schema && body_verb
               operation[:requestBody] = build_request_body(endpoint.request_schema)
+              if endpoint.request_description
+                operation[:requestBody][:description] = endpoint.request_description
+              end
             end
 
-            params = extract_path_params(path) + extract_header_params(endpoint)
+            params = extract_path_params(path, endpoint.path_params) + extract_header_params(endpoint)
             params += extract_query_params(endpoint) unless body_verb
             operation[:parameters] = params if params.any?
 
@@ -113,6 +119,9 @@ module RailsNinja
             description: response_description_for(status),
             content: { "application/json" => { schema: schema_node } },
           }
+          documentation = endpoint.response_documentation.fetch(status, {})
+          out[status.to_s].merge!(documentation.slice(:description, :headers))
+          out[status.to_s][:content]["application/json"].merge!(documentation.slice(:example, :examples))
         end
       end
 
@@ -132,14 +141,32 @@ module RailsNinja
       end
 
       def build_request_body(schema)
-        {
-          required: true,
-          content: {
-            "application/json" => {
-              schema: schema_ref(schema),
-            },
-          },
-        }
+        multipart = schema._fields.values.any? { |f| file_type?(f.type) }
+        reject_nested_files!(schema)
+        media_type = multipart ? "multipart/form-data" : "application/json"
+
+        { required: true, content: { media_type => { schema: schema_ref(schema) } } }
+      end
+
+      def file_type?(type)
+        type = type.first if type.is_a?(Array)
+        type.is_a?(Class) && type <= Types::File
+      end
+
+      # Nested objects travel as JSON strings inside multipart, which cannot carry a file.
+      def reject_nested_files!(schema, path = [], seen = Set.new)
+        return unless seen.add?(schema)
+
+        schema._fields.each do |name, field|
+          nested = Array(field.type).first
+          next unless nested.is_a?(Class) && nested <= Schema::Base
+
+          if nested._fields.values.any? { |f| file_type?(f.type) }
+            raise Error, "File fields are only supported at the top level of a request schema " \
+                         "(found under #{(path + [name]).join('.')})"
+          end
+          reject_nested_files!(nested, path + [name], seen)
+        end
       end
 
       def schema_ref(type)
@@ -170,9 +197,16 @@ module RailsNinja
         end
       end
 
-      def extract_path_params(path)
-        path.scan(/:(\w+)/).flatten.map do |param|
-          { name: param, in: "path", required: true, schema: { type: "string" } }
+      def extract_path_params(path, documentation)
+        names = path.scan(/:(\w+)/).flatten
+        unknown = documentation.keys - names
+        raise ArgumentError, "Unknown path parameter annotations: #{unknown.join(', ')}" if unknown.any?
+
+        names.map do |param|
+          metadata = documentation.fetch(param, {})
+          { name: param, in: "path", required: true,
+            schema: { type: "string" }.merge(metadata.fetch(:schema, {})) }
+            .merge(metadata.slice(:description, :example))
         end
       end
 
@@ -180,7 +214,9 @@ module RailsNinja
         return [] unless endpoint.request_schema
 
         endpoint.request_schema._fields.map do |name, field|
-          { name: name.to_s, in: "query", required: field.required, schema: schema_ref(field.type) }
+          { name: name.to_s, in: "query", required: field.required,
+            schema: schema_ref(field.type).merge(field.documentation.except(:description, :example)) }
+            .merge(field.documentation.slice(:description, :example))
         end
       end
 
@@ -189,6 +225,7 @@ module RailsNinja
 
         endpoint.header_params.map do |h|
           { name: h[:name], in: "header", required: h[:required], schema: h[:schema] }
+            .merge(h.slice(:description, :example))
         end
       end
 
@@ -243,16 +280,17 @@ module RailsNinja
         required = []
 
         schema_class._fields.each do |name, field|
-          property = schema_ref(field.type)
+          property = schema_ref(field.type).deep_dup
           property[:title] = schema_title(name)
           property[:enum] = field.enum if field.enum
+          property.merge!(field.documentation)
           properties[name.to_s] = property
           required << name.to_s if field.required
         end
 
         result = { type: "object", title: schema_name(schema_class), properties: properties }
         result[:required] = required if required.any?
-        result
+        result.merge(schema_class.openapi)
       end
 
       def schema_title(name)

data/lib/rails_ninja/openapi/schema_ref.rb

@@ -24,13 +24,13 @@ module RailsNinja
         required = []
 
         schema_class._fields.each do |name, field|
-          properties[name.to_s] = to_json_schema(field.type)
+          properties[name.to_s] = to_json_schema(field.type).merge(field.documentation)
           required << name.to_s if field.required
         end
 
         result = { type: "object", properties: properties }
         result[:required] = required if required.any?
-        result
+        result.merge(schema_class.openapi).deep_dup
       end
 
       def primitive_type(type)

data/lib/rails_ninja/operation.rb

@@ -3,21 +3,44 @@
 module RailsNinja
   class Operation
     attr_reader :verb, :path, :handler, :display_handler, :api_class,
-                :request_schema, :responses_map, :tags, :summary, :header_params
+                :request_schema, :responses_map, :tags, :summary, :header_params,
+                :description, :operation_id, :path_params, :request_description, :response_documentation
 
     def initialize(verb:, path:, handler:, api_class:, request: nil, response: nil, responses: nil,
-      tags: nil, summary: nil, headers: nil, deprecated: false)
+      tags: nil, summary: nil, headers: nil, deprecated: false, description: nil,
+      operation_id: nil, path_params: {}, request_description: nil)
       @verb = verb
       @path = path
       @handler = handler
       @display_handler = handler
       @api_class = api_class
       @request_schema = request
-      @responses_map = responses || (response ? { 200 => response } : {})
+      @response_documentation = {}
+      @responses_map = (responses || (response ? { 200 => response } : {})).to_h do |status, declaration|
+        if declaration.is_a?(Hash)
+          unknown = declaration.keys - %i[schema description example examples headers]
+          raise ArgumentError, "Unsupported response #{status} keys: #{unknown.join(', ')}" if unknown.any?
+          if declaration.key?(:example) && declaration.key?(:examples)
+            raise ArgumentError, "Response #{status} cannot declare both example and examples"
+          end
+          @response_documentation[status] = declaration.except(:schema).deep_dup
+          [status, declaration.fetch(:schema)]
+        else
+          [status, declaration]
+        end
+      end
       @tags = tags || api_class._tags || []
       @summary = summary || handler.to_s.tr("_", " ").capitalize
       @header_params = merge_headers(api_class._headers, headers)
       @deprecated = deprecated
+      @description = description
+      @operation_id = operation_id
+      @path_params = path_params.transform_keys(&:to_s).deep_dup
+      @path_params.each_value do |metadata|
+        unknown = metadata.keys - %i[description example schema]
+        raise ArgumentError, "Unsupported path parameter keys: #{unknown.join(', ')}" if unknown.any?
+      end
+      @request_description = request_description
     end
 
     def deprecated?
@@ -64,7 +87,9 @@ module RailsNinja
         if h.is_a?(String)
           { name: h, required: true, schema: { type: "string" } }
         elsif h.is_a?(Hash)
-          { name: h[:name], required: h.fetch(:required, true), schema: { type: h.fetch(:type, "string") } }
+          { name: h[:name], required: h.fetch(:required, true),
+            schema: h.fetch(:schema, { type: h.fetch(:type, "string") }) }
+            .merge(h.slice(:description, :example)).deep_dup
         end
       end
     end

data/lib/rails_ninja/schema/field.rb

@@ -2,9 +2,16 @@
 
 module RailsNinja
   module Schema
-    Field = Struct.new(:name, :type, :required, :default, :enum, keyword_init: true) do
-      def initialize(name:, type:, required: true, default: nil, enum: nil)
-        super
+    Field = Struct.new(:name, :type, :required, :default, :enum, :documentation, keyword_init: true) do
+      def initialize(name:, type:, required: true, default: nil, enum: nil, openapi: {}, **documentation)
+        unknown = openapi.keys - %i[format pattern minLength maxLength minimum maximum default enum oneOf]
+        raise ArgumentError, "Unsupported field OpenAPI keys: #{unknown.join(', ')}" if unknown.any?
+
+        unknown = documentation.keys - %i[description example]
+        raise ArgumentError, "Unsupported field documentation keys: #{unknown.join(', ')}" if unknown.any?
+
+        super(name: name, type: type, required: required, default: default, enum: enum,
+          documentation: openapi.merge(documentation).deep_dup)
       end
     end
   end

data/lib/rails_ninja/schema/parameter_decoder.rb

@@ -8,9 +8,12 @@ module RailsNinja
 
       attr_reader :schema_class, :data
 
-      def initialize(schema_class, data)
+      # wrap_arrays: treat a lone value as a one-element list. Only safe for
+      # multipart, the one source where repeated names are preserved.
+      def initialize(schema_class, data, wrap_arrays: false)
         @schema_class = schema_class
         @data = data || {}
+        @wrap_arrays = wrap_arrays
       end
 
       def call
@@ -26,9 +29,13 @@ module RailsNinja
 
       def decode_value(value, type)
         if type.is_a?(Array)
+          value = Array.wrap(value) if @wrap_arrays
           value.is_a?(Array) ? value.map { |item| decode_value(item, type.first) } : value
         elsif type.is_a?(Class) && type <= Schema::Base
-          value.is_a?(Hash) ? self.class.new(type, value).call : value
+          # JSON already carries native types: validate it as-is, no form coercion.
+          return decode_json_object(value) if value.is_a?(::String)
+
+          value.is_a?(Hash) ? self.class.new(type, value, wrap_arrays: @wrap_arrays).call : value
         elsif type.is_a?(Class) && type <= Types::BaseScalar
           decode_scalar(value, type)
         else
@@ -47,6 +54,13 @@ module RailsNinja
         end
       end
 
+      # OpenAPI clients send nested objects in multipart/form bodies as JSON strings.
+      def decode_json_object(value)
+        MultiJson.load(value)
+      rescue MultiJson::ParseError
+        value
+      end
+
       def decode_integer(value)
         INTEGER_PATTERN.match?(value) ? Kernel.Integer(value, 10) : value
       end

data/lib/rails_ninja/schema/validator.rb

@@ -11,6 +11,8 @@ module RailsNinja
       end
 
       def call
+        return [{}, ["Expected object, got #{data.class}"]] unless data.respond_to?(:key?)
+
         errors = []
         validated = {}
 
@@ -77,6 +79,8 @@ module RailsNinja
       end
 
       def validate_schema(value, type)
+        return [nil, [": Expected object, got #{value.class}"]] unless value.respond_to?(:key?)
+
         result, errors = type.validate(value)
         [result, errors.map { |err| ".#{err}" }]
       end

data/lib/rails_ninja/schema.rb

@@ -4,14 +4,15 @@ module RailsNinja
   module Schema
     class Base
       class << self
-        def field(name, type, required: true, default: nil, enum: nil)
+        def field(name, type, required: true, default: nil, enum: nil, **documentation)
           validate_type!(type)
           _fields[name.to_sym] = Field.new(
             name: name.to_sym,
             type: type,
             required: required,
             default: default,
-            enum: enum
+            enum: enum,
+            **documentation
           )
         end
 
@@ -23,9 +24,18 @@ module RailsNinja
           @_fields ||= {}
         end
 
+        def openapi(**documentation)
+          unknown = documentation.keys - %i[description example]
+          raise ArgumentError, "Unsupported schema documentation keys: #{unknown.join(', ')}" if unknown.any?
+
+          @_openapi ||= {}
+          @_openapi.merge!(documentation.deep_dup)
+        end
+
         def inherited(subclass)
           super
           subclass.instance_variable_set(:@_fields, _fields.dup)
+          subclass.instance_variable_set(:@_openapi, openapi.deep_dup)
         end
 
         def validate(data)

data/lib/rails_ninja/types/file.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Types
+    class File < BaseScalar
+      class << self
+        def ruby_classes
+          [ActionDispatch::Http::UploadedFile]
+        end
+
+        def openapi_schema
+          { type: "string", format: "binary" }
+        end
+      end
+    end
+  end
+end

data/lib/rails_ninja/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsNinja
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/rails_ninja.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "action_controller/metal"
+require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/enumerable"
+require "active_support/core_ext/object/deep_dup"
 require "rack"
 require "multi_json"
 
@@ -9,6 +11,7 @@ require_relative "rails_ninja/version"
 require_relative "rails_ninja/errors"
 require_relative "rails_ninja/types/base_scalar"
 require_relative "rails_ninja/types/boolean"
+require_relative "rails_ninja/types/file"
 require_relative "rails_ninja/types/float"
 require_relative "rails_ninja/types/int"
 require_relative "rails_ninja/types/string"

data/rails_ninja.gemspec

@@ -26,10 +26,10 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "actionpack", ">= 7.0"
-  spec.add_dependency "activesupport", ">= 7.0"
+  spec.add_dependency "actionpack", ">= 7.1"
+  spec.add_dependency "activesupport", ">= 7.1"
   spec.add_dependency "multi_json", "~> 1.15"
-  spec.add_dependency "rack", ">= 2.0"
+  spec.add_dependency "rack", ">= 2.2.4"
 
   spec.add_development_dependency "minitest", ">= 5.0"
   spec.add_development_dependency "rack-test", ">= 2.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_ninja
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Benjamin Urrutia
@@ -15,28 +15,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.2.4
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -137,6 +137,7 @@ files:
 - lib/rails_ninja/tasks.rake
 - lib/rails_ninja/types/base_scalar.rb
 - lib/rails_ninja/types/boolean.rb
+- lib/rails_ninja/types/file.rb
 - lib/rails_ninja/types/float.rb
 - lib/rails_ninja/types/int.rb
 - lib/rails_ninja/types/string.rb
@@ -166,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Django Ninja-inspired API framework for Ruby/Rails
 test_files: []