openapi_blocks 0.2.0

data/lib/openapi_blocks/schema/extractor.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+module OpenapiBlocks
+  module Schema
+    class Extractor # rubocop:disable Style/Documentation
+      IGNORED_COLUMNS = %w[
+        password_digest
+        encrypted_password
+        reset_password_token
+        reset_password_sent_at
+        remember_created_at
+        confirmation_token
+        confirmed_at
+        confirmation_sent_at
+        unconfirmed_email
+        failed_attempts
+        unlock_token
+        locked_at
+      ].freeze
+
+      def initialize(openapi_class)
+        @openapi_class = openapi_class
+        @model         = openapi_class.model
+        @ignored       = Array(openapi_class._ignored) + IGNORED_COLUMNS
+      end
+
+      def extract
+        properties = {}
+
+        column_properties.each      { |name, schema| properties[name] = schema }
+        virtual_properties.each     { |name, schema| properties[name] = schema }
+        association_properties.each { |name, schema| properties[name] = schema }
+
+        {
+          type:       "object",
+          required:   required_columns,
+          properties: properties
+        }.compact
+      end
+
+      private
+
+      def column_properties
+        @model.columns.each_with_object({}) do |column, hash|
+          next if @ignored.include?(column.name)
+
+          hash[column.name] = Types.map(column.sql_type_metadata.type)
+        end
+      end
+
+      def virtual_properties
+        Array(@openapi_class._virtual_attributes).each_with_object({}) do |attr, hash|
+          name    = attr.delete(:name)
+          options = attr
+
+          hash[name.to_s] = build_virtual_property(options)
+        end
+      end
+
+      def association_properties
+        Array(@openapi_class._associations).each_with_object({}) do |assoc, hash|
+          name      = assoc[:name]
+          type      = assoc[:type]
+          input     = assoc.fetch(:input, true)
+          ref       = { "$ref" => "#/components/schemas/#{name.to_s.classify}" }
+
+          schema = type == :array ? { type: "array", items: ref } : ref
+          schema[:readOnly] = true unless input
+
+          hash[name.to_s] = schema
+        end
+      end
+
+      def required_columns # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        association_names = Array(@openapi_class._associations).map { |a| a[:name].to_s }
+
+        required = @model.validators.each_with_object([]) do |validator, arr|
+          next unless validator.is_a?(ActiveModel::Validations::PresenceValidator)
+
+          validator.attributes.each do |attr|
+            next if @ignored.include?(attr.to_s)
+            next if association_names.include?(attr.to_s)
+
+            arr << attr.to_s
+          end
+        end
+
+        required.empty? ? nil : required
+      end
+
+      def build_virtual_property(options)
+        property = {}
+        property[:type]        = options[:type].to_s      if options[:type]
+        property[:format]      = options[:format].to_s    if options[:format]
+        property[:description] = options[:description]    if options[:description]
+        property[:readOnly]    = options[:read_only]      if options[:read_only]
+        property
+      end
+    end
+  end
+end

data/lib/openapi_blocks/schema/types.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OpenapiBlocks
+  module Schema
+    module Types # rubocop:disable Style/Documentation
+      MAPPING = {
+        # Inteiros
+        "integer"   => { type: "integer", format: "int32" },
+        "bigint"    => { type: "integer", format: "int64" },
+        "smallint"  => { type: "integer" },
+
+        # Decimais
+        "float"     => { type: "number", format: "float" },
+        "decimal"   => { type: "number", format: "double" },
+
+        # Texto
+        "string"    => { type: "string" },
+        "text"      => { type: "string" },
+        "citext"    => { type: "string" },
+
+        # Booleano
+        "boolean"   => { type: "boolean" },
+
+        # Datas e horas
+        "date"      => { type: "string", format: "date" },
+        "datetime"  => { type: "string", format: "date-time" },
+        "timestamp" => { type: "string", format: "date-time" },
+        "time"      => { type: "string", format: "time" },
+
+        # UUID
+        "uuid"      => { type: "string", format: "uuid" },
+
+        # JSON
+        "json"      => { type: "object" },
+        "jsonb"     => { type: "object" },
+
+        # Binário
+        "binary"    => { type: "string", format: "binary" },
+
+        # Arrays (PostgreSQL)
+        "string[]"  => { type: "array", items: { type: "string" } },
+        "integer[]" => { type: "array", items: { type: "integer" } }
+      }.freeze
+
+      DEFAULT = { type: "string" }.freeze
+
+      def self.map(ar_type)
+        MAPPING.fetch(ar_type.to_s, DEFAULT)
+      end
+    end
+  end
+end

