forest_admin_agent 1.0.0.pre.beta.60 → 1.0.0.pre.beta.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d139f75a88e0da6b4900f761ed7f8cb6ff127da70e16c6b046ff8e689bdf362
-  data.tar.gz: 00fd69796e962e847b7cb4ef01941b723ceeb66b23415aed9eee2fa2cab54a92
+  metadata.gz: 8094394fa87dd1d0c83fac337a16804b9aefa3592bf3398b4ae859a45de031af
+  data.tar.gz: 38438b2a1f495a1b448796e742189103a8180bb8322735ae5b88708557da505b
 SHA512:
-  metadata.gz: 8ad28b9ead8aca8e508bd6f3c59b9dd625d78f04fc02e58f574f065870137ca364e8b2efc99b75187001a105ed061a1197cf22f2a48b83cfeef5ae2879b76878
-  data.tar.gz: 47d0f533c7b88121faa68aa7512b9439d424ed9234fddbbed4f02745b9a4071cce62962d9833fe87f871a1da5a38856be748e017c3cc5d74ef4a44bfd84d8514
+  metadata.gz: ce0cf6bfd2a8da01400c0f12ee772e2274327613c3dcb4c89806415b1f13602b3c8e5fa397ad7f75dcbc511657ab3ebb7bb1f3e1555ba9dc2dcfb3f1186a2822
+  data.tar.gz: 2b1d5f879c66af69ccd73aa160261fd4c293a39cfdee463e536dc7efd8e367f4eca979e7231a517d7895607425b9f0580b2f835a1d3b2001caeb34b8c4eb6351

data/lib/forest_admin_agent/routes/abstract_authenticated_route.rb

@@ -19,7 +19,7 @@ module ForestAdminAgent
           record[schema.foreign_key] = value['data'][schema.foreign_key_target] if schema.type == 'ManyToOne'
         end
 
-        record
+        record || {}
       end
     end
   end

data/lib/forest_admin_agent/routes/abstract_related_route.rb

@@ -5,7 +5,11 @@ module ForestAdminAgent
         super
 
         relation = @collection.schema[:fields][args[:params]['relation_name']]
-        @child_collection = @datasource.get_collection(relation.foreign_collection)
+        @child_collection = if relation.type == 'PolymorphicManyToOne'
+                              @datasource.get_collection(args[:params]['data']['type'])
+                            else
+                              @datasource.get_collection(relation.foreign_collection)
+                            end
       end
     end
   end

data/lib/forest_admin_agent/routes/resources/delete.rb

@@ -37,6 +37,25 @@ module ForestAdminAgent
         def delete_records(args, selection_ids)
           condition_tree_ids = ConditionTree::ConditionTreeFactory.match_records(@collection, selection_ids[:ids])
           condition_tree_ids = condition_tree_ids.inverse if selection_ids[:are_excluded]
+
+          @collection.schema[:fields].each_value do |field_schema|
+            next unless field_schema.type == 'PolymorphicOneToOne' || field_schema.type == 'PolymorphicOneToMany'
+
+            condition_tree = Nodes::ConditionTreeBranch.new(
+              'And',
+              [
+                Nodes::ConditionTreeLeaf.new(field_schema.origin_key, Operators::IN,
+                                             selection_ids[:ids].map { |value| value['id'] }),
+                Nodes::ConditionTreeLeaf.new(field_schema.origin_type_field, Operators::EQUAL,
+                                             @collection.name.gsub('__', '::'))
+              ]
+            )
+            filter = Filter.new(condition_tree: condition_tree)
+            @datasource.get_collection(field_schema.foreign_collection)
+                       .update(@caller, filter, { field_schema.origin_key => nil,
+                                                  field_schema.origin_type_field => nil })
+          end
+
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
             condition_tree: ConditionTree::ConditionTreeFactory.intersect(
               [

data/lib/forest_admin_agent/routes/resources/list.rb

@@ -38,7 +38,7 @@ module ForestAdminAgent
               class_name: @collection.name,
               is_collection: true,
               serializer: Serializer::ForestSerializer,
-              include: projection.relations.keys,
+              include: projection.relations(only_keys: true),
               meta: handle_search_decorator(args[:params]['search'], records)
             )
           }

data/lib/forest_admin_agent/routes/resources/related/associate_related.rb

