forest_admin_datasource_customizer 1.20.0 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ee49b58e6a895d834d1f572efcdd8e1a74f18900e82276216023ef9532616c1
-  data.tar.gz: 886e2aaca491fa532ecc05de5aca3a449fcfc46e00d74c23e91e2cf6b27da42a
+  metadata.gz: 371670b192f095092ef1197ab3f975a3cc839addf0182a8a8626c4129f3ddafd
+  data.tar.gz: 575fcb53daec77edf6c1ac0570a962907d8346d1da3373746e040783030ae85f
 SHA512:
-  metadata.gz: 26da0e8526c58463aae326d6c5f89fa3b5647094c7d8bf07f86212649619c35efdadf0aa28da189925cbe9544999202962d3c45af160f6707f5907e7a920d1c9
-  data.tar.gz: bfd5409cb06f37d77659535231f415b93275140d42e47df5616fe7246f829502a6e4e7bce391167e218af9f7ec2c1de742c33ba90e9e919398745707bc2dcc42
+  metadata.gz: bab0b35b445bc3ec354da8f0cbfe4b6425328272d9c24ba536ccbb2f2e178e73772ce7752f258df5eb4baaf92c1ba7acc8a526800e59143973b7043a7485e241
+  data.tar.gz: c91f34ef071ef68104e02490b7b6cca3c18f78fabd386a7f933004701bc06da001e6ff3ace46d313088ebba20829176ec51c916cfc5d39f30a910cea03a0775a

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

@@ -47,9 +47,6 @@ module ForestAdminDatasourceCustomizer
         end
 
         def rename_collection(current_name, new_name)
-          # Check collection exists
-          collection = get_collection(current_name)
-
           return unless current_name != new_name
 
           # Check new name is not already used
@@ -64,17 +61,6 @@ module ForestAdminDatasourceCustomizer
                   "Cannot rename a collection twice: #{@to_child_name[current_name]}->#{current_name}->#{new_name}"
           end
 
-          polymorphic_relations = %w[PolymorphicOneToOne PolymorphicOneToMany]
-          collection.schema[:fields].each do |field_name, field_schema|
-            next unless polymorphic_relations.include?(field_schema.type)
-
-            reverse_relation_name = Utils::Collection.get_inverse_relation(collection, 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

@@ -9,21 +9,46 @@ module ForestAdminDatasourceCustomizer
           datasource.get_collection_name(super)
         end
 
-        def refine_schema(sub_schema)
-          fields = {}
+        def list(caller, filter = nil, projection = nil)
+          refined_filter = refine_filter(caller, filter)
+          records = @child_collection.list(caller, refined_filter, projection)
 
-          sub_schema[:fields].each do |name, old_schema|
-            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)
+          transform_records_polymorphic_values(records)
+        end
+
+        def create(caller, data)
+          transformed_data = transform_data_polymorphic_values(data)
+          result = @child_collection.create(caller, transformed_data)
+
+          transform_record_polymorphic_values(result)
+        end
+
+        def update(caller, filter, patch)
+          refined_filter = refine_filter(caller, filter)
+          transformed_patch = transform_data_polymorphic_values(patch)
+
+          @child_collection.update(caller, refined_filter, transformed_patch)
+        end
+
+        def refine_filter(_caller, filter)
+          return filter unless filter&.condition_tree
+
+          type_fields = polymorphic_type_fields
+
+          transformed_tree = filter.condition_tree.replace_leafs do |leaf|
+            if type_fields.include?(leaf.field)
+              transformed_value = transform_polymorphic_value(leaf.value)
+              if transformed_value == leaf.value
+                leaf
+              else
+                leaf.override(value: transformed_value)
               end
+            else
+              leaf
             end
-
-            fields[name] = old_schema
           end
 
-          sub_schema
+          filter.override(condition_tree: transformed_tree)
         end
 
         # rubocop:disable Lint/UselessMethodDefinition
@@ -31,6 +56,128 @@ module ForestAdminDatasourceCustomizer
           super
         end
         # rubocop:enable Lint/UselessMethodDefinition
