rails-fields 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f6148f3e28ada22e83ccdd3d5c9ebe0054a61e61d28af95fcac0052b42e03ef5
+  data.tar.gz: 9095670043d7f5df6fc540739c2b81951d16b2abc4da9b901ce3f58c7aa71515
+SHA512:
+  metadata.gz: 16125dfe4d17cc6b2c12465bf7182a0e73d0be3e2e79efb33b6feaa8272bc79bed026bc4ff5f35d3cf1bf27ed23c6b17151083827b55f9cf2f09be80b7410782
+  data.tar.gz: 956dc90b7ee6e99f1a0fb75987d86b1d0f88db2e294d9ff334c77f06da1476cc29fb538d4c2e7748b55f1f7e76b24a8bd574328d5e2a33be22524cb81536d21e

data/README.md

@@ -0,0 +1,39 @@
+# Rails Fields
+
+## Summary
+Enforce field types and attributes for ActiveRecord models in Ruby on Rails applications.
+
+## Description
+The `rails-fields` gem provides robust field type enforcement for ActiveRecord models in Ruby on Rails applications. It includes utility methods for type validation, logging, and field mappings between GraphQL and ActiveRecord types. Custom error classes provide clear diagnostics for field-related issues, making it easier to maintain consistent data models.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails-fields'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install rails-fields
+```
+
+## Usage
+
+(TBD: Add usage examples here)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Author
+
+Gaston Morixe - gaston@gastonmorixe.com

data/lib/rails_fields/class_methods.rb

@@ -0,0 +1,125 @@
+module RailsFields
+  module ClassMethods
+    # TODO: Check  all models at rails init app? like migrations?
+
+    def declared_fields
+      @declared_fields ||= []
+    end
+
+    def declared_fields=(value)
+      @declared_fields = value
+    end
+
+    def write_migration(index: nil)
+      changes = RailsFields::Utils.detect_changes(self)
+      RailsFields::Utils.generate_migration(self, changes, index:, write: true)
+    end
+
+    # Declares a field with enforcement.
+    #
+    # @!method
+    #   @param name [Symbol] the name of the field
+    #   @param type [Symbol] the type of the field
+    #   @param null [Boolean] whether the field can be null (default: true)
+    #   @param index [Boolean] whether to index the field (default: false)
+    #   @return [void]
+    #
+    # @!macro [attach] field
+    #   @!attribute $1
+    #   @return [$2] the $1 property
+    def field(name, type, null: true, index: false)
+      # Check if type is a valid GraphQL type
+      # GraphQL::Types.const_get(type) if type.is_a?(Symbol) || type.is_a?(String)
+      unless Utils.valid_type?(type)
+        raise Errors::RailsFieldsUnknownTypeError.new("
+          Declared field '#{name}' in class '#{self.name}' of unknown type '#{type}'. Allowed types are: #{Utils.allowed_types.join(', ')}.
+        ")
+      end
+
+      declared_fields << OpenStruct.new(name: name.to_s, type:, null:, index:)
+    end
+
+    def gql_type
+      return RailsFields.processed_classes[self] if RailsFields.processed_classes[self].present?
+
+      fields = declared_fields
+      owner_self = self
+
+      type = Class.new(::Types::BaseObject) do
+        # graphql_name "#{owner_self.name}Type"
+        graphql_name "#{owner_self.name}"
+        description "A type representing a #{owner_self.name}"
+
+        fields.each do |f|
+          next if f.type.nil? # TODO: ! remove references fields
+
+          # Assuming a proper mapping from your custom types to GraphQL types
+          # TODO: use a better method or block
+          field_gql_type = f.name == :id ? GraphQL::Types::ID : Utils::RAILS_TO_GQL_TYPE_MAP[f.type]
+          field f.name, field_gql_type
+        end
+      end
+
+      # Cache the processed class here to prevent infinite recursion
+      RailsFields.processed_classes[self] = type
+
+      type.instance_eval do
+        owner_self.reflections.each do |association_name, reflection|
+          if reflection.macro == :has_many
+            reflection_klass = if reflection.options[:through]
+              through_reflection_klass = reflection.through_reflection.klass
+              source_reflection_name = reflection.source_reflection_name.to_s
+              source_reflection = through_reflection_klass.reflections[source_reflection_name]
+              source_reflection ? source_reflection.klass : through_reflection_klass
+            else
+              reflection.klass
+            end
+            field association_name, [reflection_klass.gql_type], null: true
+          elsif reflection.macro == :belongs_to
+            field association_name, reflection.klass.gql_type, null: true
+          end
+        end
+
+        type
+      end
+    end
+
+    def enforce_declared_fields
+      database_columns = column_names.map(&:to_sym)
+      declared_fields_names = declared_fields.map(&:name).map(&:to_sym) || []
+      changes = RailsFields::Utils.detect_changes(self)
+      migration = RailsFields::Utils.generate_migration(self, changes)
+      instance_methods = self.instance_methods(false).select do |method|
+        instance_method(method).source_location.first.start_with?(Rails.root.to_s)
+      end
+      extra_methods = instance_methods - declared_fields_names.map(&:to_sym)
+      has_changes = !changes.nil?
+
+      unless extra_methods.empty?
+        # TODO: Custom error subclass
+        raise "You have extra methods declared in #{name}: #{extra_methods.join(', ')}. Please remove them or declare them as fields."
+      end
+
+      if has_changes
+        error_message = <<~STRING
+
+          ----------------
+
+          Declared Fields:
+          #{declared_fields_names.join(', ')}
+
+          Database columns:
+          #{database_columns.join(', ')}
+
+          Changes:
+          #{changes.to_yaml.lines[1..-1].join}
+          Migration:
+          #{migration}
+
+          ----------------
+        STRING
+        raise Errors::RailsFieldsMismatchError.new(error_message)
+      end
+    end
+  end
+end

data/lib/rails_fields/errors/rails_fields_error.rb

@@ -0,0 +1,5 @@
+module RailsFields
+  module Errors
+    class RailsFieldsError < StandardError; end
+  end
+end

data/lib/rails_fields/errors/rails_fields_mismatch_error.rb

@@ -0,0 +1,18 @@
+module RailsFields
+  module Errors
+    class RailsFieldsMismatchError < RailsFieldsError
+      include ActiveSupport::ActionableError
+
+      action "Save migrations" do
+        models = RailsFields::Utils.active_record_models
+        models.each_with_index do |m, index|
+          m.write_migration(index:)
+        end
+      end
+
+      # action "Run db:migrations" do
+      #   ActiveRecord::Tasks::DatabaseTasks.migrate
+      # end
+    end
+  end
+end

data/lib/rails_fields/errors/rails_fields_unknown_type_error.rb

@@ -0,0 +1,5 @@
+module RailsFields
+  module Errors
+    class RailsFieldsUnknownTypeError < RailsFieldsError; end
+  end
+end

data/lib/rails_fields/instance_methods.rb

@@ -0,0 +1,4 @@
+module RailsFields
+  module InstanceMethods
+  end
+end

data/lib/rails_fields/utils/helpers.rb

@@ -0,0 +1,202 @@
+module RailsFields
+  module Utils
+    class << self
+      def allowed_types
+        # TODO: this may depend on the current database adapter or mapper
+        ActiveRecord::Base.connection.native_database_types.keys
+      end
+
+      def valid_type?(type)
+        # TODO: this may depend on the current database adapter or mapper
+        allowed_types.include?(type)
+      end
+
+      def active_record_models
+        Rails.application.eager_load! # Ensure all models are loaded
+
+        ActiveRecord::Base.descendants.reject do |model|
+          !(model.is_a?(Class) && model < ApplicationRecord) ||
+            model.abstract_class? ||
+            model.name.nil? ||
+            model.name == "ActiveRecord::SchemaMigration"
+        end
+      end
+
+      # Detect changes between the ActiveRecord model declared fields and the database structure.
+      # @example
+      #   model_changes = FieldEnforcement::Utils.detect_changes(User)
+      #   # => {
+      #     added: [],
+      #     removed: [],
+      #     renamed: [],
+      #     type_changed: [],
+      #     potential_renames: []
+      #   }
+      # @param model [ActiveRecord::Base] the model to check
+      # @return [Hash, Nil] the changes detected
+      def detect_changes(model)
+        previous_fields = model.attribute_types.to_h { |k, v| [k.to_sym, v.type] }
+        declared_fields = model.declared_fields.to_h do |f|
+          [f.name.to_sym, {
+            name: f.type.to_sym,
+            options: f.options
+          }]
+        end
+
+        LOGGER.debug "Log: previous_fields: #{previous_fields}"
+        LOGGER.debug "Log: declared_fields #{declared_fields}}"
+
+        model_changes = {
+          added: [],
+          removed: [],
+          renamed: [],
+          type_changed: [],
+          potential_renames: [],
+          associations_added: [],
+          associations_removed: []
+        }
+
+        # Detect added and type-changed fields
+        declared_fields.each do |name, type|
+          type_name = type[:name]
+          if previous_fields[name]
+            if previous_fields[name] != type_name
+              model_changes[:type_changed] << { name:, from: previous_fields[name],
+                                                to: type }
+            end
+          else
+            model_changes[:added] << { name:, type: }
+          end
+        end
+
+        LOGGER.debug "Log: model_changes[:added] before filter #{model_changes[:added]}"
+        # Remove added fields that have a defined method in the the model
+        model_changes[:added] = model_changes[:added].filter { |f| !model.instance_methods.include?(f[:name]) }
+        LOGGER.debug "Log: model_changes[:added] after filter #{model_changes[:added]}"
+
+        # Detect removed fields
+        removed_fields = previous_fields.keys - declared_fields.keys
+        model_changes[:removed] = removed_fields.map { |name| { name:, type: previous_fields[name] } }
+
+        LOGGER.debug "Log: model_changes[:removed] 1 #{model_changes[:removed]}"
+
+        # Remove foreign keys from removed fields
+        associations = model.reflections.values.map(&:foreign_key).map(&:to_sym)
+        model_changes[:removed].reject! { |f| associations.include?(f[:name]) }
+
+        LOGGER.debug "Log: model_changes[:removed] 2 #{model_changes[:removed]} | associations #{associations}"
+
+        # Detect potential renames
+        potential_renames = []
+        model_changes[:removed].each do |removed_field|
+          # puts "Log: removed_field: #{removed_field}"
+          added_field = model_changes[:added].find { |f| f[:type] == removed_field[:type] }
+          if added_field
+            potential_renames << { from: removed_field[:name],
+                                   to: added_field[:name] }
+          end
+        end
+
+        LOGGER.debug "Log: potential_renames: #{potential_renames}"
+
+        model_changes[:potential_renames] = potential_renames
+
+        # Filter out incorrect renames (one-to-one mapping)
+        potential_renames.each do |rename|
+          next unless model_changes[:added].count { |f| f[:type] == rename[:to].to_sym } == 1 &&
+            model_changes[:removed].count { |f| f[:type] == rename[:from].to_sym } == 1
+
+          model_changes[:renamed] << rename
+          model_changes[:added].reject! { |f| f[:name] == rename[:to].to_sym }
+          model_changes[:removed].reject! { |f| f[:name] == rename[:from].to_sym }
+        end
+
+        # Handle associations changes
+        declared_associations = model.reflections.values.select do |reflection|
+          [:belongs_to].include?(reflection.macro)
+        end
+
+        declared_foreign_keys = declared_associations.map(&:foreign_key).map(&:to_sym)
+        existing_foreign_keys = ActiveRecord::Base.connection.foreign_keys(model.table_name).map(&:options).map { |opt| opt[:column].to_sym }
+
+        associations_added = declared_associations.select do |reflection|
+          !existing_foreign_keys.include?(reflection.foreign_key.to_sym)
+        end
+
+        associations_removed = existing_foreign_keys.select do |foreign_key|
+          !declared_foreign_keys.include?(foreign_key)
+        end.map { |foreign_key| model.reflections.values.find { |reflection| reflection.foreign_key == foreign_key.to_s } }
+
+        model_changes[:associations_added] = associations_added
+        model_changes[:associations_removed] = associations_removed
+
+        return model_changes unless model_changes.values.all?(&:empty?)
+
+        nil
+      end
+
+      def generate_migration(model, model_changes, index: 0, write: false)
+        return if model_changes.blank?
+
+        model_name = model.name
+        timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i + index
+        migration_class_name = "#{model_name}Migration#{timestamp}"
+
+        migration_code = []
+        migration_code << "class #{migration_class_name} < ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]"
+
+        migration_code << "  def change"
+
+        model_changes.dig(:added)&.each do |change|
+          field_type = change[:type]
+          field_type_for_db = field_type[:name]
+          # TODO: custom mapper
+          migration_code << "    add_column :#{model_name.tableize}, :#{change[:name]}, :#{field_type_for_db}"
+        end
+
+        # Handle added associations
+        model_changes.dig(:associations_added)&.each do |assoc|
+          migration_code << "    add_reference :#{model_name.tableize}, :#{assoc.name}, foreign_key: true"
+        end
+
+        # Handle removed associations
+        model_changes.dig(:associations_removed)&.each do |assoc|
+          migration_code << "    remove_reference :#{model_name.tableize}, :#{assoc.name}, foreign_key: true"
+        end
+
+        # Handle removed fields
+        model_changes.dig(:removed)&.each do |change|
+          migration_code << "    remove_column :#{model_name.tableize}, :#{change[:name]}"
+        end
+
+        # Handle renamed fields
+        model_changes.dig(:renamed)&.each do |change|
+          change_to = change[:to]
+          migration_code << "    rename_column :#{model_name.tableize}, :#{change[:from]}, :#{change_to}"
+        end
+
+        # Handle fields' type changes
+        model_changes.dig(:type_changed)&.each do |change|
+          change_to = change[:to]
+          migration_code << "    change_column :#{model_name.tableize}, :#{change[:name]}, :#{change_to}"
+        end
+
+        migration_code << "  end"
+        migration_code << "end"
+        migration_code << ""
+
+        write_migration(migration_code, migration_class_name, timestamp) if write
+
+        migration_code.join("\n")
+      end
+
+      def write_migration(migration_code, migration_class_name, timestamp)
+        migration_filename = "#{timestamp}_#{migration_class_name.underscore}.rb"
+        migration_path = Rails.root.join("db", "migrate", migration_filename)
+        File.write(migration_path, migration_code.join("\n"))
+        LOGGER.info "Migration saved at #{migration_path}"
+        { migration_filename:, migration_path: }
+      end
+    end
+  end
+end

data/lib/rails_fields/utils/logging.rb

@@ -0,0 +1,11 @@
+require "logger"
+
+module RailsFields
+  module Utils
+    LOGGER = begin
+      logger = Logger.new($stdout)
+      logger.level = Rails.env.production? ? Logger::INFO : Logger::DEBUG
+      logger
+    end
+  end
+end

data/lib/rails_fields/utils/mappings.rb

@@ -0,0 +1,29 @@
+module RailsFields
+  module Utils
+    # TODO: mapper can be different or custom
+    GQL_TO_RAILS_TYPE_MAP = {
+      ::GraphQL::Types::String => :string,
+      ::GraphQL::Types::Int => :integer,
+      ::GraphQL::Types::Float => :float,
+      ::GraphQL::Types::Boolean => :boolean,
+      ::GraphQL::Types::ID => :integer, # or :string depending on how you handle IDs
+      ::GraphQL::Types::ISO8601DateTime => :datetime,
+      ::GraphQL::Types::ISO8601Date => :date,
+      ::GraphQL::Types::JSON => :json,
+      ::GraphQL::Types::BigInt => :bigint
+    }.freeze
+
+    RAILS_TO_GQL_TYPE_MAP = {
+      # id: ::GraphQL::Types::String,
+      string: ::GraphQL::Types::String,
+      integer: ::GraphQL::Types::Int,
+      float: ::GraphQL::Types::Float,
+      boolean: ::GraphQL::Types::Boolean,
+      datetime: ::GraphQL::Types::ISO8601DateTime,
+      date: ::GraphQL::Types::ISO8601Date,
+      json: ::GraphQL::Types::JSON,
+      bigint: ::GraphQL::Types::BigInt,
+      text: ::GraphQL::Types::String
+    }.freeze
+  end
+end

data/lib/rails_fields/version.rb

@@ -0,0 +1,3 @@
+module RailsFields
+  VERSION = "0.1.0"
+end

data/lib/rails_fields.rb

@@ -0,0 +1,26 @@
+require "rails_fields/errors/rails_fields_error"
+require "rails_fields/errors/rails_fields_mismatch_error"
+require "rails_fields/errors/rails_fields_unknown_type_error"
+require "rails_fields/utils/logging"
+require "rails_fields/utils/mappings"
+require "rails_fields/utils/helpers"
+require "rails_fields/class_methods"
+require "rails_fields/instance_methods"
+
+# Provides enforcement of declared field for ActiveRecord models.
+module RailsFields
+  @processed_classes = {}
+
+  def self.processed_classes
+    @processed_classes
+  end
+
+  # @param base [ActiveRecord::Base] the model to include the module in
+  def self.included(base)
+    # base.extend(ClassMethods)
+    # todo: raise if class methods not found
+    base.after_initialize do
+      self.class.enforce_declared_fields
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: rails-fields
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gaston Morixe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-27 00:00:00.000000000 Z
+dependencies: []
+description: The rails-fields gem provides robust field type enforcement for ActiveRecord
+  models in Ruby on Rails applications. It includes utility methods for type validation,
+  logging, and field mappings between GraphQL and ActiveRecord types. Custom error
+  classes provide clear diagnostics for field-related issues, making it easier to
+  maintain consistent data models.
+email:
+- gaston@gastonmorixe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rails_fields.rb
+- lib/rails_fields/class_methods.rb
+- lib/rails_fields/errors/rails_fields_error.rb
+- lib/rails_fields/errors/rails_fields_mismatch_error.rb
+- lib/rails_fields/errors/rails_fields_unknown_type_error.rb
+- lib/rails_fields/instance_methods.rb
+- lib/rails_fields/utils/helpers.rb
+- lib/rails_fields/utils/logging.rb
+- lib/rails_fields/utils/mappings.rb
+- lib/rails_fields/version.rb
+homepage: https://github.com/gastonmorixe/rails-fields
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Enforce field types and attributes for ActiveRecord models in Ruby on Rails
+  applications.
+test_files: []