model-to-schema 0.1.0

data/lib/esquema/property.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require_relative "type_caster"
+module Esquema
+  # Represents a property in the Esquema schema.
+  class Property # rubocop:disable Metrics/ClassLength
+    # Mapping of database types to JSON types.
+    DB_TO_JSON_TYPE_MAPPINGS = {
+      date: "date",
+      datetime: "date-time",
+      time: "time",
+      string: "string",
+      text: "string",
+      integer: "integer",
+      float: "number",
+      number: "number",
+      decimal: "number",
+      boolean: "boolean",
+      array: "array",
+      object: "object"
+    }.freeze
+
+    NUMERIC_CONSTRAINT_KEYWORDS = %i[minimum maximum exclusiveMinimum exclusiveMaximum multipleOf].freeze
+    STRING_CONSTRAINT_KEYWORDS = %i[maxLength minLength pattern format].freeze
+    ARRAY_CONSTRAINT_KEYWORDS = %i[maxItems minItems uniqueItems items].freeze
+    OBJECT_CONSTRAINT_KEYWORDS = %i[maxProperties minProperties properties additionalProperties dependencies].freeze
+    LOGICAL_KEYWORDS = %i[allOf anyOf oneOf not].freeze
+    GENERIC_KEYWORDS = %i[type default title description enum const].freeze
+
+    KEYWORDS = (
+      NUMERIC_CONSTRAINT_KEYWORDS +
+      STRING_CONSTRAINT_KEYWORDS  +
+      ARRAY_CONSTRAINT_KEYWORDS   +
+      OBJECT_CONSTRAINT_KEYWORDS  +
+      LOGICAL_KEYWORDS            +
+      GENERIC_KEYWORDS
+    ).freeze
+
+    FORMAT_OPTIONS = %i[date-time date time email hostname ipv4 ipv6 uri uuid uri-reference uri-template].freeze
+
+    attr_reader :object, :options
+
+    # Initializes a new Property instance.
+    #
+    # @param object [Object] The object to build the property for.
+    # An object can be any of the following instance types:
+    #  An ActiveRecord column. Example: ActiveRecord::ConnectionAdapters::SQLite3::Column
+    #  An ActiveRecord association reflection. Example: ActiveRecord::Reflection::BelongsToReflection
+    #  An Esquema virtual column. Example: Esquema::VirtualColumn
+    # @param options [Hash] Additional options for the property.
+    # @raise [ArgumentError] If the property does not have a name.
+    def initialize(object, options = {})
+      raise ArgumentError, "property must have a name" unless object.respond_to?(:name)
+
+      @object = object
+      @options = options
+    end
+
+    # Converts the Property instance to a JSON representation.
+    #
+    # @return [Hash] The JSON representation of the Property.
+    def as_json
+      KEYWORDS.each_with_object({}) do |property, hash|
+        value = send("build_#{property.downcase}")
+        next if value.nil? || (value.is_a?(String) && value.empty?)
+
+        hash[property] = value
+      end.compact
+    end
+
+    # Builds the title attribute for the Property.
+    #
+    # @return [String] The title attribute.
+    def build_title
+      options[:title].presence || object.name.to_s.humanize
+    end
+
+    # Builds the default attribute for the Property.
+    #
+    # @return [Object, nil] The default attribute.
+    def build_default
+      return unless object.respond_to?(:default)
+
+      default_value = object.default || options[:default].presence
+
+      @default = TypeCaster.cast(object.type, default_value) unless default_value.nil?
+    end
+
+    # Builds the type attribute for the Property.
+    #
+    # @return [String, nil] The type attribute.
+    def build_type
+      return DB_TO_JSON_TYPE_MAPPINGS[:array] if object.try(:collection?)
+
+      return unless object.respond_to?(:type)
+
+      @type = DB_TO_JSON_TYPE_MAPPINGS[object.type]
+    end
+
+    # Builds the description attribute for the Property.
+    #
+    # @return [String, nil] The description attribute.
+    def build_description
+      options[:description]
+    end
+
+    # Builds the items attribute for the Property.
+    #
+    # @return [Hash, nil] The items attribute.
+    def build_items
+      return unless object.try(:collection?)
+
+      case object.type
+      when :array
+        { type: DB_TO_JSON_TYPE_MAPPINGS[object.item_type] }
+      else
+        Builder.new(object.klass).build_schema
+      end
+    end
+
+    # Builds the enum attribute for the Property.
+    #
+    # @return [Array, nil] The enum attribute.
+    def build_enum
+      options[:enum]
+    end
+
+    def build_minimum
+      options[:minimum]
+    end
+
+    def build_maximum
+      options[:maximum]
+    end
+
+    def build_exclusiveminimum
+      options[:exclusiveMinimum]
+    end
+
+    def build_exclusivemaximum
+      options[:exclusiveMaximum]
+    end
+
+    def build_multipleof
+      options[:multipleof]
+    end
+
+    def build_maxlength
+      options[:maxLength]
+    end
+
+    def build_minlength
+      options[:minLength]
+    end
+
+    def build_pattern
+      options[:pattern]
+    end
+
+    def build_format
+      options[:format]
+    end
+
+    def build_maxitems # rubocop:disable Metrics/AbcSize
+      raise ArgumentError, "maxItems must be an integer" if options[:maxItems] && !options[:maxItems].is_a?(Integer)
+
+      if options[:maxItems]&.negative?
+        raise ArgumentError,
+              "maxItems must be a non-negative integer"
+      end
+
+      if options[:maxItems] && options[:type] != :array
+        raise ArgumentError, "maxItems must be use for array type properties only."
+      end
+
+      options[:maxItems]
+    end
+
+    def build_minitems # rubocop:disable Metrics/AbcSize
+      raise ArgumentError, "minItems must be an integer" if options[:minItems] && !options[:minItems].is_a?(Integer)
+
+      if options[:minItems]&.negative?
+        raise ArgumentError,
+              "minItems must be a non-negative integer"
+      end
+
+      if options[:minItems] && options[:type] != :array
+        raise ArgumentError, "minItems must be use for array type properties only."
+      end
+
+      options[:minItems]
+    end
+
+    def build_uniqueitems
+      options[:uniqueItems]
+    end
+
+    def build_properties
+      options[:properties]
+    end
+
+    def build_maxproperties
+      options[:maxProperties]
+    end
+
+    def build_minproperties
+      options[:minProperties]
+    end
+
+    def build_additionalproperties
+      options[:additionalProperties]
+    end
+
+    def build_dependencies
+      options[:dependencies]
+    end
+
+    def build_allof
+      options[:allOf]
+    end
+
+    def build_anyof
+      options[:anyOf]
+    end
+
+    def build_oneof
+      options[:oneOf]
+    end
+
+    def build_not
+      options[:not]
+    end
+
+    def build_const
+      options[:const]
+    end
+  end
+end

