forest_admin_datasource_toolkit 1.0.0.pre.beta.61 → 1.0.0.pre.beta.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75c2a7dd3e73ab35a21a709f66a26b010451b12b351beee9a406f0d8bd603c30
-  data.tar.gz: af73c66990a1e2428bec50bcf84f7114ac2b7b5ae4a41a4541ede3a4722460c7
+  metadata.gz: bc0b57418aca698691178e0871421fd15bbd914dc89b2b449cc4af62114b46dc
+  data.tar.gz: ab89da8265eb3bb14c2e3cf7db7d7d795e4a64f623b8bb088def57488a043f8e
 SHA512:
-  metadata.gz: 4514679b848d96a9321d9a8fd0082e2f7dbde52ffa3e9168cbb7073a0b98cadaaf70141091a934df1a1021c6a5b65a7c66f913e636be651bee8c7935197a1b97
-  data.tar.gz: be5eb58b7380562ae3e9fea7de7f8c540bc7f9502d45b4c0b6e7bdb8760567f6c32ea68f1be61e22db0a9ec4cb4aca0a58aa3ec1c054e22056c86729306bc856
+  metadata.gz: d68d8cd582bdafaab2f8aa183f2197518be454567cc0ec661f2ca20fc21adc147eedc9e45d9ca558211124a36443d75356f2ecb9bdee20cec43ec01dcf67924d
+  data.tar.gz: 77a33ebd8cc869736e6f68a89325278790806d79e7aa111a63bd13b24069c83128705af27bf098a732fba2f5e6cf633037d71435a4779f38ed554f535023a41d

data/lib/forest_admin_datasource_toolkit/components/query/filter_factory.rb

@@ -58,14 +58,24 @@ module ForestAdminDatasourceToolkit
           relation = ForestAdminDatasourceToolkit::Utils::Schema.get_to_many_relation(collection, relation_name)
           origin_value = ForestAdminDatasourceToolkit::Utils::Collection.get_value(collection, caller, id,
                                                                                    relation.origin_key_target)
+
           if relation.is_a?(OneToManySchema)
             origin_tree = Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value)
+          elsif relation.is_a?(PolymorphicOneToManySchema)
+            origin_tree = ConditionTreeFactory.intersect(
+              [
+                Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
+                Nodes::ConditionTreeLeaf.new(relation.origin_type_field, Operators::EQUAL, relation.origin_type_value)
+              ]
+            )
           else
             through_collection = collection.datasource.get_collection(relation.through_collection)
