GraphQL Resolvers

Resolver Interface

<?php
namespace Magento\Framework\GraphQl\Resolver;

use Magento\Framework\GraphQl\Config\Element\Field;
use Magento\Framework\GraphQl\Schema\Type\ResolveInfo;

interface ResolverInterface
{
    /**
     * @param Field $field
     * @param mixed $context
     * @param ResolveInfo $info
     * @param array|null $value
     * @param array|null $args
     * @return mixed
     */
    public function resolve(
        Field $field,
        $context,
        ResolveInfo $info,
        array $value = null,
        array $args = null
    );
}

Basic Resolver

<?php
namespace Vendor\Module\GraphQl\Resolver\Query;

use Magento\Framework\GraphQl\Config\Element\Field;
use Magento\Framework\GraphQl\Schema\Type\ResolveInfo;
use Magento\Framework\GraphQl\Resolver\ResolverInterface;

class ProductResolver implements ResolverInterface
{
    public function __construct(
        private \Magento\Catalog\Api\ProductRepositoryInterface $productRepository,
    ) {
    }
    
    public function resolve(
        Field $field,
        $context,
        ResolveInfo $info,
        array $value = null,
        array $args = null
    ) {
        $sku = $args['sku'];
        
        $product = $this->productRepository->get($sku);
        
        return [
            'id' => $product->getId(),
            'name' => $product->getName(),
            'sku' => $product->getSku(),
            'price' => $product->getPrice()
        ];
    }
}

Register Resolver

<!-- etc/schema.graphqls -->
<config>
    <type name="Query">
        <field name="product"
               resolver="Vendor\Module\GraphQl\Resolver\Query\ProductResolver"
               type="Product"/>
    </type>
</config>

Collection Loading

public function resolve(
    Field $field,
    $context,
    ResolveInfo $info,
    array $value = null,
    array $args = null
) {
    $collection = $this->collectionFactory->create();
    
    // Apply filters
    if (isset($args['filter'])) {
        $this->filterApplier->applyFilters($collection, $args['filter']);
    }
    
    // Apply sorting
    if (isset($args['sort'])) {
        $this->sortApplier->applySorting($collection, $args['sort']);
    }
    
    // Apply pagination
    $pageSize = $args['pageSize'] ?? 20;
    $currentPage = $args['currentPage'] ?? 1;
    $collection->setPageSize($pageSize);
    $collection->setCurPage($currentPage);
    
    $items = [];
    foreach ($collection as $item) {
        $items[] = $this->formatItem($item);
    }
    
    return [
        'items' => $items,
        'total_count' => $collection->getSize(),
        'page_info' => [
            'page_size' => $pageSize,
            'current_page' => $currentPage
        ]
    ];
}

Repository Loading

public function resolve(
    Field $field,
    $context,
    ResolveInfo $info,
    array $value = null,
    array $args = null
) {
    try {
        $product = $this->productRepository->getById($args['id']);
        
        return [
            'id' => $product->getId(),
            'name' => $product->getName(),
            'sku' => $product->getSku()
        ];
    } catch (\Exception $e) {
        throw new \GraphQL\Error\GraphQLError(
            __('Product not found'),
            null,
            null,
            null,
            ['id' => $args['id']]
        );
    }
}

The N+1 Problem

query {
    products {
        items {
            name
            category {
                name  # N+1: Separate query for each product's category
            }
        }
    }
}

Solution: DataLoader

<?php
namespace Vendor\Module\GraphQl\DataLoader;

use GraphQL\Utils\Utils;
use Magento\Framework\GraphQl\Model\DataLoader\BatchResolverInterface;

class CategoryBatchResolver implements BatchResolverInterface
{
    public function __construct(
        private \Magento\Catalog\Model\ResourceModel\Category\CollectionFactory $collectionFactory,
    ) {
    }
    
    public function resolve(array $keys): array
    {
        $collection = $this->collectionFactory->create()
            ->addFieldToFilter('entity_id', ['in' => $keys])
            ->addFieldToSelect(['entity_id', 'name']);
        
        $categories = [];
        foreach ($collection as $category) {
            $categories[$category->getId()] = [
                'id' => $category->getId(),
                'name' => $category->getName()
            ];
        }
        
        // Return in same order as keys
        $result = [];
        foreach ($keys as $key) {
            $result[] = $categories[$key] ?? null;
        }
        
        return $result;
    }
}

Use DataLoader in Resolver

public function resolve(
    Field $field,
    $context,
    ResolveInfo $info,
    array $value = null,
    array $args = null
) {
    // Use DataLoader for related data
    return $context->categoryLoader->load($value['category_id']);
}

Benefits

• Single query for all categories
• Reduces database queries
• Improves performance

Batch Loading

<?php
namespace Vendor\Module\GraphQl\Resolver\Product;

use Magento\Framework\GraphQl\Model\DataLoader\BatchResolverInterface;

class CategoryBatchResolver implements BatchResolverInterface
{
    public function resolve(array $ids): array
    {
        // Single query for all IDs
        $collection = $this->collectionFactory->create()
            ->addFieldToFilter('entity_id', ['in' => $ids])
            ->addFieldToSelect(['entity_id', 'name', 'url_path']);
        
        $categories = [];
        foreach ($collection as $category) {
            $categories[$category->getId()] = $this->formatCategory($category);
        }
        
        // Return results in order
        return array_map(fn($id) => $categories[$id] ?? null, $ids);
    }
}

Query Complexity Analysis

<?php
namespace Vendor\Module\GraphQl\Model\Query\Complexity;

use Magento\Framework\GraphQl\Model\Query\Complexity\AbstractComplexity;

class ProductComplexity extends AbstractComplexity
{
    public function getComplexity(
        Field $field,
        $childComplexity
    ): int {
        return 10 + $childComplexity;
    }
}

Query Depth Limiting

<!-- etc/graphQl.xml -->
<config>
    <type name="Magento\Framework\GraphQl\Model\Query\Validator">
        <arguments>
            <argument name="validators" xsi:type="array">
                <item name="depth_limit" xsi:type="object">
                    Magento\Framework\GraphQl\Model\Query\Validator\DepthLimit
                </item>
            </argument>
        </arguments>
    </type>
</config>

Performance Tips

1. Use DataLoader for related entities
2. Batch database queries instead of individual
3. Limit query depth to prevent abuse
4. Implement caching for frequently accessed data
5. Use indexed fields in filters