mirror of
https://github.com/retailcrm/graphql-php.git
synced 2025-03-23 00:03:51 +03:00
7b05673d8d
This improves the overlapping fields validation performance and improves error reporting quality by separating the concepts of checking fields "within" a single collection of fields from checking fields "between" two different collections of fields. This ensures for deeply overlapping fields that nested fields are not checked against each other repeatedly. Extending this concept further, fragment spreads are no longer expanded inline before looking for conflicts, instead the fields within a fragment are compared to the fields with the selection set which contained the referencing fragment spread.
e.g.
```graphql
{
same: a
same: b
...X
}
fragment X on T {
same: c
same: d
}
```
In the above example, the initial query body is checked "within" so `a` is compared to `b`. Also, the fragment `X` is checked "within" so `c` is compared to `d`. Because of the fragment spread, the query body and fragment `X` are checked "between" so that `a` and `b` are each compared to `c` and `d`. In this trivial example, no fewer checks are performed, but in the case where fragments are referenced multiple times, this reduces the overall number of checks (regardless of memoization).
**BREAKING**: This can change the order of fields reported when a conflict arises when fragment spreads are involved. If you are checking the precise output of errors (e.g. for unit tests), you may find existing errors change from `"a" and "c" are different fields` to `"c" and "a" are different fields`.
From a perf point of view, this is fairly minor as the memoization "PairSet" was already keeping these repeated checks from consuming time, however this will reduce the number of memoized hits because of the algorithm improvement.
From an error reporting point of view, this reports nearest-common-ancestor issues when found in a fragment that comes later in the validation process. I've added a test which fails with the existing impl and now passes, as well as changed a comment.
This also fixes an error where validation issues could be missed because of an over-eager memoization. I've also modified the `PairSet` to be aware of both forms of memoization, also represented by a previously failing test.
ref: graphql/graphql-js#386
67 lines
1.7 KiB
PHP
67 lines
1.7 KiB
PHP
<?php
|
|
namespace GraphQL\Utils;
|
|
|
|
/**
|
|
* A way to keep track of pairs of things when the ordering of the pair does
|
|
* not matter. We do this by maintaining a sort of double adjacency sets.
|
|
*/
|
|
class PairSet
|
|
{
|
|
/**
|
|
* @var array
|
|
*/
|
|
private $data;
|
|
|
|
/**
|
|
* PairSet constructor.
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->data = [];
|
|
}
|
|
|
|
/**
|
|
* @param string $a
|
|
* @param string $b
|
|
* @param bool $areMutuallyExclusive
|
|
* @return bool
|
|
*/
|
|
public function has($a, $b, $areMutuallyExclusive)
|
|
{
|
|
$first = isset($this->data[$a]) ? $this->data[$a] : null;
|
|
$result = ($first && isset($first[$b])) ? $first[$b] : null;
|
|
if ($result === null) {
|
|
return false;
|
|
}
|
|
// areMutuallyExclusive being false is a superset of being true,
|
|
// hence if we want to know if this PairSet "has" these two with no
|
|
// exclusivity, we have to ensure it was added as such.
|
|
if ($areMutuallyExclusive === false) {
|
|
return $result === false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @param string $a
|
|
* @param string $b
|
|
* @param bool $areMutuallyExclusive
|
|
*/
|
|
public function add($a, $b, $areMutuallyExclusive)
|
|
{
|
|
$this->pairSetAdd($a, $b, $areMutuallyExclusive);
|
|
$this->pairSetAdd($b, $a, $areMutuallyExclusive);
|
|
}
|
|
|
|
/**
|
|
* @param string $a
|
|
* @param string $b
|
|
* @param bool $areMutuallyExclusive
|
|
*/
|
|
private function pairSetAdd($a, $b, $areMutuallyExclusive)
|
|
{
|
|
$this->data[$a] = isset($this->data[$a]) ? $this->data[$a] : [];
|
|
$this->data[$a][$b] = $areMutuallyExclusive;
|
|
}
|
|
}
|