forest_admin_datasource_mongoid 1.0.1

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_mongoid.gemspec

@@ -0,0 +1,38 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require_relative "lib/forest_admin_datasource_mongoid/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "forest_admin_datasource_mongoid"
+  spec.version = ForestAdminDatasourceMongoid::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 = "GPL-3.0"
+  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/blob/main/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 "mongoid", ">= 9.0"
+  spec.add_dependency "activesupport", ">= 6.1"
+  spec.add_dependency "zeitwerk", "~> 2.3"
+end

data/lib/forest_admin_datasource_mongoid/collection.rb

@@ -0,0 +1,135 @@
+module ForestAdminDatasourceMongoid
+  class Collection < ForestAdminDatasourceToolkit::Collection
+    include ForestAdminDatasourceToolkit::Components::Query
+    include ForestAdminDatasourceToolkit::Exceptions
+    include Parser::Column
+    include Parser::Relation
+    include Parser::Validation
+    include Utils::AddNullValues
+    include Utils::Schema
+    include Utils::Pipeline
+    include Utils::Helpers
+
+    attr_reader :model, :stack
+
+    def initialize(datasource, model, stack)
+      prefix = stack[stack.length - 1][:prefix]
+
+      @model = model
+      @stack = stack
+      model_name = format_model_name(@model.name)
+      name = escape(prefix ? "#{model_name}.#{prefix}" : model_name)
+      super(datasource, name)
+
+      add_fields(FieldsGenerator.build_fields_schema(model, stack))
+      enable_count
+    end
+
+    def list(_caller, filter, projection)
+      projection = projection.union(filter.condition_tree&.projection || [], filter.sort&.projection || [])
+      pipeline = [*build_base_pipeline(filter, projection), *ProjectionGenerator.project(projection)]
+      add_null_values(replace_mongo_types(model.unscoped.collection.aggregate(pipeline).to_a), projection)
+    end
+
+    def aggregate(_caller, filter, aggregation, limit = nil)
+      lookup_projection = aggregation.projection.union(filter.condition_tree&.projection || [])
+      pipeline = [
+        *build_base_pipeline(filter, lookup_projection),
+        *GroupGenerator.group(aggregation),
+        { '$sort' => { value: -1 } }
+      ]
+      pipeline << { '$limit' => limit } if limit
+      rows = model.unscoped.collection.aggregate(pipeline).to_a
+
+      replace_mongo_types(rows)
+    end
+
+    def create(caller, data)
+      handle_validation_error { _create(caller, data) }
+    end
+
+    def _create(_caller, flat_data)
+      as_fields = @stack[stack.length - 1][:as_fields]
+      data = unflatten_record(flat_data, as_fields)
+      inserted_record = @model.create(data)
+
+      { '_id' => inserted_record.attributes['_id'], **flat_data }
+    end
+
+    def update(caller, filter, data)
+      handle_validation_error { _update(caller, filter, data) }
+    end
+
+    def _update(_caller, filter, flat_patch)
+      as_fields = @stack[stack.length - 1][:as_fields]
+      patch = unflatten_record(flat_patch, as_fields, patch_mode: true)
+      formatted_patch = reformat_patch(patch)
+
+      records = list(nil, filter, Projection.new(['_id']))
+      ids = records.map { |record| record['_id'] }
+
+      if ids.length > 1
+        @model.where(_id: ids).update_all(formatted_patch)
+      else
+        @model.find(ids.first).update(formatted_patch)
+      end
+    end
+
+    def delete(caller, filter)
+      handle_validation_error { _delete(caller, filter) }
+    end
+
+    def _delete(_caller, filter)
+      records = list(nil, filter, Projection.new(['_id']))
+      ids = records.map { |record| record['_id'] }
+
+      @model.where(_id: ids).delete_all
+    end
+
+    private
+
+    def build_base_pipeline(filter, projection)
+      fields_used_in_filters = FilterGenerator.list_relations_used_in_filter(filter)
+
+      pre_sort_and_paginate,
+        sort_and_paginate_post_filtering,
+        sort_and_paginate_all = FilterGenerator.sort_and_paginate(model, filter)
+
+      reparent_stages = ReparentGenerator.reparent(model, stack)
+
+      # For performance reasons, we want to only include the relationships that are used in filters
+      # before applying the filters
+      lookup_used_in_filters_stage = LookupGenerator.lookup(model, stack, projection,
+                                                            { include: fields_used_in_filters })
+      filter_stage = FilterGenerator.filter(model, stack, filter)
+      # Here are the remaining relationships that are not used in filters. For performance reasons
+      # they are computed after the filters.
+      lookup_not_filtered_stage = LookupGenerator.lookup(
+        model,
+        stack,
+        projection,
+        { exclude: fields_used_in_filters }
+      )
+
+      [
+        *pre_sort_and_paginate,
+        *reparent_stages,
+        *lookup_used_in_filters_stage,
+        *filter_stage,
+        *sort_and_paginate_post_filtering,
+        *lookup_not_filtered_stage,
+        *sort_and_paginate_all
+      ]
+    end
+
+    def format_model_name(class_name)
+      class_name.gsub('::', '__')
+    end
+
+    def handle_validation_error
+      yield
+    rescue Mongoid::Errors::Validations => e
+      raise ForestAdminDatasourceToolkit::Exceptions::ValidationError, e.message
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/datasource.rb

