Data loading workflow [DRAFT]

Workflow

1. Resolver: [FieldConfigInterface, QueryContextInterface, QueryInterface, QueryInterface]
2. Search Criteria creating [query, query parametrs, query context] => SearchCriteria
3. Data searhing [SearchCriteria] => matched identifiers
4. Data loading[query info, matched identifiers] => loaded data

Resolving

ResolverInterface - entry point from an application

interface ResolverInterface
{
    public function resolve(
        FieldConfigInterface $fieldConfig,
        QueryContextInterface $queryContext,
        QueryInterface $query,                
        array $parentResolvedValue = []
    );
}

Ideally, initialize and pass just what resolver needed

FieldConfigInterface - represents 'field' GraphQL config element

interface FieldConfigInterface 
    extends \Magento\Framework\GraphQl\Config\ConfigElementInterface

QueryContextInterface - represents query context data

interface QueryContextInterface
{
    public function getStore(): StoreInterface;    
    public function getUser(): UserInterface;
}

Open question:

1. Immutability with setExtensionAttribues (for example for collect warnings)
2. Returning whole object or just identificator (store_code, user_id)

QueryInterface - represents query structure and parameters

interface QueryInterface
{
    public function getStructure(): ResolveInfo;
    public function getArguments(): array;	
    public function getVariables(): array;
}

array $parentResolvedValue - contains values resolved by parrent resolvers

Could be used as data container between resolvers

Data searching/matching

SearchCriteriaFactoryInreface || SearchCriteriaBuilderInreface - responsible for Search Criteria creating

interface SearchCriteriaFactoryInreface
{
    public function create(
        QueryInterface $query, 
        [QueryContextInterface $queryContext]
    ): SearchCriteriaInterface;    
}

Could has state for resolving N+1 problem (descibed bellow).

DataSearchInterface - responsible for matching and searching data

interface DataSearchInterface
{
    public function search(
        SearchCriteriaInterface $searchCriteria
    ): array;    
}

Open question:

1. A format of output data
2. Work with current search API or using a lighter version
3. Covering indexes (when the index contains enough data and don't need to load data from raw source)

Data loading

DataProviderInterface - responsible for loading data from raw storage

interface DataProviderInterface
{
    public function load(
        QueryStructure $queryStructure, 
        QueryContextInterface $queryContext, 
        array $identifiers,
        array $parentResolvedValue = []
    ): DataInterface;    
}

QueryOutputProcessingInterface - responsible for processing data before output (for example set warnings to result)

interface QueryOutputProcessingInterface
{
    public function process(DataInterface $data): void;    
}

Base implementation works with \GraphQL\Executor\ExecutionResult (webonyx)

N + 1 problem

// Child resolver
$this->searchCriteriaBuilder->addFilter(...);

return $this->valueFactory->create(function () use ($query, $queryContext) {
    $searchCriteria = $this->searchCriteriaBuilder->create();
    $searchResult = $dataSearch->search($searchCriteria);
    $data = $this->dataProvider->load($query, $queryContext, $searchResult);
    return $data;
});

Improvements

• Resolver could be mutual for all queries: register 'DataSearchInterface' and DataProviderInterface per GraphQL type