data/lib/esquema/schema_enhancer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "date"
+require "bigdecimal"
+require_relative "keyword_validator"
+
+module Esquema
+  # The SchemaEnhancer class is responsible for enhancing the schema of a model.
+  class SchemaEnhancer
+    attr_reader :model
+
+    def initialize(model, schema_enhancements)
+      @schema_enhancements = schema_enhancements
+      @model = model
+    end
+
+    # Sets the description for the model.
+    #
+    # @param description [String] The description of the model.
+    def model_description(description)
+      @schema_enhancements[:model_description] = description
+    end
+
+    # Sets the title for the model.
+    #
+    # @param title [String] The title of the model.
+    def model_title(title)
+      @schema_enhancements[:model_title] = title
+    end
+
+    # Adds a property to the schema.
+    #
+    # @param name [Symbol] The name of the property.
+    # @param options [Hash] Additional options for the property.
+    def property(name, options = {})
+      validate_property_as_attribute_for(name, options)
+
+      type = resolve_type(name, options)
+
+      KeywordValidator.validate!(name, type, options)
+
+      @schema_enhancements[:properties] ||= {}
+      @schema_enhancements[:properties][name] = options
+    end
+
+    # Adds a virtual property to the schema.
+    #
+    # @param name [Symbol] The name of the virtual property.
+    # @param options [Hash] Additional options for the virtual property.
+    def virtual_property(name, options = {})
+      options[:virtual] = true
+      property(name, options)
+    end
+
+    private
+
+    # Resolves the type of a property.
+    #
+    # @param name [Symbol] The name of the property.
+    # @param options [Hash] Additional options for the property.
+    # @return [Symbol] The resolved type of the property.
+    def resolve_type(name, options = {})
+      if options[:virtual] == true
+        options[:type]
+      else
+        model.type_for_attribute(name).type
+      end
+    end
+
+    # Retrieves the valid properties for the model.
+    #
+    # @return [Array<Symbol>] The valid properties for the model.
+    def valid_properties
+      @valid_properties ||= begin
+        properties = model.column_names + model.reflect_on_all_associations.map(&:name)
+        properties.map(&:to_sym)
+      end
+    end
+
+    # Validates that a property is a valid attribute for the model.
+    #
+    # @param prop_name [Symbol] The name of the property.
+    # @param options [Hash] Additional options for the property.
+    # @raise [ArgumentError] If the property is not a valid attribute for the model.
+    def validate_property_as_attribute_for(prop_name, options = {})
+      return if options[:virtual] == true
+      raise ArgumentError, "`#{prop_name}` is not a model attribute." unless valid_properties.include?(prop_name.to_sym)
+    end
+  end
+end

