rails_ninja 0.1.0

data/lib/rails_ninja/schema/one_of.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Schema
+    class OneOf
+      attr_reader :variants, :discriminator
+
+      def initialize(variants, discriminator: nil)
+        @variants = variants
+        @discriminator = discriminator
+      end
+    end
+  end
+end

data/lib/rails_ninja/schema/parameter_decoder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Schema
+    class ParameterDecoder
+      INTEGER_PATTERN = /\A-?(?:0|[1-9]\d*)\z/
+      NUMBER_PATTERN = /\A-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\z/
+
+      attr_reader :schema_class, :data
+
+      def initialize(schema_class, data)
+        @schema_class = schema_class
+        @data = data || {}
+      end
+
+      def call
+        schema_class._fields.each_with_object({}) do |(name, field), decoded|
+          next unless data.key?(name) || data.key?(name.to_s)
+
+          value = data.key?(name) ? data[name] : data[name.to_s]
+          decoded[name] = decode_value(value, field.type)
+        end
+      end
+
+      private
+
+      def decode_value(value, type)
+        if type.is_a?(Array)
+          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
+        elsif type.is_a?(Class) && type <= Types::BaseScalar
+          decode_scalar(value, type)
+        else
+          value
+        end
+      end
+
+      def decode_scalar(value, type)
+        return value unless value.is_a?(::String)
+
+        case type.openapi_schema[:type]
+        when "integer" then decode_integer(value)
+        when "number" then decode_number(value)
+        when "boolean" then decode_boolean(value)
+        else value
+        end
+      end
+
+      def decode_integer(value)
+        INTEGER_PATTERN.match?(value) ? Kernel.Integer(value, 10) : value
+      end
+
+      def decode_number(value)
+        NUMBER_PATTERN.match?(value) ? Kernel.Float(value) : value
+      end
+
+      def decode_boolean(value)
+        return true if value == "true"
+        return false if value == "false"
+
+        value
+      end
+    end
+  end
+end

data/lib/rails_ninja/schema/serializer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Schema
+    class Serializer
+      attr_reader :schema_class, :object
+
+      def initialize(schema_class, object)
+        @schema_class = schema_class
+        @object = object
+      end
+
+      def call
+        result = {}
+
+        schema_class._fields.each do |name, field|
+          value = read_attribute(object, name)
+          result[name] = serialize_value(value, field.type)
+        end
+
+        result
+      end
+
+      private
+
+      def serialize_value(value, type)
+        return nil if value.nil?
+
+        if type.is_a?(OneOf)
+          variant = pick_variant(type, value)
+          variant ? Serializer.new(variant, value).call : value
+        elsif array_type?(type)
+          value.map { |item| serialize_value(item, type.first) }
+        elsif schema_type?(type)
+          Serializer.new(type, value).call
+        elsif scalar_type?(type)
+          value
+        else
+          raise Error, "Unsupported schema type: #{type.inspect}"
+        end
+      end
+
+      def pick_variant(one_of, value)
+        return nil unless value.is_a?(Hash)
+
+        one_of.variants.find do |variant|
+          variant._fields.each_value.all? do |field|
+            !field.required || value.key?(field.name) || value.key?(field.name.to_s)
+          end
+        end
+      end
+
+      def read_attribute(obj, name)
+        if obj.is_a?(Hash)
+          obj.key?(name) ? obj[name] : obj[name.to_s]
+        elsif obj.respond_to?(name)
+          obj.public_send(name)
+        elsif obj.respond_to?(:[])
+          obj[name]
+        end
+      end
+
+      def array_type?(type)
+        type.is_a?(Array)
+      end
+
+      def schema_type?(type)
+        type.is_a?(Class) && type <= Schema::Base
+      end
+
+      def scalar_type?(type)
+        type.is_a?(Class) && type <= Types::BaseScalar
+      end
+    end
+  end
+end