@@ -28,10 +28,13 @@ module ForestAdminAgent
             target_relation_id = Utils::Id.unpack_id(@child_collection, args[:params]['data'][0]['id'], with_key: true)
             relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
 
-            if relation.type == 'OneToMany'
+            case relation.type
+            when 'OneToMany'
               associate_one_to_many(relation, parent_id, target_relation_id)
-            else
+            when 'ManyToMany'
               associate_many_to_many(relation, parent_id, target_relation_id)
+            when 'PolymorphicOneToMany'
+              associate_polymorphic_one_to_many(relation, parent_id, target_relation_id)
             end
 
             { content: nil, status: 204 }
@@ -55,6 +58,27 @@ module ForestAdminAgent
             @child_collection.update(@caller, filter, { relation.origin_key => value })
           end
 
+          def associate_polymorphic_one_to_many(relation, parent_id, target_relation_id)
+            id = Schema.primary_keys(@child_collection)[0]
+            value = Collection.get_value(@child_collection, @caller, target_relation_id, id)
+            filter = Filter.new(
+              condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+                [
+                  ConditionTree::Nodes::ConditionTreeLeaf.new(id, 'Equal', value),
+                  @permissions.get_scope(@collection)
+                ]
+              )
+            )
+
+            value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+
+            @child_collection.update(
+              @caller,
+              filter,
+              { relation.origin_key => value, relation.origin_type_field => @collection.name.gsub('__', '::') }
+            )
+          end
+
           def associate_many_to_many(relation, parent_id, target_relation_id)
             id = Schema.primary_keys(@child_collection)[0]
             foreign_value = Collection.get_value(@child_collection, @caller, target_relation_id, id)

data/lib/forest_admin_agent/routes/resources/related/dissociate_related.rb

@@ -28,7 +28,7 @@ module ForestAdminAgent
             filter = get_base_foreign_filter(args)
             relation = Schema.get_to_many_relation(@collection, args[:params]['relation_name'])
 
-            if relation.type == 'OneToMany'
+            if relation.type == 'OneToMany' || relation.type == 'PolymorphicOneToMany'
               dissociate_or_delete_one_to_many(relation, args[:params]['relation_name'], parent_id, is_delete_mode,
                                                filter)
             else
@@ -47,7 +47,12 @@ module ForestAdminAgent
             if is_delete_mode
               @child_collection.delete(@caller, foreign_filter)
             else
-              @child_collection.update(@caller, foreign_filter, { relation.origin_key => nil })
+              patch = if relation.type == 'PolymorphicOneToMany'
+                        { relation.origin_key => nil, relation.origin_type_field => nil }
+                      else
+                        { relation.origin_key => nil }
+                      end
+              @child_collection.update(@caller, foreign_filter, patch)
             end
           end
 

data/lib/forest_admin_agent/routes/resources/related/update_related.rb

@@ -8,6 +8,7 @@ module ForestAdminAgent
           include ForestAdminAgent::Builder
           include ForestAdminDatasourceToolkit::Utils
           include ForestAdminDatasourceToolkit::Components::Query
+
           def setup_routes
             add_route(
               'forest_related_update',
@@ -26,14 +27,19 @@ module ForestAdminAgent
             relation = @collection.schema[:fields][args[:params]['relation_name']]
             parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'])
 
-            linked_id = if (id = args.dig(:params, :data, :id))
+            linked_id = if (id = args.dig(:params, 'data', 'id'))
                           Utils::Id.unpack_id(@child_collection, id)
                         end
 
-            if relation.type == 'ManyToOne'
+            case relation.type
+            when 'ManyToOne'
               update_many_to_one(relation, parent_id, linked_id)
-            elsif relation.type == 'OneToOne'
+            when 'PolymorphicManyToOne'
+              update_polymorphic_many_to_one(relation, parent_id, linked_id)
+            when 'OneToOne'
               update_one_to_one(relation, parent_id, linked_id)
+            when 'PolymorphicOneToOne'
+              update_polymorphic_one_to_one(relation, parent_id, linked_id)
             end
 
             { content: nil, status: 204 }
@@ -49,16 +55,104 @@ module ForestAdminAgent
             @collection.update(@caller, Filter.new(condition_tree: fk_owner), { relation.foreign_key => foreign_value })
           end
 
+          def update_polymorphic_many_to_one(relation, parent_id, linked_id)
+            foreign_value = if linked_id
+                              Collection.get_value(
+                                @child_collection,
+                                @caller,
+                                linked_id,
+                                relation.foreign_key_targets[@child_collection.name]
+                              )
+                            end
+
+            polymorphic_type = @child_collection.name.gsub('__', '::')
+            fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@collection, [parent_id])
+            @collection.update(
+              @caller,
+              Filter.new(condition_tree: fk_owner),
+              {
+                relation.foreign_key => foreign_value,
+                relation.foreign_key_type_field => polymorphic_type
+              }
+            )
+          end
+
+          def update_polymorphic_one_to_one(relation, parent_id, linked_id)
+            origin_value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
+
+            break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
+            create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
+          end
+
           def update_one_to_one(relation, parent_id, linked_id)
             origin_value = Collection.get_value(@collection, @caller, parent_id, relation.origin_key_target)
 