data/lib/esquema/type_caster.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Esquema
+  module TypeCaster # rubocop:disable Style/Documentation
+    def self.cast(type, value) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      case type
+      when :string, :text
+        value.to_s
+      when :integer
+        begin
+          Integer(value)
+        rescue StandardError
+          nil
+        end
+      when :float
+        begin
+          Float(value)
+        rescue StandardError
+          nil
+        end
+      when :number
+        if value.to_s.include?(".")
+          begin
+            Float(value)
+          rescue StandardError
+            nil
+          end
+        else
+          begin
+            Integer(value)
+          rescue StandardError
+            nil
+          end
+        end
+      when :boolean
+        case value
+        when true, "true", "1", 1
+          true
+        when false, "false", "0", 0
+          false
+        end
+      when :array
+        Array(value)
+      when :object
+        value.is_a?(Hash) ? value : nil # or convert as desired
+      when :null
+        nil if value.nil?
+      else
+        raise ArgumentError, "Unsupported type: #{type}"
+      end
+    end
+  end
+end

data/lib/esquema/version.rb

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

data/lib/esquema/virtual_column.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Esquema
+  class VirtualColumn # rubocop:disable Style/Documentation
+    def initialize(property_name, options = {})
+      @property_name = property_name
+      @options = options
+    end
+
+    def name
+      @property_name.to_s
+    end
+
+    def class_name
+      @property_name.to_s.classify
+    end
+
+    def type
+      @options[:type]
+    end
+
+    def item_type
+      @options.dig(:items, :type)
+    end
+
+    def default
+      @options[:default]
+    end
+
+    def title
+      @options[:title]
+    end
+
+    def description
+      @options[:description]
+    end
+
+    def columns
+      []
+    end
+
+    def collection?
+      @options[:type] == :array
+    end
+  end
+end

data/lib/esquema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "esquema/version"
+require_relative "esquema/configuration"
+require_relative "esquema/model"
+require_relative "esquema/schema_enhancer"
+require_relative "esquema/keyword_validator"
+require_relative "esquema/builder"
+require_relative "esquema/property"
+require_relative "esquema/type_caster"
+require_relative "esquema/virtual_column"
+
+module Esquema # rubocop:disable Style/Documentation
+end

