GraphQL batch loading – BatchServiceContractResolverInterface, cache z tagami, N+1

Własny resolver GraphQL w Magento 2 to kilka plików konfiguracyjnych i klasa PHP – o tym pisałem już w 2020. Ale gdy resolver pojawia się w produkcji pod ruchem, zaczynają się prawdziwe problemy: N+1 queries przez zagnieżdżone pola, brak cache dla drogich operacji i trudne debugowanie. Pokazuję jak napisać resolver produkcyjnej jakości z batch loadingiem i granularnym cache.

Anatomia wolnego resolvera – N+1 w GraphQL

// Typowe zapytanie które ujawnia N+1
query {
    products(filter: { category_id: { eq: "42" } }, pageSize: 20) {
        items {
            sku
            name
            price { regularPrice { amount { value currency } } }
            # To pole wywołuje osobny resolver dla KAŻDEGO produktu z listy
            stock_summary {
                total_qty
                source_count
                is_available
            }
        }
    }
}
// 20 produktów = 1 query na listę + 20 queries na stock_summary = 21 queries
// Przy pageSize: 100 = 101 queries

<!-- etc/schema.graphqls - definicja własnego typu -->
type ProductInterface {
    stock_summary: StockSummary @resolver(class: "Vendor\\Module\\Model\\Resolver\\StockSummary")
}

type StockSummary {
    total_qty: Float
    source_count: Int
    is_available: Boolean
    sources: [SourceStock]
}

type SourceStock {
    source_code: String
    qty: Float
    status: Int
}

Naiwny resolver – rozwiązanie które nie skaluje

<?php

declare(strict_types=1);

namespace Vendor\Module\Model\Resolver;

use Magento\Framework\GraphQl\Query\ResolverInterface;

// Ten resolver generuje N+1 – osobne zapytanie dla każdego produktu
class StockSummaryNaive implements ResolverInterface
{
    public function __construct(
        private \Magento\InventoryApi\Api\GetSourceItemsBySkuInterface $getSourceItems
    ) {}

    public function resolve($field, $context, $info, ?array $value = null, ?array $args = null): array
    {
        $sku     = $value['model']->getSku();
        $sources = $this->getSourceItems->execute($sku); // <-- osobne query per produkt!

        $totalQty    = 0.0;
        $sourceCount = 0;

        foreach ($sources as $source) {
            if ($source->getStatus() === 1) {
                $totalQty += $source->getQuantity();
                $sourceCount++;
            }
        }

        return [
            'total_qty'    => $totalQty,
            'source_count' => $sourceCount,
            'is_available' => $totalQty > 0,
        ];
    }
}

Batch Loader – rozwiązanie N+1

<?php

declare(strict_types=1);

namespace Vendor\Module\Model;

use Magento\Framework\GraphQl\Query\Resolver\BatchServiceContractResolverInterface;
use Magento\Framework\GraphQl\Query\Resolver\BatchRequestItemInterface;

// BatchRequestItemInterface pozwala Magento grupować requesty
// i przekazywać je do resolvera RAZEM zamiast po jednym
class StockSummaryBatchResolver implements BatchServiceContractResolverInterface
{
    public function __construct(
        private StockSummaryService $stockService
    ) {}

    // Magento zbiera wszystkie batch requesty z jednego wykonania GraphQL
    // i przekazuje je hurtowo – jeden wywołanie zamiast N
    public function getServiceContract(): array
    {
        return [StockSummaryService::class, 'getForSkus'];
    }

    // Mapuje każdy item z batcha na parametry dla service
    public function convertToServiceArgument(BatchRequestItemInterface $request): mixed
    {
        return $request->getValue()['model']->getSku();
    }

    // Mapuje wynik z service z powrotem na konkretny item batcha
    public function convertFromServiceResult(mixed $result, BatchRequestItemInterface $request): array
    {
        $sku  = $request->getValue()['model']->getSku();
        $data = $result[$sku] ?? ['total_qty' => 0.0, 'source_count' => 0, 'is_available' => false];
        return $data;
    }
}

<?php

declare(strict_types=1);

namespace Vendor\Module\Model;

class StockSummaryService
{
    public function __construct(
        private \Magento\Framework\App\ResourceConnection $resourceConnection
    ) {}

