class FieldDefinitionListener

class FieldDefinitionListener implements FieldDefinitionListenerInterface {

  /**
   * The entity type manager.
   *
   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
   */
  protected $entityTypeManager;

  /**
   * The key-value factory.
   *
   * @var \Drupal\Core\KeyValueStore\KeyValueFactoryInterface
   */
  protected $keyValueFactory;

  /**
   * Cache backend instance.
   *
   * @var \Drupal\Core\Cache\CacheBackendInterface
   */
  protected $cacheBackend;

  /**
   * The entity field manager.
   *
   * @var \Drupal\Core\Entity\EntityFieldManagerInterface
   */
  protected $entityFieldManager;

  /**
   * Constructs a new FieldDefinitionListener.
   *
   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
   *   The entity type manager.
   * @param \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager
   *   The entity field manager.
   * @param \Drupal\Core\KeyValueStore\KeyValueFactoryInterface $key_value_factory
   *   The key-value factory.
   * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
   *   The cache backend.
   */
  public function __construct(EntityTypeManagerInterface $entity_type_manager, EntityFieldManagerInterface $entity_field_manager, KeyValueFactoryInterface $key_value_factory, CacheBackendInterface $cache_backend) {
    $this->entityTypeManager = $entity_type_manager;
    $this->entityFieldManager = $entity_field_manager;
    $this->keyValueFactory = $key_value_factory;
    $this->cacheBackend = $cache_backend;
  }

  /**
   * {@inheritdoc}
   */
  public function onFieldDefinitionCreate(FieldDefinitionInterface $field_definition) {
    $entity_type_id = $field_definition
      ->getTargetEntityTypeId();
    $bundle = $field_definition
      ->getTargetBundle();
    $field_name = $field_definition
      ->getName();

    // Notify the storage about the new field.
    $this->entityTypeManager
      ->getStorage($entity_type_id)
      ->onFieldDefinitionCreate($field_definition);

    // Update the bundle field map key value collection, add the new field.
    $bundle_field_map = $this->keyValueFactory
      ->get('entity.definitions.bundle_field_map')
      ->get($entity_type_id);
    if (!isset($bundle_field_map[$field_name])) {

      // This field did not exist yet, initialize it with the type and empty
      // bundle list.
      $bundle_field_map[$field_name] = [
        'type' => $field_definition
          ->getType(),
        'bundles' => [],
      ];
    }
    $bundle_field_map[$field_name]['bundles'][$bundle] = $bundle;
    $this->keyValueFactory
      ->get('entity.definitions.bundle_field_map')
      ->set($entity_type_id, $bundle_field_map);

    // Delete the cache entry.
    $this->cacheBackend
      ->delete('entity_field_map');

    // If the field map is initialized, update it as well, so that calls to it
    // do not have to rebuild it again.
    if ($field_map = $this->entityFieldManager
      ->getFieldMap()) {
      if (!isset($field_map[$entity_type_id][$field_name])) {

        // This field did not exist yet, initialize it with the type and empty
        // bundle list.
        $field_map[$entity_type_id][$field_name] = [
          'type' => $field_definition
            ->getType(),
          'bundles' => [],
        ];
      }
      $field_map[$entity_type_id][$field_name]['bundles'][$bundle] = $bundle;
      $this->entityFieldManager
        ->setFieldMap($field_map);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function onFieldDefinitionUpdate(FieldDefinitionInterface $field_definition, FieldDefinitionInterface $original) {

    // Notify the storage about the updated field.
    $this->entityTypeManager
      ->getStorage($field_definition
      ->getTargetEntityTypeId())
      ->onFieldDefinitionUpdate($field_definition, $original);
  }

  /**
   * {@inheritdoc}
   */
  public function onFieldDefinitionDelete(FieldDefinitionInterface $field_definition) {
    $entity_type_id = $field_definition
      ->getTargetEntityTypeId();
    $bundle = $field_definition
      ->getTargetBundle();
    $field_name = $field_definition
      ->getName();

    // Notify the storage about the field deletion.
    $this->entityTypeManager
      ->getStorage($entity_type_id)
      ->onFieldDefinitionDelete($field_definition);

    // Unset the bundle from the bundle field map key value collection.
    $bundle_field_map = $this->keyValueFactory
      ->get('entity.definitions.bundle_field_map')
      ->get($entity_type_id);
    unset($bundle_field_map[$field_name]['bundles'][$bundle]);
    if (empty($bundle_field_map[$field_name]['bundles'])) {

      // If there are no bundles left, remove the field from the map.
      unset($bundle_field_map[$field_name]);
    }
    $this->keyValueFactory
      ->get('entity.definitions.bundle_field_map')
      ->set($entity_type_id, $bundle_field_map);

    // Delete the cache entry.
    $this->cacheBackend
      ->delete('entity_field_map');

    // If the field map is initialized, update it as well, so that calls to it
    // do not have to rebuild it again.
    if ($field_map = $this->entityFieldManager
      ->getFieldMap()) {
      unset($field_map[$entity_type_id][$field_name]['bundles'][$bundle]);
      if (empty($field_map[$entity_type_id][$field_name]['bundles'])) {
        unset($field_map[$entity_type_id][$field_name]);
      }
      $this->entityFieldManager
        ->setFieldMap($field_map);
    }
  }

}