-            break_old_one_to_one_relationship(nil, relation, origin_value, linked_id)
-            create_new_one_to_one_relationship(nil, relation, origin_value, linked_id)
+            break_old_one_to_one_relationship(relation, origin_value, linked_id)
+            create_new_one_to_one_relationship(relation, origin_value, linked_id)
           end
 
-          def break_old_one_to_one_relationship(_scope, relation, origin_value, linked_id)
+          def break_old_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
             linked_id ||= []
 
+            old_fk_owner_filter = Filter.new(
+              condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+                [
+                  @permissions.get_scope(@collection),
+                  ConditionTree::Nodes::ConditionTreeBranch.new(
+                    'And',
+                    [
+                      ConditionTree::Nodes::ConditionTreeLeaf.new(
+                        relation.origin_key,
+                        ConditionTree::Operators::EQUAL,
+                        origin_value
+                      ),
+                      ConditionTree::Nodes::ConditionTreeLeaf.new(
+                        relation.origin_type_field,
+                        ConditionTree::Operators::EQUAL,
+                        @collection.name.gsub('__', '::')
+                      )
+                    ]
+                  ),
+                  # Don't set the new record's field to null
+                  # if it's already initialized with the right value
+                  ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id]).inverse
+                ]
+              )
+            )
+
+            result = @child_collection.aggregate(@caller, old_fk_owner_filter, Aggregation.new(operation: 'Count'), 1)
+            return unless !(result[0]['value']).nil? && (result[0]['value']).positive?
+
+            # Avoids updating records to null if it's not authorized by the ORM
+            # and if there is no record to update (the filter returns no record)
+
+            @child_collection.update(
+              @caller,
+              old_fk_owner_filter,
+              { relation.origin_key => nil, relation.origin_type_field => nil }
+            )
+          end
+
+          def create_new_polymorphic_one_to_one_relationship(relation, origin_value, linked_id)
+            return unless linked_id
+
+            new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id])
+
+            @child_collection.update(
+              @caller,
+              Filter.new(
+                condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+                  [
+                    @permissions.get_scope(@collection), new_fk_owner
+                  ]
+                )
+              ),
+              { relation.origin_key => origin_value, relation.origin_type_field => @collection.name.gsub('__', '::') }
+            )
+          end
+
+          def break_old_one_to_one_relationship(relation, origin_value, linked_id)
+            linked_id ||= []
             old_fk_owner_filter = Filter.new(
               condition_tree: ConditionTree::ConditionTreeFactory.intersect(
                 [
@@ -67,18 +161,16 @@ module ForestAdminAgent
                     relation.origin_key,
                     ConditionTree::Operators::EQUAL,
                     origin_value
-                  )
-                ].push(
+                  ),
                   # Don't set the new record's field to null
                   # if it's already initialized with the right value
                   ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id]).inverse
-                )
+                ]
               )
             )
 
             result = @child_collection.aggregate(@caller, old_fk_owner_filter, Aggregation.new(operation: 'Count'), 1)
-
-            return unless (result[0][:value]).positive?
+            return unless !(result[0]['value']).nil? && (result[0]['value']).positive?
 
             # Avoids updating records to null if it's not authorized by the ORM
             # and if there is no record to update (the filter returns no record)
@@ -86,7 +178,7 @@ module ForestAdminAgent
             @child_collection.update(@caller, old_fk_owner_filter, { relation.origin_key => nil })
           end
 
-          def create_new_one_to_one_relationship(_scope, relation, origin_value, linked_id)
+          def create_new_one_to_one_relationship(relation, origin_value, linked_id)
             return unless linked_id
 
             new_fk_owner = ConditionTree::ConditionTreeFactory.match_ids(@child_collection, [linked_id])