    // Jeden wywołanie dla wszystkich SKU z batcha
    // Zamiast N zapytań – jedno z WHERE sku IN (...)
    public function getForSkus(array $skus): array
    {
        if (empty($skus)) {
            return [];
        }

        $connection = $this->resourceConnection->getConnection();

        $select = $connection->select()
            ->from(
                ['si' => $this->resourceConnection->getTableName('inventory_source_item')],
                [
                    'sku',
                    'total_qty'    => new \Zend_Db_Expr('SUM(si.quantity)'),
                    'source_count' => new \Zend_Db_Expr('COUNT(si.source_code)'),
                ]
            )
            ->where('si.sku IN (?)', $skus)
            ->where('si.status = ?', 1)
            ->group('si.sku');

        $rows   = $connection->fetchAll($select);
        $result = [];

        foreach ($rows as $row) {
            $result[$row['sku']] = [
                'total_qty'    => (float) $row['total_qty'],
                'source_count' => (int) $row['source_count'],
                'is_available' => $row['total_qty'] > 0,
            ];
        }

        // Uzupełnij brakujące SKU (produkt bez stocku)
        foreach ($skus as $sku) {
            if (!isset($result[$sku])) {
                $result[$sku] = ['total_qty' => 0.0, 'source_count' => 0, 'is_available' => false];
            }
        }

        return $result;
    }
}

Cache dla resolvera GraphQL

<?php

declare(strict_types=1);

namespace Vendor\Module\Model\Resolver;

use Magento\Framework\GraphQl\Query\ResolverInterface;

// Resolver z własnym cache – dla danych które rzadko się zmieniają
class StockSummaryWithCache implements ResolverInterface
{
    private const CACHE_TAG = 'vendor_stock_summary';
    private const CACHE_TTL = 300; // 5 minut

    public function __construct(
        private StockSummaryService $stockService,
        private \Magento\Framework\App\CacheInterface $cache,
        private \Magento\Framework\Serialize\SerializerInterface $serializer
    ) {}

    public function resolve($field, $context, $info, ?array $value = null, ?array $args = null): array
    {
        $sku      = $value['model']->getSku();
        $cacheKey = 'stock_summary_' . md5($sku);

        // Sprawdź cache
        $cached = $this->cache->load($cacheKey);
        if ($cached !== false) {
            return $this->serializer->unserialize($cached);
        }

        // Pobierz dane i zapisz w cache
        $data = $this->stockService->getForSkus([$sku])[$sku];

        $this->cache->save(
            $this->serializer->serialize($data),
            $cacheKey,
            [self::CACHE_TAG, 'sku_' . $sku],
            self::CACHE_TTL
        );

        return $data;
    }
}

// Invalidacja cache po zmianie stocku
class InvalidateStockCacheObserver implements \Magento\Framework\Event\ObserverInterface
{
    public function __construct(
        private \Magento\Framework\App\Cache\TypeListInterface $cacheTypeList
    ) {}

    public function execute(\Magento\Framework\Event\Observer $observer): void
    {
        // Wyczyść cache graphql i vendor_stock_summary po zmianie stocku
        $this->cacheTypeList->invalidate(['full_page', 'block_html']);
    }
}

Rejestracja batch resolvera w di.xml

<!-- etc/di.xml -->
<?xml version="1.0"?>
<config>
    <!-- Rejestracja batch resolvera -->
    <type name="Magento\Framework\GraphQl\Query\BatchContractResolverWrapper">
        <arguments>
            <argument name="batchResolvers" xsi:type="array">
                <item name="vendor_stock_summary" xsi:type="object">
                    Vendor\Module\Model\StockSummaryBatchResolver
                </item>
            </argument>
        </arguments>
    </type>
</config>

Porównanie wydajności – przed i po

Podsumowanie

Batch loading w resolverach GraphQL Magento 2 to standard którego nie można pominąć przy polach zagnieżdżonych. BatchServiceContractResolverInterface pozwala Magento grupować requesty i wykonywać jedno zapytanie zamiast N. Granularny cache z inwalidacją przez tagi dopełnia obraz – dane stockowe mają krótki TTL (5 minut), dane katalogowe można trzymać dłużej. Razem dają resolver który skaluje bez bólu.