Content Entity Field Definitions की परिभाषा और उपयोग

30/09/2025, by Ivan

Content entities को अपने सभी फील्ड्स को स्पष्ट रूप से परिभाषित करना होता है, इसके लिए entity class में definitions दी जाती हैं। फील्ड definitions Typed data API पर आधारित होती हैं (देखें कैसे entities इसे implement करती हैं).

फील्ड डिफ़िनिशन्स

Entity types अपने बेस फील्ड्स को entity class के static method में परिभाषित करते हैं। बेस फील्ड्स वो फील्ड्स हैं जो configure नहीं किए जा सकते और हमेशा entity type में मौजूद होते हैं, जैसे node का title या creation/change तारीखें। Entity Manager इन बेस फील्ड्स को custom और non-configurable फील्ड्स से पूरक करता है, जिन्हें दूसरे modules द्वारा प्रदान किया जाता है, hook_entity_field_info() और hook_entity_field_info_alter() के माध्यम से। Field UI द्वारा कॉन्फ़िगर किए गए फील्ड्स भी इसी तरह जुड़ते हैं (ये hooks अब API का हिस्सा नहीं हैं)।

फील्ड definitions ऐसे objects होते हैं जो FieldDefinitionInterface को implement करते हैं। बेस फील्ड्स आमतौर पर BaseFieldDefinition class से बनाए जाते हैं, जबकि custom फील्ड्स interface को सीधे implement करते हैं और संबंधित configuration objects (Field और FieldInstance) के साथ काम करते हैं।
फील्ड definitions का उपयोग validation constraints परिभाषित करने के लिए भी होता है। किसी भी Field type plugin की implementations उपयोग की जा सकती हैं। (यह interface और class अब मौजूद नहीं हैं)।

फील्ड्स हमेशा Field items की list होती हैं, यानी FieldItem class (type के रूप में परिभाषित) को FieldItemList class में wrap किया जाता है, जो field items की list को दर्शाता है।

सभी फील्ड्स (बेस फील्ड्स समेत) के पास widgets और formatters हो सकते हैं, जो उन्हें दिखाने और एडिट करने के लिए उपयोग होते हैं।

बेस फील्ड्स

नीचे node entity type के field definitions की एक संक्षिप्त उदाहरण सूची है:

use Drupal\Core\Field\BaseFieldDefinition;

class Node implements NodeInterface {

  /**
   * {@inheritdoc}
   */
  public static function baseFieldDefinitions($entity_type) {
    // Node ID integer है, IntegerItem field item class उपयोग करता है।
    $fields['nid'] = BaseFieldDefinition::create('integer')
      ->setLabel(t('Node ID'))
      ->setDescription(t('The node ID.'))
      ->setReadOnly(TRUE);

    // UUID field uuid_field type उपयोग करता है, जिससे entity create होते समय नया UUID बनेगा।
    $fields['uuid'] = BaseFieldDefinition::create('uuid')
      ->setLabel(t('UUID'))
      ->setDescription(t('The node UUID.'))
      ->setReadOnly(TRUE);

    // Language code language_field से परिभाषित है, जिससे default language सुनिश्चित होती है।
    $fields['langcode'] = BaseFieldDefinition::create('language')
      ->setLabel(t('Language code'))
      ->setDescription(t('The node language code.'));

    // Title StringItem है, डिफ़ॉल्ट मान empty string है और 255 characters की सीमा है।
    $fields['title'] = BaseFieldDefinition::create('string')
      ->setLabel(t('Title'))
      ->setDescription(t('The title of this node, always treated as non-markup plain text.'))
      ->setRequired(TRUE)
      ->setTranslatable(TRUE)
      ->setSettings(array(
        'default_value' => '',
        'max_length' => 255,
      ));

    // uid user entity type का entity reference है।
    $fields['uid'] = BaseFieldDefinition::create('entity_reference')
      ->setLabel(t('User ID'))
      ->setDescription(t('The user ID of the node author.'))
      ->setSettings(array(
        'target_type' => 'user',
        'default_value' => 0,
      ));

    // changed field हर बार entity save होने पर timestamp अपडेट करता है।
    $fields['changed'] = BaseFieldDefinition::create('changed')
      ->setLabel(t('Changed'))
      ->setDescription(t('The time that the node was last edited.'))
    return $fields;
  }
}

मल्टी-वैल्यू फील्ड्स

फील्ड में अनुमत items की अधिकतम संख्या बताने के लिए setCardinality() method का उपयोग करें।
उदाहरण के लिए, 3 values वाला field बनाने के लिए:

->setCardinality(3);

अनलिमिटेड values वाले field के लिए:

->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);