@@ -0,0 +1,125 @@
+require 'mongo'
+require 'mongoid'
+
+module ForestAdminDatasourceMongoid
+  class Datasource < ForestAdminDatasourceToolkit::Datasource
+    include Utils::Helpers
+
+    attr_reader :models
+
+    def initialize(options: {})
+      super()
+
+      if options && !options[:flatten_mode]
+        ForestAdminAgent::Facades::Container.logger.log(
+          'Warn',
+          'Using unspecified flattenMode. ' \
+          'Please refer to the documentation to update your code: ' \
+          'https://docs.forestadmin.com/developer-guide-agents-ruby/data-sources/provided-data-sources/mongoid'
+        )
+      end
+
+      generate(options)
+    end
+
+    private
+
+    def generate(options)
+      models = ObjectSpace.each_object(Class).select do |klass|
+        klass < Mongoid::Document && klass.name && !klass.name.start_with?('Mongoid::') && !embedded_in_relation?(klass)
+      end
+
+      # Create collections (with only many to one relations).
+      models.each do |model|
+        ForestAdminDatasourceMongoid::Utils::Schema::MongoidSchema.from_model(model)
+        options_parser = OptionsParser.parse_options(model, options)
+
+        add_model(model, schema, [], nil, options_parser[:as_fields], options_parser[:as_models])
+      end
+
+      # Add one-to-many, one-to-one and many-to-many relations.
+      ForestAdminDatasourceMongoid::Utils::Schema::RelationGenerator.add_implicit_relations(@collections)
+    end
+
+    def add_model(
+      model,
+      schema,
+      stack, # current only
+      prefix, # prefix that we should handle in this recursion
+      as_fields, # current + children
+      as_models
+    ) # current + children
+      local_as_fields = as_fields.filter { |f| as_models.none? { |i| f.start_with?("#{i}.") } }
+      local_as_models = as_models.filter { |f| as_models.none? { |i| f.start_with?("#{i}.") } }
+      # peut etre faut faire un union parce qu'on pige rien ici de ce merdier
+      local_stack = stack.union([{ prefix: prefix, as_fields: local_as_fields, as_models: local_as_models }])
+
+      add_collection(Collection.new(self, model, local_stack))
+
+      local_as_models.each do |name|
+        sub_prefix = prefix ? "#{prefix}.#{name}" : name
+        sub_as_fields = unnest(as_fields, name)
+        sub_as_models = unnest(as_models, name)
+
+        add_model(model, schema, local_stack, sub_prefix, sub_as_fields, sub_as_models)
+      end
+    end
+
+    def check_as_fields(schema, prefix, local_as_fields)
+      local_schema = schema.get_sub_schema(prefix)
+      local_as_fields.each do |field|
+        name = prefix ? "#{prefix}.#{field}" : field
+
+        if !field.include?('.') && prefix
+          raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                "asFields contains '#{name}', which can't be flattened further because " \
+                "asModels contains '#{prefix}', so it is already at the root of a collection."
+        end
+
+        unless field.include?('.')
+          raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                "asFields contains '${name}', which can't be flattened because it is already at  " \
+                'the root of the model.'
+        end
+
+        next unless contains_intermediary_array(local_schema, field)
+
+        raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+              "asFields contains '${name}', " \
+              "which can't be moved to the root of the model, because it is inside of an array. " \
+              'Either add all intermediary arrays to asModels, or remove it from asFields.'
+      end
+    end
+
+    def check_as_models(schema, prefix, local_as_models)
+      local_schema = schema.get_sub_schema(prefix)
+
+      local_as_models.each do |field|
+        name = prefix ? "#{prefix}.#{field}" : field
+
+        next unless contains_intermediary_array(local_schema, field)
+
+        raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+              "asModels contains '#{name}', " \
+              "which can't be transformed into a model, because it is inside of an array. " \
+              'Either add all intermediary arrays to asModels, or remove it from asModels.'
+      end
+    end
+
+    def contains_intermediary_array(_local_schema, _field)
+      index = field.index('.')
+
+      while index != -1
+        prefix = field[0, index]
+
+        return true if schema.get_sub_schema(prefix).is_array
+
+        index = field.index('.', index + 1)
+      end
+    end
+
+    def embedded_in_relation?(klass)
+      klass.relations.any? { |_name, association| association.is_a?(Mongoid::Association::Embedded::EmbeddedIn) }
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/options_parser.rb