data/lib/rails_ninja/schema/validator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Schema
+    class Validator
+      attr_reader :schema_class, :data
+
+      def initialize(schema_class, data)
+        @schema_class = schema_class
+        @data = data || {}
+      end
+
+      def call
+        errors = []
+        validated = {}
+
+        schema_class._fields.each do |name, field|
+          value = data.key?(name) ? data[name] : data[name.to_s]
+
+          if value.nil?
+            if field.required && field.default.nil?
+              errors << "#{name} is required"
+              next
+            end
+            value = field.default
+          end
+
+          next if value.nil?
+
+          result, validation_errors = validate_value(value, field.type)
+          if validation_errors.any?
+            errors.concat(validation_errors.map { |e| "#{name}#{e}" })
+          else
+            validated[name] = result
+          end
+        end
+
+        [validated, errors]
+      end
+
+      private
+
+      def validate_value(value, type)
+        if array_type?(type)
+          validate_array(value, type)
+        elsif schema_type?(type)
+          validate_schema(value, type)
+        elsif scalar_type?(type)
+          validate_scalar(value, type)
+        else
+          raise Error, "Unsupported schema type: #{type.inspect}"
+        end
+      end
+
+      def validate_array(value, type)
+        return [nil, [": Expected #{format_type(type)}, got #{value.class}"]] unless value.is_a?(Array)
+
+        validated = []
+        errors = []
+
+        value.each_with_index do |item, index|
+          result, item_errors = validate_value(item, type.first)
+          if item_errors.any?
+            errors.concat(item_errors.map { |e| "[#{index}]#{e}" })
+          else
+            validated << result
+          end
+        end
+
+        [validated, errors]
+      end
+
+      def validate_scalar(value, type)
+        return [value, []] if type.valid?(value)
+
+        [nil, [": Expected #{type.type_name}, got #{value.class}"]]
+      end
+
+      def validate_schema(value, type)
+        result, errors = type.validate(value)
+        [result, errors.map { |err| ".#{err}" }]
+      end
+
+      def array_type?(type)
+        type.is_a?(Array)
+      end
+
+      def schema_type?(type)
+        type.is_a?(Class) && type <= Schema::Base
+      end
+
+      def scalar_type?(type)
+        type.is_a?(Class) && type <= Types::BaseScalar
+      end
+
+      def format_type(type)
+        return "[#{format_type(type.first)}]" if array_type?(type)
+        return type.type_name if scalar_type?(type)
+
+        type.name || type.to_s
+      end
+    end
+  end
+end

data/lib/rails_ninja/schema.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Schema
+    class Base
+      class << self
+        def field(name, type, required: true, default: nil, enum: nil)
+          validate_type!(type)
+          _fields[name.to_sym] = Field.new(
+            name: name.to_sym,
+            type: type,
+            required: required,
+            default: default,
+            enum: enum
+          )
+        end
+
+        def one_of(*variants, discriminator: nil)
+          OneOf.new(variants, discriminator: discriminator)
+        end
+
+        def _fields
+          @_fields ||= {}
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@_fields, _fields.dup)
+        end
+
+        def validate(data)
+          Validator.new(self, data).call
+        end
+
+        def serialize(object)
+          Serializer.new(self, object).call
+        end
+
+        def serialize_many(collection)
+          collection.map { |obj| serialize(obj) }
+        end
+
+        private
+
+        def validate_type!(type)
+          if type.is_a?(Array)
+            raise Error, "List types must contain exactly one type" unless type.one?
+
+            validate_type!(type.first)
+          elsif type.is_a?(OneOf)
+            type.variants.each { |variant| validate_type!(variant) }
+          elsif type.is_a?(Class) && (type <= Base || type <= Types::BaseScalar)
+            return
+          else
+            raise Error, "Unsupported schema type: #{type.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_ninja/swagger/ui.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Swagger
+    module UI
+      module_function
+
+      def html(spec_url: "./openapi.json")
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="UTF-8">
+            <title>API Documentation</title>
+            <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+            <style>
+              body { margin: 0; padding: 0; }
+            </style>
+          </head>
+          <body>
+            <div id="swagger-ui"></div>
+            <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+            <script>
+              SwaggerUIBundle({
+                url: "#{spec_url}",
+                dom_id: '#swagger-ui',
+                presets: [SwaggerUIBundle.presets.apis],
+                layout: "BaseLayout"
+              })
+            </script>
+          </body>
+          </html>
+        HTML
+      end
+    end
+  end
+end