उपयोगकर्ता entity references के लिए मल्टी-वैल्यू field का उदाहरण:

$fields['my_field'] = BaseFieldDefinition::create('entity_reference')
  ->setLabel(t('The label of the field'))
  ->setDescription(t('The description of the field.'))
  ->setRevisionable(TRUE)
  ->setSetting('target_type', 'user')
  ->setSetting('handler', 'default')
  ->setTranslatable(TRUE)
  ->setDisplayOptions('view', [
    'label' => 'hidden',
    'type' => 'author',
    'weight' => 0,
  ])
  ->setDisplayOptions('form', [
    'type' => 'entity_reference_autocomplete',
    'weight' => 5,
    'settings' => [
      'match_operator' => 'CONTAINS',
      'size' => '60',
      'autocomplete_type' => 'tags',
      'placeholder' => '',
    ],
  ])
  ->setDisplayConfigurable('form', TRUE)
  ->setDisplayConfigurable('view', TRUE);
  ->setRequired(TRUE)
  ->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);

Entity कुछ फील्ड्स bundle-विशेष के लिए भी दे सकती है या bundle द्वारा संशोधित कर सकती है। उदाहरण: node का title हर bundle में अलग label रख सकता है। ऐसे मामलों में base field definition को clone करना ज़रूरी है।

use Drupal\node\Entity\NodeType;

/**
 * {@inheritdoc}
 */
public static function bundleFieldDefinitions(EntityTypeInterface $entity_type, $bundle, array $base_field_definitions) {
  $node_type = NodeType::load($bundle);
  $fields = array();
  if (isset($node_type->title_label)) {
    $fields['title'] = clone $base_field_definitions['title'];
    $fields['title']->setLabel($node_type->title_label);
  }
  return $fields;
}

फील्ड टाइप्स

Drupal core बेस फील्ड्स के लिए field types की सूची देता है। Modules अतिरिक्त field types दे सकते हैं:

string: साधारण string
boolean: boolean value, integer के रूप में
integer: integer, min/max validation settings के साथ (decimal और float भी उपलब्ध)
decimal: decimal, custom precision और scale के साथ
float: floating point number
language: language code और computed language property
timestamp: Unix timestamp
created: वर्तमान समय default मान के रूप में
changed: हर save पर auto-update
datetime: ISO 8601 string
URI: URI (Link field type भी उपलब्ध है)
uuid: auto-generated UUID
email: ईमेल, validation, widgets और formatters के साथ
entity_reference: entity reference
map: serialized string में मनचाही properties

कस्टमाइज़ेबल फील्ड्स

अतिरिक्त फील्ड्स hook_entity_base_field_info() और hook_entity_bundle_field_info() से रजिस्टर की जा सकती हैं।

use Drupal\Core\Field\BaseFieldDefinition;

/**
 * Implements hook_entity_base_field_info().
 */
function path_entity_base_field_info(EntityTypeInterface $entity_type) {
  if ($entity_type->id() === 'taxonomy_term' || $entity_type->id() === 'node') {
    $fields['path'] = BaseFieldDefinition::create('path')
      ->setLabel(t('The path alias'))
      ->setComputed(TRUE);

    return $fields;
  }
}

/**
 * Implements hook_entity_bundle_field_info().
 */
function field_entity_bundle_field_info(EntityTypeInterface $entity_type, $bundle, array $base_field_definitions) {
  if ($entity_type->isFieldable()) {
    return Field::fieldInfo()->getBundleInstances($entity_type->id(), $bundle);
  }
}

हर hook के लिए alter hooks मौजूद हैं।

स्टोरेज

अगर field का कोई खास requirement नहीं है, तो Entity Field API database storage और schema updates का ध्यान रखती है। यह default होता है जब तक field computed (setComputed(TRUE)) या custom storage (setCustomStorage(TRUE)) न हो।

उदाहरण: Node entities के लिए highlight नामक boolean field जोड़ना:

use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Field\BaseFieldDefinition;

/**
 * Implements hook_entity_base_field_info().
 */
function MYMODULE_entity_base_field_info(EntityTypeInterface $entity_type) {
  $fields = array();

  if ($entity_type->id() === 'node') {
    $fields['highlight'] = BaseFieldDefinition::create('boolean')
      ->setLabel(t('Highlight'))
      ->setDescription(t('Whether or not the node is highlighted.'))
      ->setRevisionable(TRUE)
      ->setTranslatable(TRUE)
      ->setDisplayOptions('form', array(
        'type' => 'boolean_checkbox',
        'settings' => array(
          'display_label' => TRUE,
        ),
      ))
      ->setDisplayConfigurable('form', TRUE);
  }

  return $fields;
}