@@ -0,0 +1,79 @@
+module ForestAdminDatasourceMongoid
+  class OptionsParser
+    def self.parse_options(model, options)
+      schema = ForestAdminDatasourceMongoid::Utils::Schema::MongoidSchema.from_model(model)
+
+      case options[:flatten_mode]
+      when 'manual'
+        get_manual_flatten_options(schema, options, model.name)
+      when 'none'
+        { as_fields: [], as_models: [] }
+      else
+        get_auto_flatten_options(schema)
+      end
+    end
+
+    class << self
+      private
+
+      def get_auto_flatten_options(schema)
+        forbidden_paths = schema.list_paths_matching(->(_, s) { !can_be_flattened(s) })
+
+        # Split on all arrays of objects and arrays of references.
+        as_models = schema.list_paths_matching(proc do |field, path_schema|
+          path_schema.is_array &&
+            (!path_schema.is_leaf ||
+              (path_schema.schema_node&.options.is_a?(Hash) && path_schema.schema_node.options[:ref])) &&
+            forbidden_paths.none? { |p| field == p || field.start_with?("#{p}.") }
+        end).sort
+
+        # flatten all fields which are nested
+        as_fields = schema.list_paths_matching(proc do |field, path_schema|
+          # on veut flatten si on est à plus de 1 niveau de profondeur par rapport au asModels
+          min_distance = field.split('.').length
+
+          as_models.each do |as_model|
+            if field.start_with?("#{as_model}.")
+              distance = field.split('.').length - as_model.split('.').length
+              min_distance = distance if distance < min_distance
+            end
+          end
+
+          !as_models.include?(field) && path_schema.is_leaf && min_distance > 1 && forbidden_paths.none? do |p|
+            field.start_with?("#{p}.")
+          end
+        end)
+
+        { as_fields: as_fields, as_models: as_models }
+      end
+
+      def can_be_flattened(schema)
+        return true if schema.is_leaf
+
+        !schema.fields.empty?
+      end
+
+      def get_manual_flatten_options(schema, options, model_name)
+        as_models = (options[:flatten_options]&.[](model_name)&.[](:as_models) || [])
+                    .map { |f| f.tr(':', '.') }
+                    .sort
+
+        as_fields = (options[:flatten_options]&.[](model_name)&.[](:as_fields) || [])
+                    .flat_map do |item|
+                      field = (item.is_a?(String) ? item : item[:field]).tr(':', '.')
+                      level = item.is_a?(String) ? 99 : item[:level]
+                      sub_schema = schema.get_sub_schema(field)
+
+                      if sub_schema.is_leaf
+                        [field]
+                      else
+                        sub_schema.list_fields(level).map { |f| "#{field}.#{f}" }
+                      end
+                    end
+        as_fields = as_fields.reject { |f| as_models.include?(f) }.sort
+
+        { as_fields: as_fields, as_models: as_models }
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/parser/column.rb

