Types of Attributes

Attributes are an important feature of Magento. Many out-of-the-box features rely on attributes heavily, and it is possible to create new attributes to implement custom functionality.

There are two primary types of attributes in Magento:

Entity-Attribute-Value Architecture

EAV attributes follow the Entity-Attribute-Value pattern, where attribute values are stored separately from the main entity table.

EAV attributes can only be applied to resource models that extend Magento\Eav\Model\Entity\AbstractEntity.

Core Entities Using EAV:

• ✅ Products - Magento\Catalog\Model\ResourceModel\Product
• ✅ Categories - Magento\Catalog\Model\ResourceModel\Category
• ✅ Customers - Magento\Customer\Model\ResourceModel\Customer
• ✅ Customer Addresses - Magento\Customer\Model\ResourceModel\Address

EAV attribute values are stored in special tables based on data type:

One of the biggest advantages of EAV attributes is automatic persistence.

<?php
// EAV attribute - automatically saved
$product->setWarrantyPeriod(12);
$product->save(); // warranty_period is automatically saved to catalog_product_entity_int

// Later, automatically loaded
$warrantyPeriod = $product->getWarrantyPeriod(); // Automatically loaded from database

EAV attributes require a DataPatch to create them.

<?php
namespace Vendor\Module\Setup\Patch\Data;

use Magento\Eav\Setup\EavSetup;
use Magento\Eav\Setup\EavSetupFactory;
use Magento\Framework\Setup\Patch\DataPatchInterface;
use Magento\Catalog\Model\Product;
use Magento\Eav\Model\Entity\Attribute\ScopedAttributeInterface;

class AddCustomAttribute implements DataPatchInterface
{
    private $eavSetupFactory;
    
    public function __construct(EavSetupFactory $eavSetupFactory)
    {
        $this->eavSetupFactory = $eavSetupFactory;
    }
    
    public function apply()
    {
        $eavSetup = $this->eavSetupFactory->create();
        
        $eavSetup->addAttribute(
            Product::ENTITY,
            'warranty_period',
            [
                'type' => 'int',
                'label' => 'Warranty Period (months)',
                'input' => 'text',
                'required' => false,
                'sort_order' => 100,
                'global' => ScopedAttributeInterface::SCOPE_STORE,
                'visible' => true,
                'searchable' => false,
                'filterable' => false,
                'comparable' => false,
                'visible_on_front' => false,
                'used_in_product_listing' => true,
                'unique' => false,
                'group' => 'General'
            ]
        );
        
        return $this;
    }
    
    public static function getDependencies()
    {
        return [];
    }
    
    public function getAliases()
    {
        return [];
    }
}

EAV attributes for products and categories support scope out of the box.

Available Scopes:

• SCOPE_GLOBAL - Same value across all websites and store views
• SCOPE_WEBSITE - Different values per website
• SCOPE_STORE - Different values per store view

<?php
use Magento\Eav\Model\Entity\Attribute\ScopedAttributeInterface;

// In DataPatch
'global' => ScopedAttributeInterface::SCOPE_STORE,  // Store view scope
'global' => ScopedAttributeInterface::SCOPE_WEBSITE, // Website scope
'global' => ScopedAttributeInterface::SCOPE_GLOBAL,  // Global scope

EAV attributes have built-in support for admin grids and forms.

// In DataPatch attribute configuration
'is_used_in_grid' => true,           // Can be used in admin grid
'is_visible_in_grid' => true,        // Visible in admin grid by default
'is_filterable_in_grid' => true,     // Can filter by this attribute in grid
'is_searchable_in_grid' => true,     // Can search by this attribute

Flexible Extension Architecture

Extension attributes provide a flexible way to extend entities with complex data types and custom storage mechanisms.

Extension attributes can be applied to:

• Data models that extend Magento\Framework\Api\AbstractExtensibleObject
• Models that extend Magento\Framework\Model\AbstractExtensibleModel

Common Extensible Entities:

• ✅ Products, Categories, Customers (API Data interfaces)
• ✅ Orders, Quotes, Invoices, Shipments
• ✅ Cart items, Quote items
• ✅ Custom entities implementing the interfaces

Unlike EAV attributes, with extension attributes the developer decides where to store the data.

Storage Options:

Extension attributes require manual implementation of save and load logic using plugins.

Example: Load Extension Attribute

<?php
namespace Vendor\Module\Plugin;

use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Api\Data\ProductExtensionFactory;
use Vendor\Module\Api\RelatedBlogPostRepositoryInterface;

class ProductRepositoryPlugin
{
    private $extensionFactory;
    private $blogPostRepository;
    
    public function __construct(
        ProductExtensionFactory $extensionFactory,
        RelatedBlogPostRepositoryInterface $blogPostRepository
    ) {
        $this->extensionFactory = $extensionFactory;
        $this->blogPostRepository = $blogPostRepository;
    }
    
    public function afterGet(
        \Magento\Catalog\Api\ProductRepositoryInterface $subject,
        ProductInterface $product
    ) {
        $extensionAttributes = $product->getExtensionAttributes();
        if ($extensionAttributes === null) {
            $extensionAttributes = $this->extensionFactory->create();
        }
        
        // Load extension attribute data from custom source
        $blogPosts = $this->blogPostRepository->getByProductId($product->getId());
        $extensionAttributes->setRelatedBlogPosts($blogPosts);
        
        $product->setExtensionAttributes($extensionAttributes);
        return $product;
    }
}

Extension attributes require an entry in etc/extension_attributes.xml.

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Api/etc/extension_attributes.xsd">
    <extension_attributes for="Magento\Catalog\Api\Data\ProductInterface">
        <!-- Simple scalar attribute -->
        <attribute code="custom_flag" type="string" />
        
        <!-- Array of objects -->
        <attribute code="related_blog_posts" type="Vendor\Module\Api\Data\BlogPostInterface[]" />
        
        <!-- Single object -->
        <attribute code="shipping_estimate" type="Vendor\Module\Api\Data\ShippingEstimateInterface" />
    </extension_attributes>
</config>

Extension attributes are automatically available in WebAPI responses as Extension Attributes.

API Response Example:

{
  "id": 123,
  "sku": "product-sku",
  "name": "Product Name",
  "custom_attributes": [
    {
      "attribute_code": "warranty_period",
      "value": "12"
    }
  ],
  "extension_attributes": {
    "custom_flag": "some_value",
    "related_blog_posts": [
      {
        "id": 1,
        "title": "Blog Post Title"
      }
    ]
  }
}

Scenario 1: Product Warranty (Use EAV)

Requirement: Add warranty period to products, different per store view, filterable in admin.

Solution: EAV attribute

• ✅ Simple integer value
• ✅ Need scope support
• ✅ Want admin grid filtering
• ✅ Automatic persistence

Scenario 2: Shipping Estimates (Use Extension)

Requirement: Add real-time shipping estimates from external API to cart items.

Solution: Extension attribute

• ✅ Complex object (carrier, cost, time)
• ✅ Computed from external API
• ✅ No database persistence needed
• ✅ WebAPI integration

Scenario 3: Custom Order Notes (Use Extension)

Requirement: Store structured internal notes about orders.

Solution: Extension attribute

• ✅ Orders don't use EAV
• ✅ Complex structure (author, timestamp, note)
• ✅ Custom table for storage
• ✅ Manual save/load control

• Add Product Attributes
• EAV and Extension Attributes
• Adding Extension Attributes to Entity
• Custom and Extension Attributes in WebAPI