feat: add polymorphic support

.github/workflows/build.yml

@@ -69,7 +69,7 @@ jobs:
  bundle install
 
  - name: Test
- run: cd packages/${{ matrix.package }} && bundle install && bundle exec rspec --color --format doc && cd -
+ run: cd packages/${{ matrix.package }} && BUNDLE_GEMFILE=Gemfile-test bundle install && BUNDLE_GEMFILE=Gemfile-test bundle exec rspec --color --format doc && cd -
 
  - name: Upload coverage
  uses: actions/upload-artifact@v3

.gitignore

@@ -16,5 +16,6 @@ vendor
 
 # GEM
 Gemfile.lock
+Gemfile-test.lock
 *.gem
 pkg/

.releaserc.js

@@ -42,7 +42,7 @@ module.exports = {
  'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/schema_emitter.rb',
  'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/version.rb',
  'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/version.rb',
- 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_customizer/version.rb',
+ 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/version.rb',
  'packages/forest_admin_rails/lib/forest_admin_rails/version.rb',
  'package.json'
  ],

.rubocop.yml

@@ -226,6 +226,7 @@ Metrics/MethodLength:
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/validations/field_validator.rb'
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/actions/action_field_factory.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/action/base_action.rb'
+ - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/rename_field/rename_field_collection_decorator.rb'
 
 Metrics/BlockLength:
  Exclude:
@@ -239,11 +240,13 @@ Metrics/ClassLength:
  - 'packages/forest_admin_agent/lib/forest_admin_agent/services/permissions.rb'
  - 'packages/forest_admin_agent/lib/forest_admin_agent/routes/charts/charts.rb'
  - 'packages/forest_admin_agent/lib/forest_admin_agent/routes/action/actions.rb'
+ - 'packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/related/update_related.rb'
  - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/frontend_validation_utils.rb'
  - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/utils/query.rb'
  - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/collection_customizer.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/binary/binary_collection_decorator.rb'
+ - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/search/search_collection_decorator.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/relation/relation_collection_decorator.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/rename_field/rename_field_collection_decorator.rb'
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/utils/collection.rb'
@@ -253,6 +256,7 @@ Metrics/ClassLength:
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/condition_tree/transforms/comparisons.rb'
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/validations/rules.rb'
  - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_action_field_widget.rb'
+ - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb'
 
 Style/OpenStructUse:
  Exclude:

packages/forest_admin_agent/Gemfile

@@ -2,10 +2,9 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'forest_admin_datasource_customizer'
-gem 'forest_admin_datasource_toolkit'
-
 group :development, :test do
+ gem 'forest_admin_datasource_customizer'
+ gem 'forest_admin_datasource_toolkit'
  gem 'rspec', '~> 3.0'
  gem 'simplecov', '~> 0.22', require: false
  gem 'simplecov-html', '~> 0.12.3'

packages/forest_admin_agent/Gemfile-test

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+ gem 'forest_admin_datasource_customizer', path: '../forest_admin_datasource_customizer'
+ gem 'forest_admin_datasource_toolkit', path: '../forest_admin_datasource_toolkit'
+ gem 'rspec', '~> 3.0'
+ gem 'simplecov', '~> 0.22', require: false
+ gem 'simplecov-html', '~> 0.12.3'
+ gem 'simplecov_json_formatter', '~> 0.1.4'
+end

packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb

@@ -19,7 +19,7 @@ def format_attributes(args)
  record[schema.foreign_key] = value['data'][schema.foreign_key_target] if schema.type == 'ManyToOne'
  end
 
- record
+ record || {}
  end
  end
  end

packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_related_route.rb

@@ -5,7 +5,11 @@ def build(args = {})
  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

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

@@ -37,6 +37,25 @@ def handle_request_bulk(args = {})
  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(
  [

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

@@ -38,7 +38,7 @@ def handle_request(args = {})
  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)
  )
  }

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

@@ -28,10 +28,13 @@ def handle_request(args = {})
  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 @@ def associate_one_to_many(relation, parent_id, target_relation_id)
  @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)

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

@@ -28,7 +28,7 @@ def handle_request(args = {})
  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 @@ def dissociate_or_delete_one_to_many(relation, relation_name, parent_id, is_dele
  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
 

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

@@ -8,6 +8,7 @@ class UpdateRelated < AbstractRelatedRoute
  include ForestAdminAgent::Builder
  include ForestAdminDatasourceToolkit::Utils
  include ForestAdminDatasourceToolkit::Components::Query
+
  def setup_routes
  add_route(
  'forest_related_update',
@@ -26,14 +27,19 @@ def handle_request(args = {})
  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 @@ def update_many_to_one(relation, parent_id, linked_id)
  @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,26 +161,24 @@ def break_old_one_to_one_relationship(_scope, relation, origin_value, linked_id)
  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)
 
  @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])

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

@@ -37,7 +37,7 @@ def handle_request(args = {})
  class_name: @collection.name,
  is_collection: false,
  serializer: Serializer::ForestSerializer,
- include: projection.relations.keys
+ include: projection.relations(only_keys: true)
  )
  }
  end