data/lib/rails_ninja/tasks.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :rails_ninja do
+  namespace :openapi do
+    desc "Generate OpenAPI JSON spec files for all registered APIs"
+    task generate: :environment do
+      output = ENV.fetch("OUTPUT", "public/openapi")
+      RailsNinja.generate_openapi(output: output)
+      puts "Generated OpenAPI specs in #{output}/"
+    end
+  end
+end

data/lib/rails_ninja/types/base_scalar.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Types
+    class BaseScalar
+      class << self
+        def valid?(value)
+          ruby_classes.any? { |ruby_class| value.is_a?(ruby_class) }
+        end
+
+        def openapi_schema
+          raise NotImplementedError
+        end
+
+        def type_name
+          name.split("::").last
+        end
+
+        def ruby_classes
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/rails_ninja/types/boolean.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Types
+    class Boolean < BaseScalar
+      class << self
+        def ruby_classes
+          [TrueClass, FalseClass]
+        end
+
+        def openapi_schema
+          { type: "boolean" }
+        end
+      end
+    end
+  end
+end

data/lib/rails_ninja/types/float.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Types
+    class Float < BaseScalar
+      class << self
+        def ruby_classes
+          [::Float]
+        end
+
+        def openapi_schema
+          { type: "number" }
+        end
+      end
+    end
+  end
+end

data/lib/rails_ninja/types/int.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsNinja
+  module Types
+    class Int < BaseScalar
+      class << self
+        def ruby_classes
+          [::Integer]
+        end
+
+        def openapi_schema
+          { type: "integer" }
+        end
+
+        def type_name
+          "Integer"
+        end
+      end
+    end
+  end
+end

data/lib/rails_ninja/types/string.rb

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

data/lib/rails_ninja/version.rb

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

data/lib/rails_ninja.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "action_controller/metal"
+require "active_support/core_ext/enumerable"
+require "rack"
+require "multi_json"
+
+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/float"
+require_relative "rails_ninja/types/int"
+require_relative "rails_ninja/types/string"
+require_relative "rails_ninja/schema/field"
+require_relative "rails_ninja/schema/one_of"
+require_relative "rails_ninja/schema/parameter_decoder"
+require_relative "rails_ninja/schema/validator"
+require_relative "rails_ninja/schema/serializer"
+require_relative "rails_ninja/schema"
+require_relative "rails_ninja/operation"
+require_relative "rails_ninja/response"
+require_relative "rails_ninja/openapi/schema_ref"
+require_relative "rails_ninja/openapi/generator"
+require_relative "rails_ninja/swagger/ui"
+require_relative "rails_ninja/endpoint_group"
+require_relative "rails_ninja/api"
+require_relative "rails_ninja/endpoint"
+
+require_relative "rails_ninja/railtie" if defined?(Rails::Railtie)
+
+module RailsNinja
+  def self.registered_apis
+    @registered_apis ||= []
+  end
+
+  def self.generate_openapi(output: "public/openapi")
+    require "fileutils"
+    FileUtils.mkdir_p(output)
+
+    registered_apis.each do |api_class|
+      generator = OpenAPI::Generator.new(api_class)
+
+      filename = api_class.name.split("::").last
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .downcase + ".json"
+
+      File.write(File.join(output, filename), generator.to_json)
+    end
+  end
+end

data/rails_ninja.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/rails_ninja/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rails_ninja"
+  spec.version = RailsNinja::VERSION
+  spec.authors = ["Benjamin Urrutia"]
+  spec.email = ["benja@fintual.com"]
+  spec.summary = "Django Ninja-inspired API framework for Ruby/Rails"
+  spec.description = "Define API endpoints with a decorator-like DSL, schema validation, and automatic OpenAPI spec generation."
+  spec.homepage = "https://github.com/fintual-oss/rails-ninja"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir["lib/**/*"].select { |path| File.file?(path) } +
+      %w[LICENSE README.md rails_ninja.gemspec]
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "actionpack", ">= 7.0"
+  spec.add_dependency "activesupport", ">= 7.0"
+  spec.add_dependency "multi_json", "~> 1.15"
+  spec.add_dependency "rack", ">= 2.0"
+
+  spec.add_development_dependency "minitest", ">= 5.0"
+  spec.add_development_dependency "rack-test", ">= 2.0"
+  spec.add_development_dependency "rake", ">= 13.0"
+end