data/lib/openapi_blocks/schema/validator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module OpenapiBlocks
+  module Schema
+    class Validator # rubocop:disable Style/Documentation
+      def initialize(model)
+        @model = model
+      end
+
+      def extract
+        @model.validators.each_with_object({}) do |validator, hash|
+          validator.attributes.each do |attribute|
+            hash[attribute.to_s] ||= {}
+            hash[attribute.to_s].merge!(convert(validator))
+          end
+        end
+      end
+
+      private
+
+      def convert(validator) # rubocop:disable Metrics/MethodLength
+        case validator
+        in ActiveModel::Validations::LengthValidator
+          convert_length(validator)
+        in ActiveModel::Validations::NumericalityValidator
+          convert_numericality(validator)
+        in ActiveModel::Validations::InclusionValidator
+          convert_inclusion(validator)
+        in ActiveModel::Validations::FormatValidator
+          convert_format(validator)
+        else
+          {}
+        end
+      end
+
+      def convert_length(validator)
+        options = validator.options
+        result  = {}
+
+        result[:minLength] = options[:minimum] if options[:minimum]
+        result[:maxLength] = options[:maximum] if options[:maximum]
+        result[:minLength] = options[:is]      if options[:is]
+        result[:maxLength] = options[:is]      if options[:is]
+
+        result
+      end
+
+      def convert_numericality(validator) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        options = validator.options
+        result  = {}
+
+        result[:minimum]          = options[:greater_than] + 1 if options[:greater_than]
+        result[:minimum]          = options[:greater_than_or_equal_to] if options[:greater_than_or_equal_to]
+        result[:maximum]          = options[:less_than] - 1 if options[:less_than]
+        result[:maximum]          = options[:less_than_or_equal_to] if options[:less_than_or_equal_to]
+        result[:multipleOf]       = options[:other_than] if options[:other_than]
+        result[:exclusiveMinimum] = options[:greater_than] if options[:greater_than]
+        result[:exclusiveMaximum] = options[:less_than]    if options[:less_than]
+
+        result
+      end
+
+      def convert_inclusion(validator)
+        options = validator.options
+        return {} unless options[:in]
+
+        { enum: Array(options[:in]) }
+      end
+
+      def convert_format(validator)
+        options = validator.options
+        return {} unless options[:with]
+
+        regexp = options[:with]
+
+        if regexp.source == URI::MailTo::EMAIL_REGEXP.source
+          { format: "email" }
+        elsif regexp.source =~ /url|uri/i
+          { format: "uri" }
+        else
+          { pattern: regexp.source }
+        end
+      end
+    end
+  end
+end

data/lib/openapi_blocks/spec/components.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../schema/extractor"
+require_relative "../schema/validator"
+
+module OpenapiBlocks
+  module Spec
+    class Components # rubocop:disable Style/Documentation
+      INPUT_IGNORED_PROPERTIES = %w[id created_at updated_at deleted_at].freeze
+
+      def initialize(openapi_classes)
+        @openapi_classes = openapi_classes
+      end
+
+      def build # rubocop:disable Metrics/AbcSize
+        schemas = @openapi_classes.each_with_object({}) do |klass, hash|
+          schema_name = klass.model.name
+          extractor   = Schema::Extractor.new(klass)
+          validator   = Schema::Validator.new(klass.model)
+
+          schema              = extractor.extract
+          schema[:properties] = merge_validations(schema[:properties], validator.extract)
+
+          hash[schema_name]            = schema
+          hash["#{schema_name}Input"]  = build_input(schema, klass)
+        end
+
+        { schemas: schemas }
+      end
+
+      private
+
+      def build_input(schema, openapi_class) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        read_only_virtuals = Array(openapi_class._virtual_attributes)
+                             .select { |attr| attr[:read_only] == true }
+                             .map { |attr| attr[:name].to_s }
+
+        input_properties = schema[:properties].reject do |name, property|
+          INPUT_IGNORED_PROPERTIES.include?(name.to_s) ||
+            read_only_virtuals.include?(name.to_s) ||
+            property[:readOnly] == true
+        end
+
+        {
+          type:       "object",
+          required:   filter_required(schema[:required], input_properties),
+          properties: input_properties
+        }.compact
+      end
+
+      def filter_required(required, input_properties)
+        return nil if required.blank?
+
+        filtered = required.select { |r| input_properties.key?(r) || input_properties.key?(r.to_sym) }
+        filtered.empty? ? nil : filtered
+      end
+
+      def merge_validations(properties, validations)
+        return properties if properties.blank?
+
+        properties.each_with_object({}) do |(name, schema), hash|
+          hash[name] = schema.merge(validations.fetch(name, {}))
+        end
+      end
+    end
+  end
+end

