forest_admin_datasource_mongoid 1.0.1

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

@@ -0,0 +1,97 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      # Generate pipeline to query submodels.
+      # The operations make rotations in the documents so that the root is changed to the submodel
+      # without loosing the parent (which may be needed later on).
+      class ReparentGenerator
+        include Utils::Schema
+
+        def self.reparent(model, stack)
+          schema = MongoidSchema.from_model(model)
+
+          stack.flat_map.with_index do |step, index|
+            # If this is the first step in the stack and there are no fields to flatten, return an empty list
+            next [] if index.zero? && step[:as_fields].empty?
+            # If this is the first step in the stack, only flatten the provided fields without reparenting
+            next unflatten(step[:as_fields]) if index.zero?
+
+            local_schema = schema.get_sub_schema(step[:prefix])
+            relative_prefix = if stack[index - 1][:prefix].nil?
+                                step[:prefix]
+                              else
+                                step[:prefix][(stack[index - 1][:prefix].length + 1)..]
+                              end
+
+            result = if local_schema.is_array
+                       reparent_array(relative_prefix, local_schema.is_leaf)
+                     else
+                       reparent_object(relative_prefix, local_schema.is_leaf)
+                     end
+
+            [*result, *unflatten(step[:as_fields])]
+          end
+        end
+
+        def self.reparent_array(prefix, in_doc)
+          [
+            { '$unwind' => { 'path' => "$#{prefix}", 'includeArrayIndex' => 'index' } },
+            {
+              '$replaceRoot' => {
+                'newRoot' => {
+                  '$mergeObjects' => [
+                    in_doc ? { 'content' => "$#{prefix}" } : "$#{prefix}",
+                    ConditionGenerator.tag_record_if_not_exist(
+                      prefix,
+                      {
+                        '_id' => { '$concat' => [{ '$toString' => '$_id' }, ".#{prefix}.",
+                                                 { '$toString' => '$index' }] },
+                        'parent_id' => '$_id',
+                        'parent' => '$$ROOT'
+                      }
+                    )
+                  ]
+                }
+              }
+            }
+          ]
+        end
+
+        def self.reparent_object(prefix, in_doc)
+          [
+            {
+              '$replaceRoot' => {
+                'newRoot' => {
+                  '$mergeObjects' => [
+                    in_doc ? { 'content' => "$#{prefix}" } : "$#{prefix}",
+                    ConditionGenerator.tag_record_if_not_exist(
+                      prefix,
+                      {
+                        '_id' => { '$concat' => [{ '$toString' => '$_id' }, ".#{prefix}"] },
+                        'parent_id' => '$_id',
+                        'parent' => '$$ROOT'
+                      }
+                    )
+                  ]
+                }
+              }
+            }
+          ]
+        end
+
+        def self.unflatten(as_fields)
+          return [] if as_fields.empty?
+
+          chunk_size = 30
+          add_fields = as_fields.map { |f| [f.gsub('.', '@@@'), "$#{f}"] }
+
+          # MongoDB (DocumentDB) enforces a limit of 30 fields per $addFields stage.
+          # We split the list into chunks of 30 to prevent errors.
+          unflatten_results = add_fields.each_slice(chunk_size).map { |chunk| { '$addFields' => chunk.to_h } }
+
+          unflatten_results << { '$project' => as_fields.to_h { |f| [f, 0] } }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Pipeline
+      # When using the `asModel` options, users can request/filter on the virtual _id and parentId fields
+      # of children (using the generated OneToOne relation).
+      #
+      # As those fields are not written to mongo, they are injected here so that they can be used like
+      # any other field.
+      #
+      # This could be also be done by preprocessing the filter, and postprocessing the records, but this
+      # solution seemed simpler, at the cost of additional pipeline stages when making queries.
+      #
+      # Note that a projection is taken as a parameter so that only fields which are actually used are
+      # injected to save resources.
+      class VirtualFieldGenerator
+        def self.add_virtual(_model, stack, projection)
+          set = {}
+
+          projection.each do |colon_field|
+            field = colon_field.tr(':', '.')
+            is_from_one_to_one = stack.last[:as_models].any? { |f| field.start_with?("#{f}.") }
+
+            set[field] = get_path(field) if is_from_one_to_one
+          end
+
+          set.keys.empty? ? [] : [{ '$addFields' => set }]
+        end
+
+        def self.get_path(field)
+          id_identifier = '._id'
+          if field.end_with?(id_identifier)
+            # ... dots to exclude the last character (ex: 'author.' => 'author')
+            suffix = field[0...(field.length - id_identifier.length)]
+
+            return ConditionGenerator.tag_record_if_not_exist_by_value(
+              suffix,
+              { '$concat' => [{ '$toString' => '$_id' }, (suffix.empty? ? '' : ".#{suffix}")] }
+            )
+          end
+
+          parent_id_identifier = '.parent_id'
+          if field.end_with?(parent_id_identifier)
+
+            if field.split('.').length > 2
+              # Implementing this would require us to have knowledge of the value of asModel for
+              # for virtual models under the current one, which the `stack` variable does not have.
+
+              # If the expcetion causes issues we could simply return
+              # `$${field.substring(0, field.length - 9)}._id` but that would not work if the customer
+              # jumped over multiple levels of nesting.
+
+              # As this is a use case that never happens from the UI, and that can be worked around when
+              # using the API, we decided to not implement it.
+              raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                    'Fetching virtual parent_id deeper than 1 level is not supported.'
+            end
+            suffix = field[0...(field.length - parent_id_identifier.length)]
+
+            return ConditionGenerator.tag_record_if_not_exist_by_value(suffix, '$_id')
+          end
+
+          content_identifier = '.content'
+          if field.end_with?(content_identifier)
+            # FIXME: we should check that this is really a leaf field because "content" can't
+            # really be used as a reserved word
+
+            return "$#{field[0...(field.length - content_identifier.length)]}"
+          end
+
+          parent = field[0..field.rindex('.')]
+          parent = parent.gsub(/\.+$/, '') # Remove trailing dots
+
+          ConditionGenerator.tag_record_if_not_exist_by_value(parent, "$#{field}")
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/schema/fields_generator.rb

