forest_admin_datasource_customizer 1.0.0.pre.beta.61 → 1.0.0.pre.beta.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01a3e9d078567da75ac00fbce2df8722f362800ac0e67108691755f8ea3908ea
-  data.tar.gz: b7fb6555dcefb5e78f6fceba1afaca3459d73f52692be6492d6992a9875c3de8
+  metadata.gz: b1f569cc8ed095e0fe9181fd91829c24ec7971a5ccd9865bd297f1cc033dfb13
+  data.tar.gz: 7399cccaedbf68f4b29e0f7ca1b187af5a828ada5a71d9610becb16ef95869c2
 SHA512:
-  metadata.gz: abfb2618846aebd32cacb55c85a074786e59e72596baefded111a7e1a801622ee9d5b7bc1ab19c3c74018a19e692fb600c9fa47043b146efb1c4fc438cff3b82
-  data.tar.gz: ee3c04a82b7b8cc35ee009a935b26f06e014bfb95b6d34b8e82263c3433ba665619d59ad9795020c9399cd83d538758cef97aad01725f7a5701cffb1b0def061
+  metadata.gz: dd5d5bd6c0926ddea927c3c6688d7f1edea5401729a317c9e9b4a68d1e23fb0cf4e20f1205805f1ba4e84aebae9550e1a333687eafbbe96ba9e149026f43bb47
+  data.tar.gz: 74adc0bbff4f997ea4c3fc1a5da2408ddc02e09a1bfb1d47baf1480ebf2f4c36aacf3f792ddc01baa607ee27b837b9402ee397604155361263d2c71162fd9ff8

data/lib/forest_admin_datasource_customizer/decorators/binary/binary_collection_decorator.rb

@@ -134,6 +134,8 @@ module ForestAdminDatasourceCustomizer
           prefix, suffix = path.split(':')
           field = @child_collection.schema[:fields][prefix]
 
+          return value if field.type == 'PolymorphicManyToOne'
+
           if field.type != 'Column'
             foreign_collection = @datasource.get_collection(field.foreign_collection)
 

data/lib/forest_admin_datasource_customizer/decorators/computed/compute_collection_decorator.rb

@@ -16,6 +16,15 @@ module ForestAdminDatasourceCustomizer
           index = path.index(':')
           return @computeds[path] if index.nil?
 
+          if schema[:fields][path[0, index]].type == 'PolymorphicManyToOne'
+            ForestAdminAgent::Facades::Container.logger.log(
+              'Debug',
+              "Cannot compute field over polymorphic relation #{name}.#{path[0, index]}."
+            )
+
+            return @computeds[path]
+          end
+
           foreign_collection = schema[:fields][path[0, index]].foreign_collection
           association = @datasource.get_collection(foreign_collection)
 
@@ -27,6 +36,10 @@ module ForestAdminDatasourceCustomizer
 
           # Check that all dependencies exist and are columns
           computed.dependencies.each do |field|
+            if field.include?(':') && schema[:fields][field.partition(':')[0]].type == 'PolymorphicManyToOne'
+              raise ForestException,
+                    "Dependencies over a polymorphic relations(#{self.name}.#{field.partition(":")[0]}) are forbidden"
+            end
             FieldValidator.validate(self, field)
           end
 
@@ -90,12 +103,14 @@ module ForestAdminDatasourceCustomizer
           if path.include?(':')
             prefix = path.split(':')[0]
             schema = collection.schema[:fields][prefix]
-            association = collection.datasource.get_collection(schema.foreign_collection)
+            if schema.type != 'PolymorphicManyToOne'
+              association = collection.datasource.get_collection(schema.foreign_collection)
 
-            return Projection.new([path])
-                             .unnest
-                             .replace { |sub_path| rewrite_field(association, sub_path) }
-                             .nest(prefix: prefix)
+              return Projection.new([path])
+                               .unnest
+                               .replace { |sub_path| rewrite_field(association, sub_path) }
+                               .nest(prefix: prefix)
+            end
           end
 
           # Computed field that we own: recursively replace by dependencies