data/lib/openapi_blocks/spec/document.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "components"
+require_relative "paths"
+
+module OpenapiBlocks
+  module Spec
+    class Document # rubocop:disable Style/Documentation
+      def initialize(openapi_classes)
+        @openapi_classes = openapi_classes
+      end
+
+      def build # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        config     = OpenapiBlocks.configuration
+        components = Components.new(@openapi_classes).build
+        security   = config.security
+
+        components[:securitySchemes] = security.to_h if security&.schemes&.any?
+
+        paths = Paths.new.build
+
+        doc = {
+          openapi:    config.openapi_version,
+          info:       config.info.to_h,
+          servers:    config.to_h[:servers],
+          paths:      paths,
+          components: components,
+          tags:       build_tags_from_paths(paths)
+        }
+
+        doc[:security] = security.schemes.keys.map { |s| { s => [] } } if security&.schemes&.any?
+
+        doc
+      end
+
+      private
+
+      def build_tags_from_paths(paths)
+        names = paths.values.flat_map do |operations|
+          operations.values.flat_map { |op| Array(op[:tags]) }
+        end
+
+        names.uniq.map { |n| { name: n } }
+      end
+    end
+  end
+end

data/lib/openapi_blocks/spec/paths.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../routing/extractor"
+
+module OpenapiBlocks
+  module Spec
+    class Paths # rubocop:disable Style/Documentation
+      def initialize(app = Rails.application)
+        @app = app
+      end
+
+      def build
+        Routing::Extractor.new(@app).extract
+      end
+    end
+  end
+end

data/lib/openapi_blocks/version.rb

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

data/lib/openapi_blocks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+require "active_record"
+
+require_relative "openapi_blocks/version"
+require_relative "openapi_blocks/configuration"
+require_relative "openapi_blocks/cache"
+require_relative "openapi_blocks/file_watcher"
+require_relative "openapi_blocks/middleware"
+require_relative "openapi_blocks/schema/types"
+require_relative "openapi_blocks/schema/extractor"
+require_relative "openapi_blocks/schema/validator"
+require_relative "openapi_blocks/routing/operation"
+require_relative "openapi_blocks/routing/extractor"
+require_relative "openapi_blocks/spec/components"
+require_relative "openapi_blocks/spec/paths"
+require_relative "openapi_blocks/spec/document"
+require_relative "openapi_blocks/builder"
+require_relative "openapi_blocks/base"
+require_relative "openapi_blocks/engine"
+require_relative "openapi_blocks/railtie"
+require_relative "openapi_blocks/operation_builder"
+
+module OpenapiBlocks # rubocop:disable Style/Documentation
+  class Error < StandardError; end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/sig/openapi_blocks.rbs

@@ -0,0 +1,4 @@
+module OpenapiBlocks
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: openapi_blocks
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Caio Santos
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Generates OpenAPI specs automatically from ActiveRecord models, ActiveModel
+  validations and Rails routes, inspired by ActiveModel::Serializer.
+email:
+- caio.francelinosena@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- README.pt-BR.md
+- Rakefile
+- app/controllers/openapi_blocks/spec_controller.rb
+- config/routes.rb
+- lib/openapi_blocks.rb
+- lib/openapi_blocks/base.rb
+- lib/openapi_blocks/builder.rb
+- lib/openapi_blocks/cache.rb
+- lib/openapi_blocks/configuration.rb
+- lib/openapi_blocks/configuration/contact_builder.rb
+- lib/openapi_blocks/configuration/info_builder.rb
+- lib/openapi_blocks/configuration/license_builder.rb
+- lib/openapi_blocks/configuration/security_builder.rb
+- lib/openapi_blocks/configuration/server_builder.rb
+- lib/openapi_blocks/configuration/servers_builder.rb
+- lib/openapi_blocks/engine.rb
+- lib/openapi_blocks/file_watcher.rb
+- lib/openapi_blocks/middleware.rb
+- lib/openapi_blocks/operation_builder.rb
+- lib/openapi_blocks/railtie.rb
+- lib/openapi_blocks/routing/extractor.rb
+- lib/openapi_blocks/routing/operation.rb
+- lib/openapi_blocks/schema/extractor.rb
+- lib/openapi_blocks/schema/types.rb
+- lib/openapi_blocks/schema/validator.rb
+- lib/openapi_blocks/spec/components.rb
+- lib/openapi_blocks/spec/document.rb
+- lib/openapi_blocks/spec/paths.rb
+- lib/openapi_blocks/version.rb
+- sig/openapi_blocks.rbs
+homepage: https://github.com/evotechbuilder/openapi_blocks
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/evotechbuilder/openapi_blocks
+  source_code_uri: https://github.com/evotechbuilder/openapi_blocks
+  changelog_uri: https://github.com/evotechbuilder/openapi_blocks/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: DSL to generate OpenAPI 3.0/3.1 documentation for Rails applications
+test_files: []