@@ -0,0 +1,86 @@
+module ForestAdminDatasourceMongoid
+  module Parser
+    module Column
+      include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+      TYPES = {
+        'Array' => 'Json',
+        'BSON::Binary' => 'Binary',
+        'BigDecimal' => 'Number',
+        'Mongoid::Boolean' => 'Boolean',
+        'Date' => 'Date',
+        'DateTime' => 'Date',
+        'Float' => 'Number',
+        'Hash' => 'Json',
+        'Integer' => 'Number',
+        'Object' => 'Json',
+        'BSON::ObjectId' => 'String',
+        'Range' => 'Json',
+        'Regexp' => 'String',
+        'Set' => 'Json',
+        'String' => 'String',
+        'Mongoid::StringifiedSymbol' => 'String',
+        'Symbol' => 'String',
+        'Time' => 'Date',
+        'ActiveSupport::TimeWithZone' => 'Date'
+      }.freeze
+
+      def get_column_type(column)
+        case column
+        when Mongoid::Fields::Standard
+          return TYPES[column.type.to_s] || 'String'
+        when Mongoid::Fields::ForeignKey
+          return 'String'
+        when Hash
+          return [get_column_type(column['[]'])] if column.key?('[]')
+
+          return column.reduce({}) do |memo, (name, sub_column)|
+            memo.merge({ name => get_column_type(sub_column) })
+          end
+        end
+
+        'String'
+      end
+
+      def get_default_value(column)
+        if column.respond_to?(:options) && column.options.key?(:default)
+          default = column.options[:default]
+
+          return default.respond_to?(:call) ? default.call : default
+        end
+
+        nil
+      end
+
+      def get_embedded_fields(model)
+        embedded_class = [Mongoid::Association::Embedded::EmbedsMany, Mongoid::Association::Embedded::EmbedsOne]
+        model.relations.select { |_name, association| embedded_class.include?(association.class) }
+      end
+
+      def operators_for_column_type(type)
+        default_operators = [Operators::PRESENT, Operators::EQUAL, Operators::NOT_EQUAL]
+        in_operators = [Operators::IN, Operators::NOT_IN]
+        string_operators = [Operators::MATCH, Operators::NOT_CONTAINS, Operators::NOT_I_CONTAINS]
+        comparison_operators = [Operators::GREATER_THAN, Operators::LESS_THAN]
+        result = []
+
+        if type.is_a? String
+          case type
+          when 'Boolean', 'Binary', 'Json'
+            result = default_operators
+          when 'Date', 'Dateonly', 'Number'
+            result = default_operators + in_operators + comparison_operators
+          when 'Enum'
+            result = default_operators + in_operators
+          when 'String'
+            result = default_operators + in_operators + string_operators
+          end
+        end
+
+        result = default_operators if type.is_a? Array
+
+        result
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/parser/relation.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceMongoid
+  module Parser
+    module Relation
+      def get_polymorphic_types(relation_name)
+        types = {}
+
+        ObjectSpace.each_object(Class).select { |klass| klass < Mongoid::Document }.each do |model|
+          if model.relations.any? { |_, relation| relation.options[:as] == relation_name.to_sym }
+            primary_key = model.fields.keys.find { |key| model.fields[key].options[:as] == :id } || :_id
+            types[model.name.gsub('::', '__')] = primary_key.to_s
+          end
+        end
+
+        types
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/parser/validation.rb