data/lib/forest_admin_datasource_customizer/decorators/operators_equivalence/operators_equivalence_collection_decorator.rb

@@ -11,7 +11,8 @@ module ForestAdminDatasourceCustomizer
           schema = sub_schema.dup
           schema[:fields] = sub_schema[:fields].dup
 
-          schema[:fields].map do |_name, field_schema|
+          schema[:fields].each do |name, field_schema|
+            field_schema = field_schema.dup
             if field_schema.type == 'Column'
               new_operators = Operators.all.select do |operator|
                 ConditionTreeEquivalent.equivalent_tree?(operator, field_schema.filter_operators,
@@ -19,9 +20,9 @@ module ForestAdminDatasourceCustomizer
               end
 
               field_schema.filter_operators = new_operators
-            else
-              field_schema
             end
+
+            schema[:fields][name] = field_schema
           end
 
           schema

data/lib/forest_admin_datasource_customizer/decorators/publication/publication_collection_decorator.rb

@@ -17,6 +17,13 @@ module ForestAdminDatasourceCustomizer
             child_collection, name
           )
 
+          @child_collection.schema[:fields].each do |field_name, field_schema|
+            next unless field_schema.type == 'PolymorphicManyToOne' &&
+                        [field_schema.foreign_key, field_schema.foreign_key_type_field].include?(name)
+
+            raise ForestException, "Cannot remove field '#{self.name}.#{name}', because it's implied " \
+                                   "in a polymorphic relation '#{self.name}.#{field_name}'"
+          end
           if visible
             @blacklist.delete(name)
           else
@@ -37,14 +44,15 @@ module ForestAdminDatasourceCustomizer
 
         def refine_schema(child_schema)
           fields = {}
+          schema = child_schema.dup
 
-          child_schema[:fields].each do |name, field|
+          schema[:fields].each do |name, field|
             fields[name] = field if published?(name)
           end
 
-          child_schema[:fields] = fields
+          schema[:fields] = fields
 
-          child_schema
+          schema
         end
 
         def published?(name)

data/lib/forest_admin_datasource_customizer/decorators/publication/publication_datasource_decorator.rb

@@ -33,6 +33,7 @@ module ForestAdminDatasourceCustomizer
 
         def remove_collection(collection_name)
           validate_collection_names([collection_name])
+          validate_is_removable(collection_name)
 
           # Delete the collection
           @blacklist << collection_name
@@ -48,6 +49,17 @@ module ForestAdminDatasourceCustomizer
 
         private
 
+        def validate_is_removable(collection_name)
+          collection = get_collection(collection_name)
+          collection.schema[:fields].each do |field_name, field_schema|
+            next unless field_schema.type == 'PolymorphicOneToOne' || field_schema.type == 'PolymorphicOneToMany'
+
+            inverse = ForestAdminDatasourceToolkit::Utils::Collection.get_inverse_relation(collection, field_name)
+
+            raise ForestException, "Cannot remove #{collection.name} because it's a potential target of polymorphic relation #{field_schema.foreign_collection}.#{inverse}"
+          end
+        end
+
         def validate_collection_names(names)
           names.each { |name| get_collection(name) }
         end

data/lib/forest_admin_datasource_customizer/decorators/relation/relation_collection_decorator.rb

@@ -177,7 +177,7 @@ module ForestAdminDatasourceCustomizer
           prefix = field.split(':').first
           field_schema = schema[:fields][prefix]
 
-          return [field] if field_schema.type == 'Column'
+          return [field] if field_schema.type == 'Column' || field_schema.type == 'PolymorphicManyToOne'
 
           relation = datasource.get_collection(field_schema.foreign_collection)
           result = []

data/lib/forest_admin_datasource_customizer/decorators/rename_collection/rename_collection_datasource_decorator.rb

@@ -55,6 +55,16 @@ module ForestAdminDatasourceCustomizer
                   "Cannot rename a collection twice: #{@to_child_name[current_name]}->#{current_name}->#{new_name}"
           end
 