data/lib/forest_admin_agent/routes/resources/show.rb

@@ -37,7 +37,7 @@ module ForestAdminAgent
               class_name: @collection.name,
               is_collection: false,
               serializer: Serializer::ForestSerializer,
-              include: projection.relations.keys
+              include: projection.relations(only_keys: true)
             )
           }
         end

data/lib/forest_admin_agent/routes/resources/store.rb

@@ -20,10 +20,16 @@ module ForestAdminAgent
           record = @collection.create(@caller, data)
           link_one_to_one_relations(args, record)
 
+          id = Utils::Id.unpack_id(@collection, record['id'], with_key: true)
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            condition_tree: ConditionTree::ConditionTreeFactory.match_records(@collection, [id])
+          )
+          records = @collection.list(@caller, filter, ProjectionFactory.all(@collection))
+
           {
             name: args[:params]['collection_name'],
             content: JSONAPI::Serializer.serialize(
-              record,
+              records[0],
               is_collection: false,
               class_name: @collection.name,
               serializer: Serializer::ForestSerializer
@@ -34,7 +40,7 @@ module ForestAdminAgent
         def link_one_to_one_relations(args, record)
           args[:params][:data][:relationships]&.map do |field, value|
             schema = @collection.schema[:fields][field]
-            next unless schema.type == 'OneToOne'
+            next unless schema.type == 'OneToOne' || schema.type == 'PolymorphicOneToOne'
 
             id = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
             foreign_collection = @datasource.get_collection(schema.foreign_collection)
@@ -42,9 +48,11 @@ module ForestAdminAgent
             origin_value = record[schema.origin_key_target]
 
             # update new relation (may update zero or one records).
+            patch = { schema.origin_key => origin_value }
+            patch[schema.origin_type_field] = @collection.name.gsub('__', '::') if schema.type == 'PolymorphicOneToOne'
             condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [id])
             filter = Filter.new(condition_tree: condition_tree)
-            foreign_collection.update(@caller, filter, { schema.origin_key => origin_value })
+            foreign_collection.update(@caller, filter, patch)
           end
         end
       end

data/lib/forest_admin_agent/serializer/forest_serializer.rb

@@ -21,11 +21,13 @@ module ForestAdminAgent
 
       def type
         class_name = @options[:class_name]
-        @@class_names[class_name] ||= class_name
+        @@class_names[class_name] ||= class_name.gsub('::', '__')
       end
 
       def id
-        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(@options[:class_name])
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(
+          @options[:class_name].gsub('::', '__')
+        )
         primary_keys = ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(forest_collection)
         id = []
         primary_keys.each { |key| id << @object[key] }
@@ -50,7 +52,9 @@ module ForestAdminAgent
       end
 
       def attributes
-        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(@options[:class_name])
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(
+          @options[:class_name].gsub('::', '__')
+        )
         fields = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'Column' }
         fields.each { |field_name, _field| add_attribute(field_name) }
         return {} if attributes_map.nil?
@@ -110,9 +114,13 @@ module ForestAdminAgent
 
       def relationships
         datasource = ForestAdminAgent::Facades::Container.datasource
-        forest_collection = datasource.get_collection(@options[:class_name])
-        relations_to_many = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'OneToMany' || field.type == 'ManyToMany' }
-        relations_to_one = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'OneToOne' || field.type == 'ManyToOne' }
+        forest_collection = datasource.get_collection(@options[:class_name].gsub('::', '__'))
+        relations_to_many = forest_collection.schema[:fields].select do |_field_name, field|
+          %w[OneToMany ManyToMany PolymorphicOneToMany].include?(field.type)
+        end
+        relations_to_one = forest_collection.schema[:fields].select do |_field_name, field|
+          %w[OneToOne ManyToOne PolymorphicManyToOne PolymorphicOneToOne].include?(field.type)
+        end
 
         relations_to_one.each { |field_name, _field| add_to_one_association(field_name) }
 
@@ -133,14 +141,24 @@ module ForestAdminAgent
           if object.nil? || object.empty?
             data[formatted_attribute_name]['data'] = nil
           else
-            relation = datasource.get_collection(@options[:class_name]).schema[:fields][attribute_name.to_s]
+            relation = datasource.get_collection(@options[:class_name].gsub('::', '__'))
+                                 .schema[:fields][attribute_name.to_s]
             options = @options.clone