data/lib/generators/esquema/install/install_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Esquema
+  module Generators
+    # This generator is responsible for installing the Esquema gem.
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_initializer_file
+        template "esquema_initializer.rb", "config/initializers/esquema.rb"
+      end
+    end
+  end
+end

data/lib/generators/esquema/install/templates/esquema_initializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "esquema"
+
+Esquema.configure do |config|
+  # Exclude Associations:
+  # Exclude associated models from the json-schema output.
+  # By default, all associated models are included.
+  config.exclude_associations = false
+
+  # Exclude Foreign Keys:
+  # Specify whether or not to exclude foreign keys from the json-schema output.
+  # By default, foreign keys are excluded.
+  # foreign keys are loosely defined as columns that end with "_id".
+  config.exclude_foreign_keys = true
+
+  # Excluded Columns:
+  # Specify the columns that you want to exclude from the json-schema output.
+  # These are columns common to all models, such as id, created_at, updated_at, etc.
+  # It's okay if not all models have these columns, they will be ignored.
+  config.excluded_columns = %i[id created_at updated_at deleted_at]
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/activemodel.rbi

@@ -0,0 +1,89 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveModel::Errors
+  Elem = type_member { { fixed: ActiveModel::Error } }
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def [](attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(ActiveModel::Error) }
+  def add(attribute, type = :invalid, **options); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Boolean) }
+  def added?(attribute, type = :invalid, options = {}); end
+
+  sig { params(options: T.untyped).returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json(options = nil); end
+
+  sig { returns(T::Array[Symbol]) }
+  def attribute_names; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T.nilable(T::Array[String])) }
+  def delete(attribute, type = nil, **options); end
+
+  sig { returns(T::Hash[Symbol, T::Array[T::Hash[Symbol, T.untyped]]]) }
+  def details; end
+
+  sig { returns(T::Array[Elem]) }
+  def errors; end
+
+  sig { params(attribute: T.any(Symbol, String), message: String).returns(String) }
+  def full_message(attribute, message); end
+
+  sig { returns(T::Array[String]) }
+  def full_messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def full_messages_for(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(String) }
+  def generate_message(attribute, type = :invalid, options = {}); end
+
+  sig { returns(T::Hash[Symbol, T::Array[ActiveModel::Error]]) }
+  def group_by_attribute; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def has_key?(attribute); end
+
+  sig { params(error: ActiveModel::Error, override_options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def import(error, override_options = {}); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def include?(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def key?(attribute); end
+
+  sig { params(other: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def merge!(other); end
+
+  sig { returns(T::Hash[Symbol, T::Array[String]]) }
+  def messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def messages_for(attribute); end
+
+  sig { returns(T::Array[Elem]) }
+  def objects; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped).returns(T::Boolean) }
+  def of_kind?(attribute, type = :invalid); end
+
+  sig { returns(T::Array[String]) }
+  def to_a; end
+
+  sig { params(full_messages: T.untyped).returns(T::Hash[Symbol, T::Array[String]]) }
+  def to_hash(full_messages = false); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def where(attribute, type = nil, **options); end
+end
+
+module ActiveModel::Validations
+  sig { returns(ActiveModel::Errors) }
+  def errors; end
+end

data/sorbet/rbi/annotations/activerecord.rbi

@@ -0,0 +1,92 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveRecord::Schema
+  sig { params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void }
+  def self.define(info = nil, &blk); end
+end
+
+class ActiveRecord::Migration
+  # @shim: Methods on migration are delegated to `SchemaStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::SchemaStatements
+
+  # @shim: Methods on migration are delegated to `DatabaseStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::DatabaseStatements
+end
+
+class ActiveRecord::Base
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  sig { returns(TrueClass) }
+  def present?; end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_initialize(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_find(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_touch(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_commit(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_rollback(*args, **options, &block); end
+end
+
+class ActiveRecord::Relation
+  sig { returns(T::Boolean) }
+  def blank?; end
+end