-            through_tree = ConditionTreeFactory.intersect([
-                                                            Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
-                                                            Nodes::ConditionTreeLeaf.new(relation.foreign_key, Operators::PRESENT)
-                                                          ])
+            through_tree = ConditionTreeFactory.intersect(
+              [
+                Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
+                Nodes::ConditionTreeLeaf.new(relation.foreign_key, Operators::PRESENT)
+              ]
+            )
             records = through_collection.list(
               caller,
               Filter.new(condition_tree: through_tree),

data/lib/forest_admin_datasource_toolkit/components/query/projection.rb

@@ -10,6 +10,8 @@ module ForestAdminDatasourceToolkit
 
           relations.each do |relation, projection|
             schema = collection.schema[:fields][relation]
+            next unless schema.type != 'PolymorphicManyToOne'
+
             association = collection.datasource.get_collection(schema.foreign_collection)
             projection_with_pks = projection.with_pks(association).nest(prefix: relation)
 
@@ -23,15 +25,19 @@ module ForestAdminDatasourceToolkit
           reject { |field| field.include?(':') }
         end
 
-        def relations
-          each_with_object({}) do |path, memo|
+        def relations(only_keys: false)
+          relations = each_with_object({}) do |path, memo|
             next unless path.include?(':')
 
             original_path = path.split(':')
+            next if original_path.size == 1 && !only_keys
+
             relation = original_path.shift
 
             memo[relation] = Projection.new([original_path.join(':')].union(memo[relation] || []))
           end
+
+          only_keys ? relations.keys : relations
         end
 
         def nest(prefix: nil)

data/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb

@@ -9,7 +9,7 @@ module ForestAdminDatasourceToolkit
             schema = path[1]
             memo += [column_name] if schema.type == 'Column'
 
-            if schema.type == 'OneToOne' || schema.type == 'ManyToOne'
+            if schema.type == 'OneToOne' || schema.type == 'ManyToOne' || schema.type == 'PolymorphicOneToOne'
               relation = collection.datasource.get_collection(schema.foreign_collection)
               relation_columns = relation.schema[:fields]
                                          .select { |_column_name, relation_column| relation_column.type == 'Column' }
@@ -19,6 +19,8 @@ module ForestAdminDatasourceToolkit
               memo += relation_columns
             end
 
+            memo += ["#{column_name}:*"] if schema.type == 'PolymorphicManyToOne'
+
             memo
           end
 

data/lib/forest_admin_datasource_toolkit/schema/relations/polymorphic_many_to_one_schema.rb

@@ -0,0 +1,23 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class PolymorphicManyToOneSchema
+        attr_reader :foreign_key_target, :foreign_key, :foreign_key_targets, :foreign_key_type_field,
+                    :foreign_collections, :type
+
+        def initialize(
+          foreign_key_type_field:,
+          foreign_key:,
+          foreign_key_targets:,
+          foreign_collections:
+        )
+          @foreign_key = foreign_key
+          @foreign_key_targets = foreign_key_targets
+          @foreign_key_type_field = foreign_key_type_field
+          @foreign_collections = foreign_collections
+          @type = 'PolymorphicManyToOne'
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relations/polymorphic_one_to_many_schema.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class PolymorphicOneToManySchema < RelationSchema
+        attr_accessor :origin_key
+        attr_reader :origin_key_target, :origin_type_field, :origin_type_value
+
+        def initialize(origin_key:, origin_key_target:, foreign_collection:, origin_type_field:, origin_type_value:)
+          super(foreign_collection, 'PolymorphicOneToMany')
+          @origin_key = origin_key
+          @origin_key_target = origin_key_target
+          @origin_type_field = origin_type_field
+          @origin_type_value = origin_type_value
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/schema/relations/polymorphic_one_to_one_schema.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceToolkit
+  module Schema
+    module Relations
+      class PolymorphicOneToOneSchema < RelationSchema
+        attr_accessor :origin_key
+        attr_reader :origin_key_target, :origin_type_field, :origin_type_value
+
+        def initialize(origin_key:, origin_key_target:, foreign_collection:, origin_type_field:, origin_type_value:)
+          super(foreign_collection, 'PolymorphicOneToOne')
+          @origin_key = origin_key
+          @origin_key_target = origin_key_target
+          @origin_type_field = origin_type_field
+          @origin_type_value = origin_type_value
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/utils/collection.rb

@@ -9,20 +9,25 @@ module ForestAdminDatasourceToolkit
       def self.get_inverse_relation(collection, relation_name)
         relation_field = collection.schema[:fields][relation_name]
         foreign_collection = collection.datasource.get_collection(relation_field.foreign_collection)
+        polymorphic_relations = %w[PolymorphicOneToOne PolymorphicOneToMany]
 
         inverse = foreign_collection.schema[:fields].select do |_name, field|
-          field.is_a?(RelationSchema) &&
-            field.foreign_collection == collection.name &&
-            (
-              (field.is_a?(ManyToManySchema) &&
-                relation_field.is_a?(ManyToManySchema) &&
-                many_to_many_inverse?(field, relation_field)) ||
-              (field.is_a?(ManyToOneSchema) &&
-                (relation_field.is_a?(OneToOneSchema) || relation_field.is_a?(OneToManySchema)) &&
-                many_to_one_inverse?(field, relation_field)) ||
-              ((field.is_a?(OneToOneSchema) || field.is_a?(OneToManySchema)) &&
-                relation_field.is_a?(ManyToOneSchema) && other_inverse?(field, relation_field))
-            )
+          if polymorphic_relations.include?(relation_field.type)
+            field.is_a?(PolymorphicManyToOneSchema) &&
+              field.foreign_collections.include?(collection.name)
+          else
+            field.is_a?(RelationSchema) &&
+              field.foreign_collection == collection.name &&
+              (
+                (field.is_a?(ManyToManySchema) && relation_field.is_a?(ManyToManySchema) &&
+                  many_to_many_inverse?(field, relation_field)) ||
+                  (field.is_a?(ManyToOneSchema) &&
+                    (relation_field.is_a?(OneToOneSchema) || relation_field.is_a?(OneToManySchema)) &&
+                    many_to_one_inverse?(field, relation_field)) ||
+                  ((field.is_a?(OneToOneSchema) || field.is_a?(OneToManySchema)) &&
+                    relation_field.is_a?(ManyToOneSchema) && other_inverse?(field, relation_field))
+              )
+          end
         end.keys.first
 
         inverse || nil
@@ -138,7 +143,7 @@ module ForestAdminDatasourceToolkit
               projection.nest(prefix: foreign_relation)
             )
 
-            return records.map { |r| r.try(foreign_relation) }
+            return records.map { |r| r[foreign_relation] }
           end
         end
 

data/lib/forest_admin_datasource_toolkit/utils/schema.rb

@@ -30,7 +30,7 @@ module ForestAdminDatasourceToolkit
 
         relation = collection.schema[:fields][relation_name]
 
-        if relation.type != 'OneToMany' && relation.type != 'ManyToMany'
+        if relation.type != 'OneToMany' && relation.type != 'PolymorphicOneToMany' && relation.type != 'ManyToMany'
           raise Exceptions::ForestException,
                 "Relation #{relation_name} has invalid type should be one of OneToMany or ManyToMany."
         end

data/lib/forest_admin_datasource_toolkit/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceToolkit
-  VERSION = "1.0.0-beta.61"
+  VERSION = "1.0.0-beta.62"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_toolkit
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.61
+  version: 1.0.0.pre.beta.62
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-26 00:00:00.000000000 Z
+date: 2024-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -100,6 +100,9 @@ files:
 - lib/forest_admin_datasource_toolkit/schema/relations/many_to_one_schema.rb
 - lib/forest_admin_datasource_toolkit/schema/relations/one_to_many_schema.rb
 - lib/forest_admin_datasource_toolkit/schema/relations/one_to_one_schema.rb
+- lib/forest_admin_datasource_toolkit/schema/relations/polymorphic_many_to_one_schema.rb
+- lib/forest_admin_datasource_toolkit/schema/relations/polymorphic_one_to_many_schema.rb
+- lib/forest_admin_datasource_toolkit/schema/relations/polymorphic_one_to_one_schema.rb
 - lib/forest_admin_datasource_toolkit/utils/collection.rb
 - lib/forest_admin_datasource_toolkit/utils/hash_helper.rb
 - lib/forest_admin_datasource_toolkit/utils/record.rb