-            options[:class_name] = datasource.get_collection(relation.foreign_collection).name
-            related_object_serializer = ForestSerializer.new(object, options)
-            data[formatted_attribute_name]['data'] = {
-              'type' => related_object_serializer.type.to_s,
-              'id' => related_object_serializer.id.to_s,
-            }
+            if relation.type == 'PolymorphicManyToOne'
+              options[:class_name] = @object[relation.foreign_key_type_field]
+              related_object_serializer = ForestSerializer.new(object, options)
+              data[formatted_attribute_name]['data'] = {
+                'type' => related_object_serializer.type.to_s,
+                'id' => related_object_serializer.id.to_s,
+              }
+            else
+              options[:class_name] = datasource.get_collection(relation.foreign_collection).name
+              related_object_serializer = ForestSerializer.new(object, options)
+              data[formatted_attribute_name]['data'] = {
+                'type' => related_object_serializer.type.to_s,
+                'id' => related_object_serializer.id.to_s,
+              }
+            end
           end
         end
 
@@ -161,7 +179,7 @@ module ForestAdminAgent
           if @_include_linkages.include?(formatted_attribute_name) || attr_data[:options][:include_data]
             data[formatted_attribute_name]['data'] = []
             objects = has_many_relationship(attribute_name, attr_data) || []
-            relation = datasource.get_collection(@options[:class_name]).schema[:fields][attribute_name.to_s]
+            relation = datasource.get_collection(@options[:class_name].gsub('::', '__')).schema[:fields][attribute_name.to_s]
             options = @options.clone
             options[:class_name] = datasource.get_collection(relation.foreign_collection).name
             objects.each do |obj|
@@ -173,6 +191,7 @@ module ForestAdminAgent
             end
           end
         end
+
         data
       end
 

data/lib/forest_admin_agent/serializer/forest_serializer_override.rb

@@ -25,6 +25,7 @@ module ForestAdminAgent
               object = nil
               is_collection = false
               is_valid_attr = false
+
               if serializer.has_one_relationships.key?(unformatted_attr_name)
                 is_valid_attr = true
                 attr_data = serializer.has_one_relationships[unformatted_attr_name]
@@ -58,8 +59,15 @@ module ForestAdminAgent
                 # If it is not set, that indicates that this is an inner path and not a leaf and will
                 # be followed by the recursion below.
                 objects.each do |obj|
-                  relation = ForestAdminAgent::Facades::Container.datasource.get_collection(options[:class_name]).schema[:fields][attribute_name]
-                  relation_class_name = ForestAdminAgent::Facades::Container.datasource.get_collection(relation.foreign_collection).name
+                  relation = ForestAdminAgent::Facades::Container.datasource
+                                                                 .get_collection(options[:class_name].gsub('::', '__'))
+                                                                 .schema[:fields][attribute_name]
+                  if relation.type == 'PolymorphicManyToOne'
+                    relation_class_name = root_object[relation.foreign_key_type_field]
+                  else
+                    relation_class_name = ForestAdminAgent::Facades::Container.datasource.get_collection(relation.foreign_collection).name
+                  end
+
                   option_relation = options.clone
                   option_relation[:class_name] = relation_class_name
                   obj_serializer = JSONAPI::Serializer.find_serializer(obj, option_relation)
@@ -203,6 +211,7 @@ module ForestAdminAgent
                 # of the internal special merging logic.
                 find_recursive_relationships(obj, inclusion_tree, relationship_data, passthrough_options)
               end
+
               result['included'] = relationship_data.map do |_, data|
                 included_passthrough_options = {}
                 included_passthrough_options[:base_url] = passthrough_options[:base_url]
@@ -216,6 +225,7 @@ module ForestAdminAgent
                 serialize_primary(data[:object], included_passthrough_options)
               end
             end
+
             result
           end
         end

data/lib/forest_admin_agent/utils/query_string_parser.rb

@@ -60,7 +60,13 @@ module ForestAdminAgent
 
         fields = fields.split(',').map do |field_name|
           column = collection.schema[:fields][field_name.strip]