@@ -0,0 +1,87 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Schema
+      class FieldsGenerator
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+        extend Utils::Helpers
+        extend Parser::Column
+        extend Parser::Validation
+
+        def self.build_fields_schema(model, stack)
+          our_schema = {}
+          child_schema = MongoidSchema.from_model(model).apply_stack(stack)
+
+          child_schema.fields.each do |name, field|
+            next unless name != 'parent'
+
+            default_value = if field.respond_to?(:object_id_field?) && field.object_id_field?
+                              nil
+                            else
+                              get_default_value(field)
+                            end
+
+            our_schema[name] = ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
+              column_type: get_column_type(field),
+              filter_operators: operators_for_column_type(get_column_type(field)),
+              is_primary_key: name == '_id',
+              is_read_only: false,
+              is_sortable: get_column_type(field) != 'Json',
+              default_value: default_value,
+              enum_values: [],
+              validations: get_validations(model, field)
+            )
+
+            if !field.is_a?(Hash) && field.foreign_key? && field.type != Array && !field.association.polymorphic?
+              our_schema["#{name}__many_to_one"] = build_many_to_one(field)
+            end
+          end
+
+          return our_schema unless stack.length > 1
+
+          parent_prefix = stack[stack.length - 2][:prefix]
+
+          our_schema['_id'] = build_virtual_primary_key
+          parent_id = child_schema.fields['parent']['_id']
+          our_schema['parent_id'] = ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
+            column_type: get_column_type(parent_id),
+            filter_operators: operators_for_column_type(get_column_type(parent_id)),
+            is_primary_key: false,
+            is_read_only: false,
+            is_sortable: get_column_type(parent_id) != 'Json',
+            default_value: parent_id.object_id_field? ? nil : get_default_value(parent_id),
+            enum_values: [],
+            validations: [{ operator: 'Present' }]
+          )
+
+          model_name = model.name.gsub('::', '__')
+          our_schema['parent'] = ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema.new(
+            foreign_collection: escape(parent_prefix.nil? ? model_name : "#{model_name}.#{parent_prefix}"),
+            foreign_key: 'parent_id',
+            foreign_key_target: '_id'
+          )
+
+          our_schema
+        end
+
+        def self.build_virtual_primary_key
+          ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
+            column_type: 'String',
+            filter_operators: operators_for_column_type('String'),
+            is_primary_key: true,
+            is_read_only: true,
+            is_sortable: true
+          )
+        end
+
+        def self.build_many_to_one(field)
+          association = field.options[:association]
+          ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema.new(
+            foreign_collection: association.klass.name.gsub('::', '__'),
+            foreign_key: association.foreign_key,
+            foreign_key_target: '_id'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/schema/mongoid_schema.rb

@@ -0,0 +1,196 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Schema
+      class MongoidSchema
+        include ForestAdminDatasourceToolkit::Exceptions
+        include Utils::Helpers
+        attr_reader :is_array, :is_leaf, :fields, :models
+
+        def initialize(model, fields, is_array, is_leaf)
+          @models = ObjectSpace.each_object(Class)
+                               .select { |klass| klass < Mongoid::Document && klass.name && !klass.name.start_with?('Mongoid::') }
+                               .to_h { |klass| [klass.name, klass] }
+          @model = model
+          @fields = fields
+          @is_array = is_array
+          @is_leaf = is_leaf
+        end
+
+        def schema_node
+          @is_leaf ? @fields[:content] : @fields
+        end
+
+        def schema_type
+          raise ForestException, 'Schema is not a leaf.' unless @is_leaf
+
+          @fields[:content]
+        end
+
+        def self.from_model(model)
+          fields = fields_and_embedded_relations(model)
+
+          new(model, build_fields(fields), false, false)
+        end
+
+        def self.fields_and_embedded_relations(model)
+          embedded_class = [Mongoid::Association::Embedded::EmbedsMany, Mongoid::Association::Embedded::EmbedsOne]
+          relations = model.relations.select { |_name, association| embedded_class.include?(association.class) }
+
+          model.fields.merge(relations)
+        end
+
+        def self.build_fields(schema_fields, level = 0)
+          targets = {}
+
+          schema_fields.each do |name, field|
+            next if name.start_with?('$') || name.include?('__') || (name == '_id' && level.positive?)
+
+            if VersionManager.sub_document?(field)
+              sub_targets = build_fields(fields_and_embedded_relations(field.klass), level + 1)
+              sub_targets.each { |sub_name, sub_field| recursive_set(targets, "#{name}.#{sub_name}", sub_field) }
+            elsif VersionManager.sub_document_array?(field)
+              sub_targets = build_fields(fields_and_embedded_relations(field.klass), level + 1)
+              sub_targets.each { |sub_name, sub_field| recursive_set(targets, "#{name}.[].#{sub_name}", sub_field) }
+            else
+              recursive_set(targets, name, field)
+            end
+          end
+
+          targets
+        end
+
+        def self.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 list_paths_matching(handle, prefix = nil)
+          return [] if @is_leaf
+
+          @fields.keys
+                 .filter(&:present?)
+                 .flat_map do |field|
+            schema = get_sub_schema(field)
+            sub_prefix = prefix ? "#{prefix}.#{field}" : field
+            sub_fields = schema.list_paths_matching(handle, sub_prefix)
+            sub_fields.map { |sub_field| "#{field}.#{sub_field}" }
+            # debugger
+            handle.call(sub_prefix, schema) ? [sub_prefix, *sub_fields] : sub_fields
+          end
+        end
+
+        def get_sub_schema(path)
+          # Terminating condition
+          return self if path.blank?
+
+          # General case: go down the tree
+          prefix, suffix = path.split(/\.(.*)/)
+          is_leaf = false
+          child = @fields[prefix]
+          is_array = child.is_a?(Mongoid::Fields::Standard) && child.options[:type] == Array
+
+          # Traverse relations
+          if child.is_a?(Hash)
+            relation_name = @model.relations[prefix].class_name
+
+            raise ForestException, "Collection '#{relation_name}' not found." unless @models.key?(relation_name)
+
+            # Traverse arrays
+            if child.is_a?(Hash) && child['[]']
+              # (has_many embed)
+              child = child['[]']
+              is_array = true
+            else
+              # (has_one embed)
+              child = MongoidSchema.from_model(@models[relation_name]).fields
+            end
+
+            return MongoidSchema.new(@models[relation_name], child, is_array, is_leaf).get_sub_schema(suffix)
+          elsif child.nil?
+            raise ForestException, "Field '#{prefix}' not found. Available fields are: #{list_fields}"
+          end
+
+          # We ended up on a field => box it.
+          if child.is_a? Mongoid::Fields::Standard
+            child = { content: child }
+            is_leaf = true
+          end
+
+          MongoidSchema.new(@model, child, is_array, is_leaf).get_sub_schema(suffix)
+        end
+
+        def apply_stack(stack, skip_as_models: false)
+          raise ForestException, 'Stack can never be empty.' if stack.empty?
+
+          step = stack.pop
+          sub_schema = get_sub_schema(step[:prefix])
+
+          step[:as_fields].each do |field|
+            field_schema = sub_schema.get_sub_schema(field)
+            recursive_delete(sub_schema.fields, field)
+
+            sub_schema.fields[field.gsub('.', '@@@')] = if field_schema.is_array
+                                                          { '[]' => field_schema.schema_node }
+                                                        else
+                                                          field_schema.schema_node
+                                                        end
+          end
+
+          unless stack.empty?
+            sub_schema.fields['_id'] = Mongoid::Fields::Standard.new('__placeholder__', { type: String })
+            sub_schema.fields['parent'] = apply_stack(stack).fields
+            sub_schema.fields['parent_id'] = sub_schema.fields['parent']['_id']
+          end
+
+          if skip_as_models
+            # Here we actually should recurse into the subSchema and add the _id and parentId fields
+            # to the virtual one-to-one relations.
+            #
+            # The issue is that we can't do that because we don't know where the relations are after
+            # the first level of nesting (we would need to have the complete asModel / asFields like in
+            # the datasource.ts file).
+            #
+            # Because of that, we need to work around the missing fields in:
+            # - pipeline/virtual-fields.ts file: we're throwing an error when we can't guess the value
+            #   of a given _id / parentId field.
+            # - pipeline/filter.ts: we're using an educated guess for the types of the _id / parentId
+            #   fields (String or ObjectId)
+          else
+            step[:as_models].each do |field|
+              recursive_delete(@fields, field)
+            end
+          end
+
+          stack << step
+
+          sub_schema
+        end
+
+        # List leafs and arrays up to a certain level
+        # Arrays are never traversed
+        def list_fields(level = Float::INFINITY)
+          raise ForestException, 'Cannot list fields on a leaf schema.' if @is_leaf
+          raise ForestException, 'Level must be greater than 0.' if level.zero?
+
+          return @fields.keys if level == 1
+
+          @fields.keys.flat_map do |field|
+            schema = get_sub_schema(field)
+            if schema.is_leaf || schema.is_array
+              [field]
+            else
+              schema.list_fields(level - 1).map { |sub_field| "#{field}.#{sub_field}" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/schema/relation_generator.rb

@@ -0,0 +1,51 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    module Schema
+      class RelationGenerator
+        include ForestAdminDatasourceToolkit::Schema::Relations
+        extend ForestAdminDatasourceMongoid::Utils::Helpers
+
+        def self.add_implicit_relations(collections)
+          collections.each_value do |collection|
+            many_to_ones = collection.schema[:fields].select { |_, f| f.type == 'ManyToOne' }
+
+            many_to_ones.each do |(name, field)|
+              add_many_to_one_inverse(collection, name, field)
+            end
+          end
+        end
+
+        # Given any many to one relation, generated while parsing mongoose schema, generate the
+        # inverse relationship on the foreignCollection.
+        # /!\ The inverse can be a OneToOne, or a ManyToOne
+        def self.add_many_to_one_inverse(collection, name, schema)
+          if name == 'parent'
+            # Create inverse of 'parent' relationship so that the relation name matches the actual name
+            # of the data which is stored in the database.
+            stack = collection.stack
+            prefix = stack[stack.length - 1][:prefix]
+            is_array = MongoidSchema.from_model(collection.model).apply_stack(stack).is_array
+
+            type = is_array ? OneToManySchema : OneToOneSchema
+            inverse_name = escape(prefix)
+
+            if stack.length > 2
+              previous_length = stack[stack.length - 2][:prefix].length + 1
+              inverse_name = prefix[previous_length..]
+            end
+          else
+            inverse_name = escape("#{collection.name}_#{name}__inverse")
+            type = OneToManySchema
+          end
+
+          other_collection = collection.datasource.get_collection(schema.foreign_collection)
+          other_collection.schema[:fields][inverse_name] = type.new(
+            foreign_collection: collection.name,
+            origin_key: schema.foreign_key,
+            origin_key_target: schema.foreign_key_target
+          )
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/utils/version_manager.rb

@@ -0,0 +1,13 @@
+module ForestAdminDatasourceMongoid
+  module Utils
+    class VersionManager
+      def self.sub_document?(field)
+        field.is_a?(Mongoid::Association::Embedded::EmbedsOne)
+      end
+
+      def self.sub_document_array?(field)
+        field.is_a?(Mongoid::Association::Embedded::EmbedsMany)
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_mongoid/version.rb

@@ -0,0 +1,3 @@
+module ForestAdminDatasourceMongoid
+  VERSION = "1.0.1"
+end

data/lib/forest_admin_datasource_mongoid.rb

@@ -0,0 +1,11 @@
+require_relative 'forest_admin_datasource_mongoid/version'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/models")
+loader.setup
+
+module ForestAdminDatasourceMongoid
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: forest_admin_datasource_mongoid
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Matthieu
+- Nicolas
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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"
+- LICENSE
+- Rakefile
+- forest_admin_datasource_mongoid.gemspec
+- lib/forest_admin_datasource_mongoid.rb
+- lib/forest_admin_datasource_mongoid/collection.rb
+- lib/forest_admin_datasource_mongoid/datasource.rb
+- lib/forest_admin_datasource_mongoid/options_parser.rb
+- lib/forest_admin_datasource_mongoid/parser/column.rb
+- lib/forest_admin_datasource_mongoid/parser/relation.rb
+- lib/forest_admin_datasource_mongoid/parser/validation.rb
+- lib/forest_admin_datasource_mongoid/utils/add_null_values.rb
+- lib/forest_admin_datasource_mongoid/utils/helpers.rb
+- lib/forest_admin_datasource_mongoid/utils/mongoid_serializer.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/condition_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/filter_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/group_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/lookup_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/projection_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/reparent_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/pipeline/virtual_field_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/schema/fields_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/schema/mongoid_schema.rb
+- lib/forest_admin_datasource_mongoid/utils/schema/relation_generator.rb
+- lib/forest_admin_datasource_mongoid/utils/version_manager.rb
+- lib/forest_admin_datasource_mongoid/version.rb
+homepage: https://www.forestadmin.com
+licenses:
+- GPL-3.0
+metadata:
+  homepage_uri: https://www.forestadmin.com
+  source_code_uri: https://github.com/ForestAdmin/agent-ruby
+  changelog_uri: https://github.com/ForestAdmin/agent-ruby/blob/main/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: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Ruby agent for Forest Admin.
+test_files: []