@@ -0,0 +1,87 @@
+module ForestAdminDatasourceMongoid
+  module Parser
+    module Validation
+      include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+      def get_validations(model, column)
+        return [] if column.is_a?(Hash)
+
+        validations = []
+        # NOTICE: Do not consider validations if a before_validation Active Records
+        #         Callback is detected.
+        default_callback_excluded = [:normalize_changed_in_place_attributes]
+        return validations if model._validation_callbacks
+                                   .reject { |callback| default_callback_excluded.include?(callback.filter) }
+                                   .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.class.to_s
+            when Mongoid::Validatable::PresenceValidator.to_s
+              validations << { operator: Operators::PRESENT }
+            when ActiveModel::Validations::NumericalityValidator.to_s
+              validations = parse_numericality_validator(validator, validations)
+            when Mongoid::Validatable::LengthValidator.to_s
+              validations = parse_length_validator(validator, validations, column)
+            when Mongoid::Validatable::FormatValidator.to_s
+              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 << { operator: Operators::GREATER_THAN, value: value }
+          when :less_than, :less_than_or_equal_to
+            parsed_validations << { operator: Operators::LESS_THAN, value: value }
+          end
+        end
+
+        parsed_validations
+      end
+
+      def parse_length_validator(validator, parsed_validations, column)
+        return unless get_column_type(column) == 'String'
+
+        validator.options.each do |option, value|
+          case option
+          when :minimum
+            parsed_validations << { operator: Operators::LONGER_THAN, value: value }
+          when :maximum
+            parsed_validations << { operator: Operators::SHORTER_THAN, value: value }
+          when :is
+            parsed_validations << { operator: Operators::LONGER_THAN, value: value }
+            parsed_validations << { operator: Operators::SHORTER_THAN, value: value }
+          end
+        end
+
+        parsed_validations
+      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 << { operator: Operators::CONTAINS, value: "/#{regex}/#{options}" }
+          end
+        end
+
+        parsed_validations
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/add_null_values.rb

@@ -0,0 +1,56 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module AddNullValues
+      # Filter out records that have been tagged as not existing
+      # If the key FOREST_RECORD_DOES_NOT_EXIST is present in the record, the record is removed
+      # If a nested object has a key with FOREST_RECORD_DOES_NOT_EXIST, the nested object is removed
+      def remove_not_exist_record(record)
+        return nil if record.nil? || record[Pipeline::ConditionGenerator::FOREST_RECORD_DOES_NOT_EXIST]
+
+        record.transform_values! do |value|
+          if value.is_a?(Hash) && value[Pipeline::ConditionGenerator::FOREST_RECORD_DOES_NOT_EXIST]
+            nil
+          else
+            value
+          end
+        end
+
+        record
+      end
+
+      def add_null_values_on_record(record, projection)
+        return nil if record.nil?
+
+        result = record.dup
+
+        projection.each do |field|
+          field_prefix = field.split(':').first
+          result[field_prefix] ||= nil
+        end
+
+        nested_prefixes = projection.select { |field| field.include?(':') }.map { |field| field.split(':').first }.uniq
+
+        nested_prefixes.each do |nested_prefix|
+          child_paths = projection.filter { |field| field.start_with?("#{nested_prefix}:") }
+                                  .map { |field| field[(nested_prefix.size + 1)..] }
+
+          next unless result[nested_prefix] && !result[nested_prefix].nil?
+
+          if result[nested_prefix].is_a?(Array)
+            result[nested_prefix] = result[nested_prefix].map do |child_record|
+              add_null_values_on_record(child_record, child_paths)
+            end
+          elsif result[nested_prefix].is_a?(Hash)
+            result[nested_prefix] = add_null_values_on_record(result[nested_prefix], child_paths)
+          end
+        end
+
+        remove_not_exist_record(result)
+      end
+
+      def add_null_values(records, projection)
+        records.filter_map { |record| add_null_values_on_record(record, projection) }
+      end
+    end
+  end
+end