+          get_collection(current_name).schema[:fields].each do |field_name, field_schema|
+            next unless field_schema.type == 'PolymorphicOneToOne' || field_schema.type == 'PolymorphicOneToMany'
+
+            reverse_relation_name = Utils::Collection.get_inverse_relation(get_collection(current_name), field_name)
+
+            raise Exceptions::ForestException,
+                  "Cannot rename collection #{current_name} because it's a target of a polymorphic relation " \
+                  "'#{field_schema.foreign_collection}.#{reverse_relation_name}'"
+          end
+
           @from_child_name[current_name] = new_name
           @to_child_name[new_name] = current_name
 

data/lib/forest_admin_datasource_customizer/decorators/rename_collection/rename_collection_decorator.rb

@@ -13,7 +13,7 @@ module ForestAdminDatasourceCustomizer
           fields = {}
 
           sub_schema[:fields].each do |name, old_schema|
-            if old_schema.type != 'Column'
+            if old_schema.type != 'Column' && old_schema.type != 'PolymorphicManyToOne'
               old_schema.foreign_collection = datasource.get_collection_name(old_schema.foreign_collection)
               if old_schema.type == 'ManyToMany'
                 old_schema.through_collection = datasource.get_collection_name(old_schema.through_collection)

data/lib/forest_admin_datasource_customizer/decorators/rename_field/rename_field_collection_decorator.rb

@@ -3,6 +3,7 @@ module ForestAdminDatasourceCustomizer
     module RenameField
       class RenameFieldCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
         include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Exceptions
         include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
 
         attr_accessor :from_child_collection, :to_child_collection
@@ -22,6 +23,14 @@ module ForestAdminDatasourceCustomizer
 
           ForestAdminDatasourceToolkit::Validations::FieldValidator.validate_name(name, new_name)
 
+          @child_collection.schema[:fields].each do |field_name, field_schema|
+            next unless field_schema.type == 'PolymorphicManyToOne' &&
+                        [field_schema.foreign_key, field_schema.foreign_key_type_field].include?(current_name)
+
+            raise ForestException, "Cannot rename '#{name}.#{current_name}', because it's implied " \
+                                   "in a polymorphic relation '#{name}.#{field_name}'"
+          end
+
           # Revert previous renaming (avoids conflicts and need to recurse on @to_child_collection).
           if to_child_collection[current_name]
             child_name = to_child_collection[current_name]
@@ -41,6 +50,7 @@ module ForestAdminDatasourceCustomizer
 
         def refine_schema(sub_schema)
           fields = {}
+          schema = sub_schema.dup
 
           sub_schema[:fields].each do |old_name, old_schema|
             case old_schema.type
@@ -58,9 +68,9 @@ module ForestAdminDatasourceCustomizer
             fields[from_child_collection[old_name] || old_name] = old_schema
           end
 
-          sub_schema[:fields] = fields
+          schema[:fields] = fields
 
-          sub_schema
+          schema
         end
 
         def refine_filter(_caller, filter = nil)
@@ -89,7 +99,7 @@ module ForestAdminDatasourceCustomizer
         def list(caller, filter, projection)
           child_projection = projection.replace { |field| path_to_child_collection(field) }
           records = @child_collection.list(caller, filter, child_projection)
-          return records if child_projection == projection
+          return records if child_projection.sort == projection.sort
 
           records.map { |record| record_from_child_collection(record) }
         end
@@ -134,9 +144,11 @@ module ForestAdminDatasourceCustomizer
             child_field = paths[0]
             relation_name = from_child_collection[child_field] || child_field
             relation_schema = schema[:fields][relation_name]
-            relation = datasource.get_collection(relation_schema.foreign_collection)
+            if relation_schema.type != 'PolymorphicManyToOne'
+              relation = datasource.get_collection(relation_schema.foreign_collection)
 
-            return "#{relation_name}:#{relation.path_from_child_collection(paths[1])}"
+              return "#{relation_name}:#{relation.path_from_child_collection(paths[1])}"
+            end
           end
 
           from_child_collection[path] ||= path
