Remove orphaned (dangling) entity references when an entity is deleted

+1 on such a feature.

The option should be available only if enabled by a setting.

However the user should be aware what exactly is being deleted and we would need to preset a list (probably with checkboxes to allow opting out of some deletions).

Please note that even the owner of the entity is behind an entity reference field. Therefore we need to enable this per field - this is something we do in one of our projects already.

However the list might get long in cases of long and nested list of references - for example entity type A references 10 entities of entity type B, which references another 20 entities of entity type C and so on ...

Entity reference field items are not removed when the referenced entity is deleted.

It's more like a bug. Isn't it?

It's more like a bug. Isn't it?

Yep. A real hot mess. I don't think most people realize how out of control it becomes. We certainly didn't when we started our Drupal project.

3 years, 400 authors and 8,000 nodes later we have a crisis on our hands.

If we only knew then what we know now ... thanks Acquia /s

#12 Yes I have just become aware of this 'hot mess'. I worry this could lead to problems down the road.

Reading through the comment history, it looks like a couple people are confused about this is about.

Note that we're not talking about going the other direction (If you delete a entity, also delete the entities that are referenced by this entity).

I'm cleaning up the description to clarify.

+1

A possible solution would be to scan all field entries of the type "entity reference" (How to select by field type?). If a field contains the entity id of the entity (to be) deleted, the entry is removed.

I also had the same problem with this thing but only with referenced custom entities. My solution was that, like kreatIL said, to go through all entities which has entity reference field and update them. This is my solution and it works fine for me. I am not sure why we do not have something like this already in core because it is really problematic thing when you are working (create/update/delete) entities programmatically.

/**
 * Implements hook_entity_delete().
 */
function hook_entity_delete(EntityInterface $entity) {

  $field_map = \Drupal::service('entity_field.manager')->getFieldMapByFieldType('entity_reference');

  foreach ($field_map as $entity_type => $item) {

    foreach ($item as $field_name => $item2) {

      foreach ($item2['bundles'] as $bundle) {

        $bundle_fields = \Drupal::getContainer()->get('entity_field.manager')->getFieldDefinitions($entity_type, $bundle);
        $field_definition = $bundle_fields[$field_name];

        if ($field_definition->getItemDefinition()->getSetting('target_type') == $entity->getEntityType()->id()) {

          $parent_entities = \Drupal::entityTypeManager()->getStorage($entity_type)->loadByProperties([$field_name => $entity->id()]);

          foreach ($parent_entities as $parent_entity) {
            foreach ($parent_entity->get($field_name) as $delta => $field_item) {
              if ($field_item->target_id == $entity->id()) {
                $parent_entity->get($field_name)->removeItem($delta);
                $parent_entity->save();
                break;
              }
            }
          }

        }

      }

    }

  }

}

@bojan.m

I am not sure why we do not have something like this already in core

I updated the issue description to describe why:

Why doesn't a fix for this already exist in core?

• There are scenarios where dangling references shouldn't be automatically cleaned up (if you need a human, or some other system to take action).
• It's a performance challenge. There may be tens of thousands (or more) dangling references to clean up.

Still relevant for 9.x :-)

Also there is already a basic example of reference cleanup in core in node_user_predelete() which deletes nodes which have as author the user being deleted.

@dalin

Why doesn't a fix for this already exist in core?

• There are scenarios where dangling references shouldn't be automatically cleaned up (if you need a human, or some other system to take action).
• It's a performance challenge. There may be tens of thousands (or more) dangling references to clean up.

Well, I do not see this performance challenge as big issue because it can be managed by queues like Revisions that are no longer used.
Something like "Entity Reference Revisions Orphan Purger" from Entity Reference Revisions module where you do not update all entities in one request but you put them in queue.

@bojan.m

I agree, I'm just stating why it doesn't already exist.

We had some free time to create module that will solve this problem.

Entity reference purger

Feel free to test it and use it.. if you have something on your mind please write us issue.
Thanks.

Yes in my case it was JSON API having a node resource with a (Required) dynamic_entity_reference field of type node
if you delete the referenced node = fire and brimstone and serious cryptic error.

leading to you doubting core , JSON API and your own sanity

  // no this is not the issue its still thinking the node exists :( 
  $relatable_resource_types = $resource_type->getRelatableResourceTypesByField($resource_type->getPublicName($field->getName()));
  assert(!empty($relatable_resource_types));

Acquia docs link to this issue as the cause of surprisingly large DB tables belonging to their Cohesion system.. On a site I looked at there were 63K nodes, 75K node revisions, and the table cohesion_layout_field_revision was 630MB in size. (This was larger than the entire Drupal codebase and the remainder of the site DB put together.)

Adding Acquia's Cohesion tables to the "examples of this problem" list in ID.

I made a contrib module that takes care of deleting references: https://www.drupal.org/project/entity_reference_delete

In addition to #30:

• https://www.drupal.org/project/entity_reference_purger
• https://www.drupal.org/project/cer/

I agree, references need a functionality like databases have to track references and remove orphans and it should be in core. Still I understand the complexities ;)

#31: +1
We have been using Entity Reference Purger in production for over a year. The module addresses exactly the issue described in the original post. In our usecase, the number of references to be deleted is typically in the triple digits, without any significant performance issues.