+
+        private
+
+        def polymorphic_type_fields
+          type_fields = []
+          child_schema = @child_collection.schema
+          return type_fields unless child_schema && child_schema[:fields]
+
+          child_schema[:fields].each_value do |field_schema|
+            case field_schema.type
+            when 'PolymorphicManyToOne'
+              type_fields << field_schema.foreign_key_type_field
+            end
+          end
+          type_fields
+        end
+
+        def transform_data_polymorphic_values(data)
+          return data unless data
+
+          type_fields = polymorphic_type_fields
+          transformed_data = data.dup
+
+          type_fields.each do |type_field|
+            next unless transformed_data.key?(type_field)
+
+            original_value = transformed_data[type_field]
+            transformed_value = reverse_collection_name(original_value)
+            transformed_data[type_field] = transformed_value if transformed_value != original_value
+          end
+
+          transformed_data
+        end
+
+        def transform_polymorphic_value(value)
+          return value unless value
+
+          # Handle both single values and arrays (for IN/NOT_IN operators)
+          if value.is_a?(Array)
+            value.map { |v| reverse_collection_name(v) }
+          else
+            reverse_collection_name(value)
+          end
+        end
+
+        # convert new collection name back to old name for db queries
+        def reverse_collection_name(collection_name)
+          to_child_name = datasource.instance_variable_get(:@to_child_name)
+          to_child_name[collection_name] || collection_name
+        end
+
+        # convert old collection name to new name for returned data
+        def forward_collection_name(collection_name)
+          from_child_name = datasource.instance_variable_get(:@from_child_name)
+          from_child_name[collection_name] || collection_name
+        end
+
+        def transform_records_polymorphic_values(records)
+          return records unless records.is_a?(Array)
+
+          type_fields = polymorphic_type_fields
+          return records if type_fields.empty?
+
+          records.map do |record|
+            transform_record_polymorphic_values(record)
+          end
+        end
+
+        def transform_record_polymorphic_values(record)
+          return record unless record.is_a?(Hash)
+
+          type_fields = polymorphic_type_fields
+          return record if type_fields.empty?
+
+          transformed_record = record.dup
+
+          type_fields.each do |type_field|
+            next unless transformed_record.key?(type_field)
+
+            old_value = transformed_record[type_field]
+            new_value = forward_collection_name(old_value)
+            transformed_record[type_field] = new_value if new_value != old_value
+          end
+
+          transformed_record
+        end
+
+        protected
+
+        def refine_schema(sub_schema)
+          current_collection_name = @child_collection.name
+
+          sub_schema[:fields].each_value do |old_schema|
+            case old_schema.type
+            when 'PolymorphicOneToOne', 'PolymorphicOneToMany'
+              refine_polymorphic_one_schema(old_schema, current_collection_name)
+            when 'PolymorphicManyToOne'
+              refine_polymorphic_many_schema(old_schema)
+            when 'ManyToOne', 'OneToMany', 'OneToOne'
+              old_schema.foreign_collection = datasource.get_collection_name(old_schema.foreign_collection)
+            when 'ManyToMany'
+              old_schema.foreign_collection = datasource.get_collection_name(old_schema.foreign_collection)
+              old_schema.through_collection = datasource.get_collection_name(old_schema.through_collection)
+            end
+          end
+
+          sub_schema
+        end
+
+        def refine_polymorphic_one_schema(schema, current_collection_name)
+          if schema.origin_type_value == current_collection_name
+            schema.origin_type_value = datasource.get_collection_name(current_collection_name)
+          end
+          schema.foreign_collection = datasource.get_collection_name(schema.foreign_collection)
+        end
+
+        def refine_polymorphic_many_schema(schema)
+          schema.foreign_collections = schema.foreign_collections.map { |fc| datasource.get_collection_name(fc) }
+          schema.foreign_key_targets = schema.foreign_key_targets.transform_keys do |key|
+            datasource.get_collection_name(key)
+          end
+        end
       end
     end
   end

data/lib/forest_admin_datasource_customizer/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceCustomizer
-  VERSION = "1.20.0"
+  VERSION = "1.21.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_customizer
 version: !ruby/object:Gem::Version
-  version: 1.20.0
+  version: 1.21.0
 platform: ruby
 authors:
 - Matthieu