@@ -148,10 +160,12 @@ module ForestAdminDatasourceCustomizer
             paths = path.split(':')
             relation_name = paths[0]
             relation_schema = schema[:fields][relation_name]
-            relation = datasource.get_collection(relation_schema.foreign_collection)
-            child_field = to_child_collection[relation_name] || relation_name
+            if relation_schema.type != 'PolymorphicManyToOne'
+              relation = datasource.get_collection(relation_schema.foreign_collection)
+              child_field = to_child_collection[relation_name] || relation_name
 
-            return "#{child_field}:#{relation.path_to_child_collection(paths[1])}"
+              return "#{child_field}:#{relation.path_to_child_collection(paths[1])}"
+            end
           end
 
           to_child_collection[path] ||= path
@@ -173,8 +187,8 @@ module ForestAdminDatasourceCustomizer
             field = from_child_collection[child_field] || child_field
             field_schema = schema[:fields][field]
 
-            # Perform the mapping, recurse for relations
-            if field_schema.type == 'Column' || value.nil?
+            # Perform the mapping, recurse for relation
+            if field_schema.type == 'Column' || field_schema.type == 'PolymorphicManyToOne' || value.nil?
               record[field] = value
             else
               relation = datasource.get_collection(field_schema.foreign_collection)

data/lib/forest_admin_datasource_customizer/decorators/search/search_collection_decorator.rb

@@ -104,7 +104,17 @@ module ForestAdminDatasourceCustomizer
           collection.schema[:fields].each do |name, field|
             fields.push([name, field]) if field.type == 'Column'
 
-            next unless extended && (field.type == 'ManyToOne' || field.type == 'OneToOne')
+            if field.type == 'PolymorphicManyToOne'
+              ForestAdminAgent::Facades::Container.logger.log(
+                'Debug',
+                "We're not searching through #{self.name}.#{name} because it's a polymorphic relation. " \
+                "You can override the default search behavior with 'replace_search'. " \
+                'See more: https://docs.forestadmin.com/developer-guide-agents-ruby/agent-customization/search'
+              )
+            end
+
+            next unless extended &&
+                        (field.type == 'ManyToOne' || field.type == 'OneToOne' || field.type == 'PolymorphicOneToOne')
 
             related = collection.datasource.get_collection(field.foreign_collection)
 

data/lib/forest_admin_datasource_customizer/decorators/write/write_replace/write_replace_collection_decorator.rb

@@ -72,10 +72,10 @@ module ForestAdminDatasourceCustomizer
             if field_schema&.type == 'Column'
               # We either call the customer handler or a default one that does nothing.
               handler = @handlers[key] || proc { |v| { key => v } }
-              field_patch = if context.record[key] && handler.call(context.record[key], context)
+              field_patch = if context.record.key?(key) && handler.call(context.record[key], context)
                               handler.call(context.record[key], context)
                             else
-                              []
+                              {}
                             end
 
               if field_patch && !field_patch.is_a?(Hash)
@@ -84,10 +84,17 @@ module ForestAdminDatasourceCustomizer
 
               # Isolate change to our own value (which should not recurse) and the rest which should
               # trigger the other handlers.
-              value = field_patch[key] || nil
+              if field_patch.key?(key)
+                value = field_patch[key]
+                is_value = true
+              else
+                value = nil
+                is_value = false
+              end
+
               new_patch = rewrite_patch(context.caller, context.action, field_patch.except(key), used + [key])
 
-              value ? deep_merge({ key => value }, new_patch) : new_patch
+              is_value ? deep_merge({ key => value }, new_patch) : new_patch
             elsif field_schema&.type == 'ManyToOne' || field_schema&.type == 'OneToOne'
               # Delegate relations to the appropriate collection.
               relation = datasource.get_collection(field_schema.foreign_collection)

data/lib/forest_admin_datasource_customizer/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceCustomizer
-  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_customizer
 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