-          column.type == 'Column' ? field_name.strip : "#{field_name.strip}:#{args[:params][:fields][field_name.strip]}"
+          if column.type == 'Column'
+            field_name.strip
+          elsif column.type == 'PolymorphicManyToOne'
+            "#{field_name.strip}:*"
+          else
+            "#{field_name.strip}:#{args[:params][:fields][field_name.strip]}"
+          end
         end
 
         Projection.new(fields)

data/lib/forest_admin_agent/utils/schema/generator_field.rb

@@ -4,20 +4,22 @@ module ForestAdminAgent
       class GeneratorField
         RELATION_MAP = {
           'ManyToMany' => 'BelongsToMany',
+          'PolymorphicManyToOne' => 'BelongsTo',
           'ManyToOne' => 'BelongsTo',
+          'PolymorphicOneToMany' => 'HasMany',
           'OneToMany' => 'HasMany',
+          'PolymorphicOneToOne' => 'HasOne',
           'OneToOne' => 'HasOne'
         }.freeze
 
         def self.build_schema(collection, name)
           type = collection.schema[:fields][name].type
 
-          case type
-          when 'Column'
-            schema = build_column_schema(collection, name)
-          when 'ManyToOne', 'OneToMany', 'ManyToMany', 'OneToOne'
-            schema = build_relation_schema(collection, name)
-          end
+          schema = if type == 'Column'
+                     build_column_schema(collection, name)
+                   else
+                     build_relation_schema(collection, name)
+                   end
 
           schema.sort_by { |k, _v| k }.to_h
         end
@@ -151,29 +153,53 @@ module ForestAdminAgent
             )
           end
 
+          def build_polymorphic_many_to_one_schema(relation, base_schema)
+            base_schema.merge(
+              {
+                type: 'Number', # default or take first foreign_key_targets ??,
+                defaultValue: nil,
+                isFilterable: false,
+                isPrimaryKey: false,
+                isRequired: false,
+                isReadOnly: false,
+                isSortable: false,
+                validations: [],
+                reference: "#{base_schema[:field]}.id",
+                polymorphic_referenced_models: relation.foreign_collections
+              }
+            )
+          end
+
           def build_relation_schema(collection, name)
             relation = collection.schema[:fields][name]
-            foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
-
             relation_schema = {
               field: name,
               enums: nil,
               integration: nil,
               isReadOnly: nil,
               isVirtual: false,
-              inverseOf: ForestAdminDatasourceToolkit::Utils::Collection.get_inverse_relation(collection, name),
               relationship: RELATION_MAP[relation.type]
             }
 
-            case relation.type
-            when 'ManyToMany'
-              build_many_to_many_schema(relation, collection, foreign_collection, relation_schema)
-            when 'OneToMany'
-              build_one_to_many_schema(relation, collection, foreign_collection, relation_schema)
-            when 'OneToOne'
-              build_one_to_one_schema(relation, collection, foreign_collection, relation_schema)
-            when 'ManyToOne'
-              build_many_to_one_schema(relation, collection, foreign_collection, relation_schema)
+            if relation.type == 'PolymorphicManyToOne'
+              relation_schema[:inverseOf] = collection.name
+              build_polymorphic_many_to_one_schema(relation, relation_schema)
+            else
+              relation_schema[:inverseOf] = ForestAdminDatasourceToolkit::Utils::Collection.get_inverse_relation(
+                collection,
+                name
+              )
+              foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
+              case relation.type
+              when 'ManyToMany'
+                build_many_to_many_schema(relation, collection, foreign_collection, relation_schema)
+              when 'OneToMany', 'PolymorphicOneToMany'
+                build_one_to_many_schema(relation, collection, foreign_collection, relation_schema)
+              when 'OneToOne', 'PolymorphicOneToOne'
+                build_one_to_one_schema(relation, collection, foreign_collection, relation_schema)
+              when 'ManyToOne'
+                build_many_to_one_schema(relation, collection, foreign_collection, relation_schema)
+              end
             end
           end
         end

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -7,7 +7,7 @@ module ForestAdminAgent
       class SchemaEmitter
         LIANA_NAME = "agent-ruby"
 
-        LIANA_VERSION = "1.0.0-beta.60"
+        LIANA_VERSION = "1.0.0-beta.62"
 
         def self.get_serialized_schema(datasource)
           schema_path = Facades::Container.cache(:schema_path)

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.0.0-beta.60"
+  VERSION = "1.0.0-beta.62"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.60
+  version: 1.0.0.pre.beta.62
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-08 00:00:00.000000000 Z
+date: 2024-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport