forest_admin_datasource_mongoid 1.0.1

data/lib/forest_admin_datasource_mongoid/utils/helpers.rb

@@ -0,0 +1,151 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Helpers
+      # Similar to projection.unnest
+      # @example
+      # unnest(['firstname', 'book.title', 'book.author'], 'book') == ['title', 'author']
+      def unnest(strings, prefix)
+        strings.select { |field| field.start_with?("#{prefix}.") }.map { |field| field[(prefix.size + 1)..] }
+      end
+
+      def escape(str)
+        str.tr('.', '_')
+      end
+
+      def recursive_set(target, path, value)
+        index = path.index('.')
+        if index.nil?
+          target[path] = value
+        else
+          prefix = path[0, index]
+          suffix = path[index + 1, path.length]
+          target[prefix] ||= {}
+          recursive_set(target[prefix], suffix, value)
+        end
+      end
+
+      def recursive_delete(target, path)
+        index = path.index('.')
+
+        if index.nil?
+          target.delete(path)
+        else
+          prefix = path[0..(index - 1)]
+          suffix = path[(index + 1)..]
+
+          if target.is_a?(Hash) && target.key?(prefix)
+            recursive_delete(target[prefix], suffix)
+            target.delete(prefix) if target[prefix].empty?
+          end
+        end
+      end
+
+      # not sure it this method is relevant for mongoid
+      def replace_mongo_types(data)
+        case data
+        when BSON::ObjectId, BSON::Decimal128
+          data.to_s
+        when Date, Time
+          data.iso8601
+        when Array
+          data.map { |item| replace_mongo_types(item) }
+        when Hash
+          data.transform_values { |value| replace_mongo_types(value) }
+        else
+          data
+        end
+      end
+
+      # Unflattend patches and records
+      def unflatten_record(record, as_fields, patch_mode: false)
+        new_record = record.dup
+
+        as_fields.each do |field|
+          alias_field = field.gsub('.', '@@@')
+
+          value = new_record[alias_field]
+
+          next if value.nil?
+
+          if patch_mode
+            new_record[field] = value
+          else
+            recursive_set(new_record, field, value)
+          end
+
+          new_record.delete(alias_field)
+        end
+
+        new_record
+      end
+
+      def reformat_patch(patch)
+        patch.each_with_object({}) do |(key, value), result|
+          keys = key.split('.')
+          last_key = keys.pop
+          nested_hash = keys.reverse.inject({ last_key => value }) do |hash, k|
+            { k => hash }
+          end
+          deep_merge(result, nested_hash)
+        end
+      end
+
+      def deep_merge(target, source)
+        source.each do |key, value|
+          if target[key].is_a?(Hash) && value.is_a?(Hash)
+            deep_merge(target[key], value)
+          else
+            target[key] ||= value
+          end
+        end
+        target
+      end
+
+      # Compare two ids.
+      # This is useful to ensure we perform array operations in the right order.
+      #
+      # @example
+      # compareIds('a.20.a', 'a.1.b') => 1 (because 1 < 20)
+      # compareIds('a.0.a', 'b.1.b') => -1 (because 'a' < 'b')
+      def compare_ids(id_a, id_b)
+        parts_a = id_a.split('.')
+        parts_b = id_b.split('.')
+        length = [parts_a.length, parts_b.length].min
+
+        (0...length).each do |i|
+          # if both parts are numbers, we compare them numerically
+          result = if parts_a[i] =~ /^\d+$/ && parts_b[i] =~ /^\d+$/
+                     parts_a[i].to_i <=> parts_b[i].to_i
+                   else
+                     # else, we compare as strings
+                     parts_a[i] <=> parts_b[i]
+                   end
+          return result unless result.zero?
+        end
+
+        parts_a.length <=> parts_b.length
+      end
+
+      def split_id(id)
+        dot_index = id.index('.')
+        root_id = id[0...dot_index]
+        path = id[(dot_index + 1)..]
+
+        root_id = BSON::ObjectId.from_string(root_id) if BSON::ObjectId.legal?(root_id)
+
+        [root_id, path]
+      end
+
+      def group_ids_by_path(ids)
+        updates = Hash.new { |hash, key| hash[key] = [] }
+
+        ids.each do |id|
+          root_id, path = split_id(id)
+          updates[path] << root_id
+        end
+
+        updates
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/mongoid_serializer.rb

@@ -0,0 +1,38 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    MongoidSerializer = Struct.new(:object) do
+      def to_hash(projection)
+        hash_object(object, projection)
+      end
+
+      def hash_object(object, projection, with_associations: true)
+        hash = {}
+
+        return if object.nil?
+
+        object.attributes.slice(*projection.columns).each do |key, value|
+          hash[key] = value
+        end
+
+        if with_associations
+          each_association_collection(object, projection) do |association_name, item|
+            hash[association_name] = hash_object(
+              item,
+              projection.relations[association_name],
+              with_associations: projection.relations.key?(association_name)
+            )
+          end
+        end
+
+        hash
+      end
+
+      def each_association_collection(object, projection)
+        one_associations = [Mongoid::Association::Referenced::HasOne, Mongoid::Association::Referenced::BelongsTo]
+        object.class.reflect_on_all_associations
+              .filter { |a| one_associations.include?(a.class) && projection.relations.key?(a.name.to_s) }
+              .each { |association| yield(association.name.to_s, object.send(association.name.to_s)) }
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/pipeline/condition_generator.rb

@@ -0,0 +1,30 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      class ConditionGenerator
+        include Utils::Schema
+
+        FOREST_RECORD_DOES_NOT_EXIST = 'FOREST_RECORD_DOES_NOT_EXIST'.freeze
+
+        def self.tag_record_if_not_exist(field, then_expr)
+          if_missing(field, then_expr, { FOREST_RECORD_DOES_NOT_EXIST => true })
+        end
+
+        def self.tag_record_if_not_exist_by_value(field, then_expr)
+          if_missing(field, then_expr, FOREST_RECORD_DOES_NOT_EXIST)
+        end
+
+        def self.if_missing(field, then_expr, else_expr)
+          {
+            '$cond' => {
+              'if' => { '$and' => [{ '$ne' => [{ '$type' => "$#{field}" }, 'missing'] },
+                                   { '$ne' => ["$#{field}", nil] }] },
+              'then' => then_expr,
+              'else' => else_expr
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/pipeline/filter_generator.rb

@@ -0,0 +1,218 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      class FilterGenerator
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        STRING_OPERATORS = [Operators::MATCH, Operators::NOT_CONTAINS, Operators::NOT_I_CONTAINS].freeze
+
+        def self.sort_and_paginate(model, filter)
+          sort = compute_sort(filter.sort)
+
+          sort_and_limit = []
+
+          sort_and_limit << { '$sort' => sort } if sort
+
+          if filter.page
+            sort_and_limit << { '$skip' => filter.page.offset }
+            sort_and_limit << { '$limit' => filter.page.limit }
+          end
+
+          return [sort_and_limit, [], []] unless sort
+
+          all_sort_criteria_native = sort.keys.none? do |key|
+            !model.fields.key?(key)
+          end
+
+          # if sort applies to native fields and no filters are applied (very common case)
+          # we apply pre-sort + limit at the beginning of the pipeline (to improve perf)
+          return [sort_and_limit, [], []] if all_sort_criteria_native && filter.condition_tree.nil?
+
+          all_condition_tree_keys_native = filter.condition_tree&.projection&.none? do |key|
+            !model.fields.key?(key)
+          end
+
+          # if filters apply to native fields only, we can apply the sort right after filtering
+          return [[], sort_and_limit, []] if all_sort_criteria_native && all_condition_tree_keys_native
+
+          # if sorting apply to relations, it is safer to do it at the end of the pipeline
+          [[], [], sort_and_limit]
+        end
+
+        def self.filter(model, stack, filter)
+          fields = []
+          tree = filter.condition_tree
+          match = compute_match(model, stack, tree, fields)
+
+          pipeline = []
+          pipeline << compute_fields(fields) unless fields.empty?
+          pipeline << { '$match' => match } if match
+
+          pipeline
+        end
+
+        def self.list_relations_used_in_filter(filter)
+          fields = Set.new
+
+          filter.sort&.each do |clause|
+            next unless clause[:field].include?(':') # only relations (fields containing ':')
+
+            list_paths(clause[:field]).each do |field|
+              parts = field.split('.') # Split into nested levels ("author.country.name"→ ["author", "country", "name"])
+
+              (1...parts.length).each do |i|
+                parent_field = parts[0...i].join('.')
+                fields.add(parent_field)
+              end
+            end
+          end
+
+          list_fields_used_in_filter_tree(filter.condition_tree, fields)
+
+          fields.to_a
+        end
+
+        def self.list_fields_used_in_filter_tree(condition_tree, fields)
+          if condition_tree.is_a? Nodes::ConditionTreeBranch
+            condition_tree.conditions.each { |condition| list_fields_used_in_filter_tree(condition, fields) }
+          elsif condition_tree&.field&.include?(':')
+            list_paths(condition_tree.field).each { |field| fields << field }
+          end
+        end
+
+        def self.list_paths(field)
+          parts = field.split(':')
+
+          parts.slice(0..)&.map&.with_index { |_, index| parts.slice(0, index + 1).join('.') }
+        end
+
+        def self.compute_sort(sort)
+          return if sort.nil? || sort.empty?
+
+          result = {}
+
+          sort.each do |clause|
+            formatted_field = format_nested_field_path(clause[:field])
+            result[formatted_field] = clause[:ascending] ? 1 : -1
+          end
+
+          result
+        end
+
+        def self.format_nested_field_path(field)
+          field.tr(':', '.')
+        end
+
+        def self.compute_match(model, stack, tree, fields)
+          schema = Utils::Schema::MongoidSchema.from_model(model).apply_stack(stack, skip_as_models: true)
+
+          if tree.is_a? Nodes::ConditionTreeBranch
+            # to check
+            return {
+              "$#{tree.aggregator.downcase}" => tree.conditions.map do |condition|
+                compute_match(model, stack, condition, fields)
+              end
+            }
+          end
+
+          if tree.is_a? Nodes::ConditionTreeLeaf
+            value = format_and_cast_leaf_value(schema, tree, fields)
+            condition = build_match_condition(tree.operator, value)
+
+            return { format_nested_field_path(tree.field) => condition }
+          end
+
+          nil
+        end
+
+        def self.format_and_cast_leaf_value(schema, leaf, fields)
+          value = leaf.value
+          leaf = leaf.override(field: format_nested_field_path(leaf.field))
+          is_array, instance = get_field_metadata(schema, leaf.field)
+
+          if is_array
+            if instance == Date && value.is_a?(Array) && value.all? { |v| valid_iso_date?(v) }
+              value = value.map { |v| Date.parse(v) }
+            elsif instance == BSON::ObjectId && value.is_a?(Array) && value.all? { |v| BSON::ObjectId.legal?(v) }
+              value = value.map { |id| BSON::ObjectId.from_string(id) }
+            end
+          elsif instance == BSON::ObjectId
+            if STRING_OPERATORS.include?(leaf.operator)
+              fields << leaf.field
+              leaf.override(field: format_string_field_name(leaf.field))
+            elsif value.is_a?(Array) && value.all? { |v| BSON::ObjectId.legal?(v) }
+              value = value.map { |id| BSON::ObjectId.from_string(id) }
+            elsif BSON::ObjectId.legal?(value)
+              value = BSON::ObjectId.from_string(value)
+            end
+          elsif instance == Date && valid_iso_date?(value)
+            value = Date.parse(value)
+          end
+
+          value
+        end
+
+        def self.build_match_condition(operator, value)
+          case operator
+          when Operators::GREATER_THAN
+            { '$gt' => value }
+          when Operators::LESS_THAN
+            { '$lt' => value }
+          when Operators::EQUAL
+            { '$eq' => value }
+          when Operators::NOT_EQUAL
+            { '$ne' => value }
+          when Operators::IN
+            { '$in' => value }
+          when Operators::INCLUDES_ALL
+            { '$all' => value }
+          when Operators::NOT_CONTAINS
+            { '$not' => Regexp.new("^.*#{value}.*$") }
+          when Operators::NOT_I_CONTAINS
+            { '$not' => Regexp.new("^.*#{value}.*$", 'i') }
+          when Operators::MATCH
+            { '$regex' => value }
+          when Operators::PRESENT
+            { '$exists' => true, '$ne' => null }
+          else
+            raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "Unsupported '#{operator}' operator"
+          end
+        end
+
+        def self.compute_fields(fields)
+          fields.reduce({ '$addFields' => {} }) do |computed, field|
+            string_field = format_string_field_name(field)
+            computed['$addField'][string_field] = { '$toString' => "$#{field}" }
+          end
+        end
+
+        def self.format_string_field_name(field)
+          parts = field.split('.')
+          parts << "string_#{parts.pop}"
+
+          parts.join('.')
+        end
+
+        def self.get_field_metadata(schema, field)
+          begin
+            sub_schema = schema.get_sub_schema(field)
+            is_array = sub_schema.is_array
+            instance = sub_schema.schema_type.type
+          rescue StandardError
+            is_array = false
+            instance = 'String'
+          end
+
+          [is_array, instance]
+        end
+
+        def self.valid_iso_date?(value)
+          DateTime.iso8601(value)
+          true
+        rescue ArgumentError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/pipeline/group_generator.rb

@@ -0,0 +1,86 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      class GroupGenerator
+        AGGREGATION_OPERATION = {
+          'Sum' => '$sum',
+          'Avg' => '$avg',
+          'Count' => '$sum',
+          'Max' => '$max',
+          'Min' => '$min'
+        }.freeze
+
+        GROUP_OPERATION = {
+          'Year' => '%Y-01-01',
+          'Month' => '%Y-%m-01',
+          'Day' => '%Y-%m-%d',
+          'Week' => '%Y-%m-%d'
+        }.freeze
+
+        def self.group(aggregation)
+          [
+            {
+              '$group' => {
+                _id: compute_groups(aggregation.groups),
+                value: compute_value(aggregation)
+              }
+            },
+            {
+              '$project' => {
+                '_id' => 0,
+                'value' => '$value',
+                'group' => compute_groups_projection(aggregation.groups)
+              }
+            }
+          ]
+        end
+
+        class << self
+          private
+
+          def compute_value(aggregation)
+            # Handle count(*) case
+            return { '$sum' => 1 } if aggregation.field.nil?
+
+            # General case
+            field = "$#{aggregation.field.tr(":", ".")}"
+
+            if aggregation.operation == 'Count'
+              { '$sum' => { '$cond' => [{ '$ne' => [field, nil] }, 1, 0] } }
+            else
+              { AGGREGATION_OPERATION[aggregation.operation] => field }
+            end
+          end
+
+          def compute_groups(groups)
+            return nil if groups.nil? || groups.empty?
+
+            groups.reduce({}) do |memo, group|
+              field = "$#{group[:field].tr(":", ".")}"
+
+              if group[:operation]
+                if group[:operation] == 'Week'
+                  date = { '$dateTrunc' => { 'date' => field, 'startOfWeek' => 'Monday', 'unit' => 'week' } }
+                  field = { '$dateToString' => { 'format' => GROUP_OPERATION[group[:operation]], 'date' => date } }
+                else
+                  field = { '$dateToString' => { 'format' => GROUP_OPERATION[group[:operation]], 'date' => field } }
+                end
+              end
+
+              memo.merge(group[:field] => field)
+            end
+          end
+
+          # Move fields in _id to the root of the document
+          def compute_groups_projection(groups)
+            return { '$literal' => {} } if groups.nil? || groups.empty?
+
+            groups.each_with_object({}) do |group, memo|
+              memo[group[:field]] = "$_id.#{group[:field]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/pipeline/lookup_generator.rb

@@ -0,0 +1,97 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      class LookupGenerator
+        include Utils::Schema
+
+        # Transform a forest admin projection into a mongo pipeline that performs the lookups
+        # and transformations to target them
+        def self.lookup(model, stack, projection, options)
+          schema_stack = stack.each_with_index.reduce([MongoidSchema.from_model(model)]) do |acc, (_, index)|
+            [
+              *acc,
+              MongoidSchema.from_model(model).apply_stack(stack.slice(0..(index + 1)), skip_as_models: true)
+            ]
+          end
+
+          lookup_projection(nil, schema_stack.map(&:fields), projection, options)
+        end
+
+        def self.lookup_projection(current_path, schema_stack, projection, options)
+          pipeline = []
+          fields = {}
+          projection.relations.each do |name, relation_projection|
+            pipeline.push(*lookup_relation(current_path, schema_stack, name, relation_projection, options))
+            # pipeline = [*pipeline, *lookup_relation(current_path, schema_stack, name, relation_projection, options)]
+            fields.merge!(add_fields(name, relation_projection, options))
+          end
+
+          pipeline.push({ '$addFields' => fields }) unless fields.empty?
+
+          pipeline
+        end
+
+        def self.add_fields(name, projection, options)
+          return {} if options[:include] && !options[:include].include?(name)
+          return {} if options[:exclude]&.include?(name)
+
+          projection.filter { |field| field.include?('@@@') }
+                    .map { |field_name| "#{name}.#{field_name.tr(":", ".")}" }
+                    .each_with_object({}) do |curr, acc|
+                      acc[curr] = "$#{curr.gsub("@@@", ".")}"
+                    end
+        end
+
+        def self.lookup_relation(current_path, schema_stack, name, projection, options)
+          models = ObjectSpace
+                   .each_object(Class)
+                   .select { |klass| klass < Mongoid::Document && klass.name && !klass.name.start_with?('Mongoid::') }
+                   .to_h { |klass| [klass.name, klass] }
+
+          as = current_path ? "#{current_path}.#{name}" : name
+
+          last_schema = schema_stack[schema_stack.length - 1]
+          previous_schema = schema_stack.slice(0..(schema_stack.length - 1))
+
+          return {} if options[:include] && !options[:include].include?(as)
+          return {} if options[:exclude]&.include?(as)
+
+          # Native many to one relation
+          identifier = '__many_to_one'
+          if name.end_with?(identifier)
+            foreign_key_name = name[0..(name.length - identifier.length - 1)]
+            model = models[last_schema[foreign_key_name].options[:association].class_name]
+
+            from = model.name.gsub('::', '__')
+            local_field = current_path ? "#{current_path}.#{foreign_key_name}" : foreign_key_name
+            foreign_field = '_id'
+            sub_schema = MongoidSchema.from_model(model).fields
+
+            return [
+              # Push lookup to pipeline
+              {
+                '$lookup' => { 'from' => from, 'localField' => local_field, 'foreignField' => foreign_field,
+                               'as' => as }
+              },
+              { '$unwind' => { 'path' => "$#{as}", 'preserveNullAndEmptyArrays' => true } },
+
+              # Recurse to get relations of relations
+              *lookup_projection(as, [*schema_stack, sub_schema], projection, options)
+            ]
+          end
+
+          # inverse of fake relation
+          if name == 'parent' && !previous_schema.empty?
+            return lookup_projection(as, previous_schema, projection, options)
+          end
+
+          # fake relation
+          return lookup_projection(as, [*schema_stack, last_schema[name]], projection, options) if last_schema[name]
+
+          # We should have handled all possible cases.
+          raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "Unexpected relation: '#{name}'"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/pipeline/projection_generator.rb

@@ -0,0 +1,20 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      class ProjectionGenerator
+        def self.project(projection)
+          return [{ '$replaceRoot' => { 'newRoot' => { '$literal' => {} } } }] if projection.empty?
+
+          project = { '_id' => false, 'FOREST_RECORD_DOES_NOT_EXIST' => true }
+
+          projection.each do |field|
+            formatted_field = field.tr(':', '.')
+            project[formatted_field] = true
+          end
+
+          [{ '$project' => project }]
+        end
+      end
+    end
+  end
+end