update.php चलाने से नया column नहीं जुड़ सकता, लेकिन यह चलाने से हो सकता है:

\Drupal::entityTypeManager()->clearCachedDefinitions();
\Drupal::service('entity.definition_update_manager')->applyUpdates();

अपडेट: यह Drupal 8.7 में काम नहीं करेगा। यहाँ देखें

नया field storage definition स्थापित करना:

function example_update_8701() {
  $field_storage_definition = BaseFieldDefinition::create('boolean')
    ->setLabel(t('Revision translation affected'))
    ->setDescription(t('Indicates if the last edit of a translation belongs to current revision.'))
    ->setReadOnly(TRUE)
    ->setRevisionable(TRUE)
    ->setTranslatable(TRUE);

  \Drupal::entityDefinitionUpdateManager()
    ->installFieldStorageDefinition('revision_translation_affected', 'block_content', 'block_content', $field_storage_definition);
}

अगर custom module नया field जोड़ता है, तो module enable करते ही जुड़ जाएगा और uninstall करने पर हट जाएगा।

अगर module पहले से install है, तो hook_update_N लिखना होगा:

/**
 * Add in highlight field to all nodes.
 */
function MYMODULE_update_8001() {
  $entity_type = \Drupal::service('entity_type.manager')->getDefinition('node');
  \Drupal::service('entity.definition_update_manager')->updateEntityType($entity_type);
}

या

/**
 * Add 'revision_translation_affected' field to 'node' entities.
 */
function node_update_8001() {
  $storage_definition = BaseFieldDefinition::create('boolean')
      ->setLabel(t('Revision translation affected'))
      ->setDescription(t('Indicates if the last edit of a translation belongs to current revision.'))
      ->setReadOnly(TRUE)
      ->setRevisionable(TRUE)
      ->setTranslatable(TRUE);

  \Drupal::entityDefinitionUpdateManager()
    ->installFieldStorageDefinition('revision_translation_affected', 'node', 'node', $storage_definition);
}

अधिक जानकारी के लिए देखें https://www.drupal.org/node/2554097

फील्ड definitions के साथ काम करना

नोट: Complex objects को ComplexDataInterface implement करना चाहिए। Typed Data API के अनुसार complex data object में सभी typed elements properties माने जाते हैं।

// जाँचें कि entity के पास कोई खास field है या नहीं।
$entity->hasField('field_tags');

// सभी फील्ड्स और उनके definitions array में लौटाएँ।
$field_definitions = $entity->getFieldDefinitions();

// Field item properties और उनके definitions प्राप्त करें।
$property_definitions = $entity->image->getFieldDefinition()->getPropertyDefinitions();

// सिर्फ ‘alt’ property का definition।
$alt_definition = $entity->image->getFieldDefinition()->getPropertyDefinition('alt');

// Entity manager से सभी bundles के fields प्राप्त करें।
\Drupal::service('entity_field.manager')->getFieldStorageDefinitions($entity_type);

// किसी खास bundle के fields प्राप्त करें।
\Drupal::service('entity_field.manager')->getFieldDefinitions($entity_type, $bundle);

बेस फील्ड्स के लिए Widgets और Formatters

बेस फील्ड्स अपने widgets और formatters परिभाषित कर सकते हैं। इन्हें FieldDefinition class में इस प्रकार सेट किया जाता है:

use Drupal\Core\Field\BaseFieldDefinition;

// ...

$fields['title'] = BaseFieldDefinition::create('string')
  ->setLabel(t('Title'))
  ->setDescription(t('The title of this node, always treated as non-markup plain text.'))
  ->setRequired(TRUE)
  ->setTranslatable(TRUE)
  ->setSettings(array(
    'default_value' => '',
    'max_length' => 255,
  ))
  ->setDisplayOptions('view', array(
    'label' => 'hidden',
    'type' => 'string',
    'weight' => -5,
  ))
  ->setDisplayOptions('form', array(
    'type' => 'string',
    'weight' => -5,
  ))
  ->setDisplayConfigurable('form', TRUE);

यहाँ string formatter और widget का उपयोग होता है और node title का weight भी सेट किया जाता है। setDisplayConfigurable() field को UI में “Manage form display” और “Manage display” में दिखाता है, ताकि लेबल्स और order बदले जा सकें। Core में widget या उनकी settings को UI से बदलना अभी संभव नहीं है।

फील्ड को default रूप से hidden सेट करने के लिए आप setDisplayOptions() में region key को hidden कर सकते हैं।

एक्स्ट्रा ब्लॉक टाइप्स (EBT) - नया लेआउट बिल्डर अनुभव❗

❗एक्स्ट्रा पैराग्राफ टाइप्स (EPT) - नया पैराग्राफ्स अनुभव