forest_admin_datasource_active_record 1.0.0.pre.beta.21

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aace6865ce55eb722690ad3a410c31144c81a2ac7aa3f9db0d5dcb7d706e4544
+  data.tar.gz: 1ced7531287ce44c3d834875980471ccfaab5a7f2ea401ab84405f9547da96c8
+SHA512:
+  metadata.gz: 9c6f07ba223bcbe79dac1bd5ab787378e4b68e9e0bc75576e67cc91d7d5f7de6cac8b2d60c94d66716b7140a93c8d5b19206336e0fa6efae8d419b93a07f0565
+  data.tar.gz: fd9d4172f74352ff3226513a2bc7b59f04f26b10ba04948c6d5ee87f8cc73e9f14575fe657cb36ea1892a2d5239c893cb7e7d7fc86a5683b81c0edd959d691ca

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/README.md

@@ -0,0 +1,31 @@
+# ForestAdminDatasourceActiveRecord
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/forest_admin_datasource_active_record`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/forest_admin_datasource_active_record.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/forest_admin_datasource_active_record.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require_relative "lib/forest_admin_datasource_active_record/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "forest_admin_datasource_active_record"
+  spec.version = ForestAdminDatasourceActiveRecord::VERSION
+  spec.authors      = ["Matthieu", "Nicolas"]
+  spec.email        = ["matthv@gmail.com", "nicolasalexandre9@gmail.com"]
+  spec.homepage     = "https://www.forestadmin.com"
+  spec.summary      = "Ruby agent for Forest Admin."
+  spec.description  = "Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
+admin work on any Ruby application."
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ForestAdmin/agent-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/ForestAdmin/agent-ruby/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "false"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 6.1"
+  spec.add_dependency "zeitwerk", "~> 2.3"
+end

data/lib/forest_admin_datasource_active_record/collection.rb

@@ -0,0 +1,117 @@
+module ForestAdminDatasourceActiveRecord
+  class Collection < ForestAdminDatasourceToolkit::Collection
+    include Parser::Column
+    include Parser::Relation
+    include ForestAdminDatasourceToolkit::Components::Query
+
+    attr_reader :model
+
+    def initialize(datasource, model)
+      @model = model
+      name = model.name.demodulize.underscore
+      super(datasource, name)
+      fetch_fields
+      fetch_associations
+    end
+
+    def list(_caller, filter, projection)
+      query = Utils::Query.new(self, projection, filter).build
+
+      query.all
+    end
+
+    def aggregate(_caller, _filter, aggregation, _limit = nil)
+      field = aggregation.field || '*'
+
+      [
+        {
+          value: @model.send(aggregation.operation.downcase, field),
+          group: []
+        }
+      ]
+    end
+
+    def create(_caller, data)
+      @model.create(data)
+    end
+
+    def update(_caller, filter, data)
+      entity = Utils::Query.new(self, nil, filter).build.first
+      entity.update(data)
+    end
+
+    def delete(_caller, filter)
+      entities = Utils::Query.new(self, nil, filter).build
+      entities&.each(&:destroy)
+    end
+
+    private
+
+    def fetch_fields
+      @model.columns_hash.each do |column_name, column|
+        # TODO: check is not sti column
+        field = ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
+          column_type: get_column_type(@model, column),
+          filter_operators: operators_for_column_type(get_column_type(@model, column)),
+          is_primary_key: column_name == @model.primary_key,
+          is_read_only: false,
+          is_sortable: true,
+          default_value: column.default,
+          enum_values: get_enum_values(@model, column),
+          # validations: get_validations(column)
+          validations: []
+        )
+
+        add_field(column_name, field)
+      end
+    end
+
+    def fetch_associations
+      associations(@model).each do |association|
+        case association.macro
+        when :has_one
+          add_field(
+            association.name.to_s,
+            ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema.new(
+              foreign_collection: association.class_name.demodulize.underscore,
+              origin_key: association.foreign_key,
+              origin_key_target: association.association_primary_key
+            )
+          )
+        when :belongs_to
+          add_field(
+            association.name.to_s,
+            ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema.new(
+              foreign_collection: association.class_name.demodulize.underscore,
+              foreign_key: association.foreign_key,
+              foreign_key_target: association.association_primary_key
+            )
+          )
+        when :has_many
+          if association.through_reflection?
+            add_field(
+              association.name.to_s,
+              ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
+                foreign_collection: association.class_name.demodulize.underscore,
+                origin_key: association.through_reflection.foreign_key,
+                origin_key_target: association.through_reflection.join_foreign_key,
+                foreign_key: association.join_foreign_key,
+                foreign_key_target: association.association_primary_key,
+                through_collection: association.through_reflection.class_name.demodulize.underscore
+              )
+            )
+          else
+            add_field(
+              association.name.to_s,
+              ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema.new(
+                foreign_collection: association.class_name.demodulize.underscore,
+                origin_key: association.foreign_key,
+                origin_key_target: association.association_primary_key
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/datasource.rb

@@ -0,0 +1,29 @@
+require 'active_record'
+
+module ForestAdminDatasourceActiveRecord
+  class Datasource < ForestAdminDatasourceToolkit::Datasource
+    def initialize(db_config = {})
+      super()
+      @models = []
+      init_orm(db_config)
+      generate
+    end
+
+    private
+
+    def generate
+      ActiveRecord::Base.descendants.each { |model| fetch_model(model) }
+      @models.each do |model|
+        add_collection(Collection.new(self, model))
+      end
+    end
+
+    def fetch_model(model)
+      @models << model unless model.abstract_class? || @models.include?(model) || !model.table_exists?
+    end
+
+    def init_orm(db_config)
+      ActiveRecord::Base.establish_connection(db_config)
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/parser/column.rb

@@ -0,0 +1,71 @@
+module ForestAdminDatasourceActiveRecord
+  module Parser
+    module Column
+      include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+      TYPES = {
+        boolean: 'Boolean',
+        datetime: 'Date',
+        date: 'Dateonly',
+        integer: 'Number',
+        float: 'Number',
+        decimal: 'Number',
+        json: 'Json',
+        jsonb: 'Json',
+        hstore: 'Json',
+        string: 'String',
+        text: 'String',
+        citext: 'String',
+        time: 'Time',
+        uuid: 'Uuid',
+        binary: 'Binary'
+      }.freeze
+
+      def get_column_type(model, column)
+        if model.respond_to?(:defined_enums) &&
+           model.defined_enums.key?(column.name)
+          return 'Enum'
+        end
+
+        is_array = (column.respond_to?(:array) && column.array == true)
+        is_array ? "[#{TYPES[column.type]}]" : TYPES[column.type]
+      end
+
+      def get_enum_values(model, column)
+        enum_values = []
+        if get_column_type(model, column) == 'Enum'
+          if sti_column?(model, column)
+            model.descendants.each { |sti_model| enum_values << sti_model.name }
+          else
+            model.defined_enums[column.name].each { |name, _value| enum_values << name }
+          end
+        end
+        enum_values
+      end
+
+      def sti_column?(model, column)
+        model.inheritance_column && column.name == model.inheritance_column
+      end
+
+      def operators_for_column_type(type)
+        result = [Operators::PRESENT, Operators::MISSING]
+        equality = [Operators::EQUAL, Operators::NOT_EQUAL, Operators::IN, Operators::NOT_IN]
+
+        if type.is_a? String
+          orderables = [Operators::LESS_THAN, Operators::GREATER_THAN]
+          strings = [Operators::LIKE, Operators::I_LIKE, Operators::NOT_CONTAINS]
+
+          result += equality if %w[Boolean Binary Enum Uuid].include?(type)
+
+          result = result + equality + orderables if %w[Date Dateonly Number].include?(type)
+
+          result = result + equality + orderables + strings if %w[String].include?(type)
+        end
+
+        result = result + equality + ['Includes_All'] if type.is_a? Array
+
+        result
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/parser/relation.rb

@@ -0,0 +1,21 @@
+module ForestAdminDatasourceActiveRecord
+  module Parser
+    module Relation
+      def associations(model)
+        model.reflect_on_all_associations.select do |association|
+          !polymorphic?(association) && !active_type?(association.klass)
+        end
+      end
+
+      def polymorphic?(association)
+        association.options[:polymorphic]
+      end
+
+      # NOTICE: Ignores ActiveType::Object association during introspection and interactions.
+      #         See the gem documentation: https://github.com/makandra/active_type
+      def active_type?(model)
+        Object.const_defined?('ActiveType::Object') && model < ActiveType::Object
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/parser/validation.rb

@@ -0,0 +1,108 @@
+module ForestAdminDatasourceActiveRecord
+  module Parser
+    module Validation
+      def get_validations(column)
+        validations = []
+        # NOTICE: Do not consider validations if a before_validation Active Records
+        #         Callback is detected.
+        return validations if @model._validation_callbacks.map(&:kind).include? :before
+
+        if @model._validators? && @model._validators[column.name.to_sym].size.positive?
+          @model._validators[column.name.to_sym].each do |validator|
+            # NOTICE: Do not consider conditional validations
+            next if validator.options[:if] || validator.options[:unless] || validator.options[:on]
+
+            case validator
+            when ActiveRecord::Validations::PresenceValidator
+              validations << {
+                type: 'is present',
+                message: validator.options[:message]
+              }
+            when ActiveModel::Validations::NumericalityValidator
+              validations = parse_numericality_validator(validator, validations)
+            when ActiveModel::Validations::LengthValidator
+              validations = parse_length_validator(validator, validations)
+            when ActiveModel::Validations::FormatValidator
+              validations = parse_format_validator(validator, validations)
+            end
+          end
+        end
+
+        validations
+      end
+
+      def parse_numericality_validator(validator, parsed_validations)
+        validator.options.each do |option, value|
+          case option
+          when :greater_than, :greater_than_or_equal_to
+            parsed_validations << {
+              type: 'is greater than',
+              value: value,
+              message: validator.options[:message]
+            }
+          when :less_than, :less_than_or_equal_to
+            parsed_validations << {
+              type: 'is less than',
+              value: value,
+              message: validator.options[:message]
+            }
+          end
+        end
+      end
+
+      def parse_length_validator(validator, parsed_validations)
+        return unless get_column_type(column) == 'String'
+
+        validator.options.each do |option, value|
+          case option
+          when :minimum
+            parsed_validations << {
+              type: 'is longer than',
+              value: value,
+              message: validator.options[:message]
+            }
+          when :maximum
+            parsed_validations << {
+              type: 'is shorter than',
+              value: value,
+              message: validator.options[:message]
+            }
+          when :is
+            parsed_validations << {
+              type: 'is longer than',
+              value: value,
+              message: validator.options[:message]
+            }
+            parsed_validations << {
+              type: 'is shorter than',
+              value: value,
+              message: validator.options[:message]
+            }
+          end
+        end
+      end
+
+      def parse_format_validator(validator, parsed_validations)
+        validator.options.each do |option, value|
+          case option
+          when :with
+            options = /\?([imx]){0,3}/.match(validator.options[:with].to_s)
+            options = options && options[1] ? options[1] : ''
+            regex = value.source
+
+            # NOTICE: Transform a Ruby regex into a JS one
+            regex = regex.sub('\\A', '^').sub('\\Z', '$').sub('\\z', '$').gsub(/\n+|\s+/, '')
+
+            parsed_validations << {
+              type: 'is like',
+              value: "/#{regex}/#{options}",
+              message: validator.options[:message]
+            }
+          end
+        end
+
+        parsed_validations
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/utils/query.rb

@@ -0,0 +1,118 @@
+module ForestAdminDatasourceActiveRecord
+  module Utils
+    class Query
+      include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+      def initialize(collection, projection, filter)
+        @collection = collection
+        @query = @collection.model
+        @projection = projection
+        @filter = filter
+        @arel_table = @collection.model.arel_table
+      end
+
+      def build
+        @query = select
+        @query = apply_filter
+
+        @query
+      end
+
+      def apply_filter
+        @query = apply_condition_tree(@filter.condition_tree) unless @filter.condition_tree.nil?
+        @query = apply_pagination(@filter.page) unless @filter.page.nil?
+
+        @query
+      end
+
+      def apply_pagination(page)
+        @query.offset(page.offset).limit(page.limit)
+
+        @query
+      end
+
+      def apply_condition_tree(condition_tree, aggregator = nil)
+        if condition_tree.is_a? Nodes::ConditionTreeBranch
+          aggregator = condition_tree.aggregator.downcase
+          condition_tree.conditions.each do |condition|
+            query = apply_condition_tree(condition, aggregator)
+            @query = @query.send(aggregator, query)
+          end
+
+          @query
+        else
+          compute_main_operator(condition_tree, aggregator || 'and')
+        end
+      end
+
+      def compute_main_operator(condition_tree, aggregator)
+        field = format_field(condition_tree.field)
+        value = condition_tree.value
+
+        case condition_tree.operator
+        when Operators::PRESENT
+          @query = @query.send(aggregator, @query.where.not({ field => nil }))
+        when Operators::EQUAL, Operators::IN
+          @query = @query.send(aggregator, @query.where({ field => value }))
+        when Operators::NOT_EQUAL, Operators::NOT_IN
+          @query = @query.send(aggregator, @query.where.not({ field => value }))
+        when Operators::GREATER_THAN
+          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].gt(value)))
+        when Operators::LESS_THAN
+          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].lt(value)))
+        when Operators::NOT_CONTAINS
+          @query = @query.send(aggregator, @query.where.not(@arel_table[field.to_sym].matches("%#{value}%")))
+        when Operators::CONTAINS
+          @query = @query.send(aggregator, @query.where(@arel_table[field.to_sym].matches("%#{value}%")))
+        when Operators::INCLUDES_ALL
+          # TODO: to implement
+        end
+
+        @query
+      end
+
+      def select
+        unless @projection.nil?
+          query_select = @projection.columns.map { |field| "#{@collection.model.table_name}.#{field}" }
+          @projection.relations.each do |relation, _fields|
+            relation_schema = @collection.fields[relation]
+            if relation_schema.type == 'OneToOne'
+              query_select.push("#{@collection.model.table_name}.#{relation_schema.origin_key_target}")
+            else
+              query_select.push("#{@collection.model.table_name}.#{relation_schema.foreign_key}")
+            end
+          end
+
+          @query = @query.select(query_select.join(', '))
+          @query = @query.eager_load(@projection.relations.keys.map(&:to_sym))
+          # TODO: replace eager_load by joins because eager_load select ALL columns of relation
+          # @query = @query.joins(@projection.relations.keys.map(&:to_sym))
+        end
+
+        @query
+      end
+
+      def add_join_relation(relation, relation_name)
+        if relation.type == 'ManyToMany'
+          # TODO: to implement
+        else
+          @query = @query.joins(relation_name.to_sym)
+        end
+
+        @query
+      end
+
+      def format_field(field)
+        if field.include?(':')
+          relation_name, field = field.split(':')
+          relation = @collection.fields[relation_name]
+          table_name = @collection.datasource.collection(relation.foreign_collection).model.table_name
+          add_join_relation(relation, relation_name)
+          return "#{table_name}.#{field}"
+        end
+
+        field
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_active_record/version.rb

@@ -0,0 +1,3 @@
+module ForestAdminDatasourceActiveRecord
+  VERSION = "1.0.0-beta.21"
+end

data/lib/forest_admin_datasource_active_record.rb

@@ -0,0 +1,11 @@
+require_relative 'forest_admin_datasource_active_record/version'
+# require 'forest_admin_datasource_toolkit'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module ForestAdminDatasourceActiveRecord
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/forest_admin_datasource_active_record/collection.rbs

@@ -0,0 +1,11 @@
+module ForestAdminDatasourceActiveRecord
+  class Collection
+    @model: untyped
+
+    private
+
+    def fetch_fields: -> void
+
+    def get_enum_values: -> [String]
+  end
+end

data/sig/forest_admin_datasource_active_record.rbs

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

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: forest_admin_datasource_active_record
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.beta.21
+platform: ruby
+authors:
+- Matthieu
+- Nicolas
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: |-
+  Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
+  admin work on any Ruby application.
+email:
+- matthv@gmail.com
+- nicolasalexandre9@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- README.md
+- Rakefile
+- forest_admin_datasource_active_record.gemspec
+- lib/forest_admin_datasource_active_record.rb
+- lib/forest_admin_datasource_active_record/collection.rb
+- lib/forest_admin_datasource_active_record/datasource.rb
+- lib/forest_admin_datasource_active_record/parser/column.rb
+- lib/forest_admin_datasource_active_record/parser/relation.rb
+- lib/forest_admin_datasource_active_record/parser/validation.rb
+- lib/forest_admin_datasource_active_record/utils/query.rb
+- lib/forest_admin_datasource_active_record/version.rb
+- sig/forest_admin_datasource_active_record.rbs
+- sig/forest_admin_datasource_active_record/collection.rbs
+homepage: https://www.forestadmin.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.forestadmin.com
+  source_code_uri: https://github.com/ForestAdmin/agent-ruby
+  changelog_uri: https://github.com/ForestAdmin/agent-ruby/CHANGELOG.md
+  rubygems_mfa_required: 'false'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Ruby agent for Forest Admin.
+test_files: []