webonyx /
graphql-php
| Total Complexity | 104 |
| Total Lines | 547 |
| Duplicated Lines | 0 % |
| Coverage | 91.67% |
| Changes | 1 | ||
| Bugs | 0 | Features | 0 |
Complex classes like AST often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use AST, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 62 | class AST |
||
| 63 | { |
||
| 64 | /** |
||
| 65 | * Convert representation of AST as an associative array to instance of GraphQL\Language\AST\Node. |
||
| 66 | * |
||
| 67 | * For example: |
||
| 68 | * |
||
| 69 | * ```php |
||
| 70 | * AST::fromArray([ |
||
| 71 | * 'kind' => 'ListValue', |
||
| 72 | * 'values' => [ |
||
| 73 | * ['kind' => 'StringValue', 'value' => 'my str'], |
||
| 74 | * ['kind' => 'StringValue', 'value' => 'my other str'] |
||
| 75 | * ], |
||
| 76 | * 'loc' => ['start' => 21, 'end' => 25] |
||
| 77 | * ]); |
||
| 78 | * ``` |
||
| 79 | * |
||
| 80 | * Will produce instance of `ListValueNode` where `values` prop is a lazily-evaluated `NodeList` |
||
| 81 | * returning instances of `StringValueNode` on access. |
||
| 82 | * |
||
| 83 | * This is a reverse operation for AST::toArray($node) |
||
| 84 | * |
||
| 85 | * @param mixed[] $node |
||
| 86 | * |
||
| 87 | * @api |
||
| 88 | */ |
||
| 89 | 2 | public static function fromArray(array $node) : Node |
|
| 90 | { |
||
| 91 | 2 | if (! isset($node['kind']) || ! isset(NodeKind::$classMap[$node['kind']])) { |
|
| 92 | throw new InvariantViolation('Unexpected node structure: ' . Utils::printSafeJson($node)); |
||
| 93 | } |
||
| 94 | |||
| 95 | 2 | $kind = $node['kind'] ?? null; |
|
| 96 | 2 | $class = NodeKind::$classMap[$kind]; |
|
| 97 | 2 | $instance = new $class([]); |
|
| 98 | |||
| 99 | 2 | if (isset($node['loc'], $node['loc']['start'], $node['loc']['end'])) { |
|
| 100 | 1 | $instance->loc = Location::create($node['loc']['start'], $node['loc']['end']); |
|
| 101 | } |
||
| 102 | |||
| 103 | 2 | foreach ($node as $key => $value) { |
|
| 104 | 2 | if ($key === 'loc' || $key === 'kind') { |
|
| 105 | 2 | continue; |
|
| 106 | } |
||
| 107 | 2 | if (is_array($value)) { |
|
| 108 | 2 | if (isset($value[0]) || empty($value)) { |
|
| 109 | 2 | $value = new NodeList($value); |
|
| 110 | } else { |
||
| 111 | 2 | $value = self::fromArray($value); |
|
| 112 | } |
||
| 113 | } |
||
| 114 | 2 | $instance->{$key} = $value; |
|
| 115 | } |
||
| 116 | |||
| 117 | 2 | return $instance; |
|
| 118 | } |
||
| 119 | |||
| 120 | /** |
||
| 121 | * Convert AST node to serializable array |
||
| 122 | * |
||
| 123 | * @return mixed[] |
||
| 124 | * |
||
| 125 | * @api |
||
| 126 | */ |
||
| 127 | public static function toArray(Node $node) |
||
| 130 | } |
||
| 131 | |||
| 132 | /** |
||
| 133 | * Produces a GraphQL Value AST given a PHP value. |
||
| 134 | * |
||
| 135 | * Optionally, a GraphQL type may be provided, which will be used to |
||
| 136 | * disambiguate between value primitives. |
||
| 137 | * |
||
| 138 | * | PHP Value | GraphQL Value | |
||
| 139 | * | ------------- | -------------------- | |
||
| 140 | * | Object | Input Object | |
||
| 141 | * | Assoc Array | Input Object | |
||
| 142 | * | Array | List | |
||
| 143 | * | Boolean | Boolean | |
||
| 144 | * | String | String / Enum Value | |
||
| 145 | * | Int | Int | |
||
| 146 | * | Float | Int / Float | |
||
| 147 | * | Mixed | Enum Value | |
||
| 148 | * | null | NullValue | |
||
| 149 | * |
||
| 150 | * @param Type|mixed|null $value |
||
| 151 | * |
||
| 152 | * @return ObjectValueNode|ListValueNode|BooleanValueNode|IntValueNode|FloatValueNode|EnumValueNode|StringValueNode|NullValueNode|null |
||
| 153 | * |
||
| 154 | * @api |
||
| 155 | */ |
||
| 156 | 28 | public static function astFromValue($value, InputType $type) |
|
| 157 | { |
||
| 158 | 28 | if ($type instanceof NonNull) { |
|
| 159 | 4 | $astValue = self::astFromValue($value, $type->getWrappedType()); |
|
|
Bug
introduced
by
|
|||
| 160 | 4 | if ($astValue instanceof NullValueNode) { |
|
| 161 | 4 | return null; |
|
| 162 | } |
||
| 163 | |||
| 164 | 1 | return $astValue; |
|
| 165 | } |
||
| 166 | |||
| 167 | 28 | if ($value === null) { |
|
| 168 | 7 | return new NullValueNode([]); |
|
| 169 | } |
||
| 170 | |||
| 171 | // Convert PHP array to GraphQL list. If the GraphQLType is a list, but |
||
| 172 | // the value is not an array, convert the value using the list's item type. |
||
| 173 | 26 | if ($type instanceof ListOfType) { |
|
| 174 | 2 | $itemType = $type->getWrappedType(); |
|
| 175 | 2 | if (is_array($value) || ($value instanceof Traversable)) { |
|
| 176 | 1 | $valuesNodes = []; |
|
| 177 | 1 | foreach ($value as $item) { |
|
| 178 | 1 | $itemNode = self::astFromValue($item, $itemType); |
|
| 179 | 1 | if (! $itemNode) { |
|
| 180 | continue; |
||
| 181 | } |
||
| 182 | |||
| 183 | 1 | $valuesNodes[] = $itemNode; |
|
| 184 | } |
||
| 185 | |||
| 186 | 1 | return new ListValueNode(['values' => new NodeList($valuesNodes)]); |
|
| 187 | } |
||
| 188 | |||
| 189 | 1 | return self::astFromValue($value, $itemType); |
|
| 190 | } |
||
| 191 | |||
| 192 | // Populate the fields of the input object by creating ASTs from each value |
||
| 193 | // in the PHP object according to the fields in the input type. |
||
| 194 | 26 | if ($type instanceof InputObjectType) { |
|
| 195 | 2 | $isArray = is_array($value); |
|
| 196 | 2 | $isArrayLike = $isArray || $value instanceof ArrayAccess; |
|
| 197 | 2 | if ($value === null || (! $isArrayLike && ! is_object($value))) { |
|
| 198 | return null; |
||
| 199 | } |
||
| 200 | 2 | $fields = $type->getFields(); |
|
| 201 | 2 | $fieldNodes = []; |
|
| 202 | 2 | foreach ($fields as $fieldName => $field) { |
|
| 203 | 2 | if ($isArrayLike) { |
|
| 204 | 2 | $fieldValue = $value[$fieldName] ?? null; |
|
| 205 | } else { |
||
| 206 | 1 | $fieldValue = $value->{$fieldName} ?? null; |
|
| 207 | } |
||
| 208 | |||
| 209 | // Have to check additionally if key exists, since we differentiate between |
||
| 210 | // "no key" and "value is null": |
||
| 211 | 2 | if ($fieldValue !== null) { |
|
| 212 | 1 | $fieldExists = true; |
|
| 213 | 1 | } elseif ($isArray) { |
|
| 214 | 1 | $fieldExists = array_key_exists($fieldName, $value); |
|
| 215 | } elseif ($isArrayLike) { |
||
| 216 | $fieldExists = $value->offsetExists($fieldName); |
||
| 217 | } else { |
||
| 218 | $fieldExists = property_exists($value, $fieldName); |
||
| 219 | } |
||
| 220 | |||
| 221 | 2 | if (! $fieldExists) { |
|
| 222 | 1 | continue; |
|
| 223 | } |
||
| 224 | |||
| 225 | 2 | $fieldNode = self::astFromValue($fieldValue, $field->getType()); |
|
| 226 | |||
| 227 | 2 | if (! $fieldNode) { |
|
| 228 | continue; |
||
| 229 | } |
||
| 230 | |||
| 231 | 2 | $fieldNodes[] = new ObjectFieldNode([ |
|
| 232 | 2 | 'name' => new NameNode(['value' => $fieldName]), |
|
| 233 | 2 | 'value' => $fieldNode, |
|
| 234 | ]); |
||
| 235 | } |
||
| 236 | |||
| 237 | 2 | return new ObjectValueNode(['fields' => new NodeList($fieldNodes)]); |
|
| 238 | } |
||
| 239 | |||
| 240 | 25 | if ($type instanceof ScalarType || $type instanceof EnumType) { |
|
| 241 | // Since value is an internally represented value, it must be serialized |
||
| 242 | // to an externally represented value before converting into an AST. |
||
| 243 | try { |
||
| 244 | 25 | $serialized = $type->serialize($value); |
|
| 245 | 3 | } catch (Throwable $error) { |
|
| 246 | 3 | if ($error instanceof Error && $type instanceof EnumType) { |
|
| 247 | 1 | return null; |
|
| 248 | } |
||
| 249 | 2 | throw $error; |
|
| 250 | } |
||
| 251 | |||
| 252 | // Others serialize based on their corresponding PHP scalar types. |
||
| 253 | 23 | if (is_bool($serialized)) { |
|
| 254 | 7 | return new BooleanValueNode(['value' => $serialized]); |
|
| 255 | } |
||
| 256 | 21 | if (is_int($serialized)) { |
|
| 257 | 5 | return new IntValueNode(['value' => $serialized]); |
|
| 258 | } |
||
| 259 | 16 | if (is_float($serialized)) { |
|
| 260 | // int cast with == used for performance reasons |
||
| 261 | // phpcs:ignore |
||
| 262 | 2 | if ((int) $serialized == $serialized) { |
|
| 263 | 2 | return new IntValueNode(['value' => $serialized]); |
|
| 264 | } |
||
| 265 | |||
| 266 | 1 | return new FloatValueNode(['value' => $serialized]); |
|
| 267 | } |
||
| 268 | 15 | if (is_string($serialized)) { |
|
| 269 | // Enum types use Enum literals. |
||
| 270 | 15 | if ($type instanceof EnumType) { |
|
| 271 | 4 | return new EnumValueNode(['value' => $serialized]); |
|
| 272 | } |
||
| 273 | |||
| 274 | // ID types can use Int literals. |
||
| 275 | 13 | $asInt = (int) $serialized; |
|
| 276 | 13 | if ($type instanceof IDType && (string) $asInt === $serialized) { |
|
| 277 | 1 | return new IntValueNode(['value' => $serialized]); |
|
| 278 | } |
||
| 279 | |||
| 280 | // Use json_encode, which uses the same string encoding as GraphQL, |
||
| 281 | // then remove the quotes. |
||
| 282 | 13 | return new StringValueNode(['value' => $serialized]); |
|
| 283 | } |
||
| 284 | |||
| 285 | throw new InvariantViolation('Cannot convert value to AST: ' . Utils::printSafe($serialized)); |
||
| 286 | } |
||
| 287 | |||
| 288 | throw new Error('Unknown type: ' . Utils::printSafe($type) . '.'); |
||
| 289 | } |
||
| 290 | |||
| 291 | /** |
||
| 292 | * Produces a PHP value given a GraphQL Value AST. |
||
| 293 | * |
||
| 294 | * A GraphQL type must be provided, which will be used to interpret different |
||
| 295 | * GraphQL Value literals. |
||
| 296 | * |
||
| 297 | * Returns `null` when the value could not be validly coerced according to |
||
| 298 | * the provided type. |
||
| 299 | * |
||
| 300 | * | GraphQL Value | PHP Value | |
||
| 301 | * | -------------------- | ------------- | |
||
| 302 | * | Input Object | Assoc Array | |
||
| 303 | * | List | Array | |
||
| 304 | * | Boolean | Boolean | |
||
| 305 | * | String | String | |
||
| 306 | * | Int / Float | Int / Float | |
||
| 307 | * | Enum Value | Mixed | |
||
| 308 | * | Null Value | null | |
||
| 309 | * |
||
| 310 | * @param VariableNode|NullValueNode|IntValueNode|FloatValueNode|StringValueNode|BooleanValueNode|EnumValueNode|ListValueNode|ObjectValueNode|null $valueNode |
||
| 311 | * @param mixed[]|null $variables |
||
| 312 | * |
||
| 313 | * @return mixed[]|stdClass|null |
||
| 314 | * |
||
| 315 | * @throws Exception |
||
| 316 | * |
||
| 317 | * @api |
||
| 318 | */ |
||
| 319 | 107 | public static function valueFromAST(?ValueNode $valueNode, Type $type, ?array $variables = null) |
|
| 467 | } |
||
| 468 | |||
| 469 | /** |
||
| 470 | * Returns true if the provided valueNode is a variable which is not defined |
||
| 471 | * in the set of variables. |
||
| 472 | * |
||
| 473 | * @param VariableNode|NullValueNode|IntValueNode|FloatValueNode|StringValueNode|BooleanValueNode|EnumValueNode|ListValueNode|ObjectValueNode $valueNode |
||
| 474 | * @param mixed[] $variables |
||
| 475 | * |
||
| 476 | * @return bool |
||
| 477 | */ |
||
| 478 | 9 | private static function isMissingVariable(ValueNode $valueNode, $variables) |
|
| 479 | { |
||
| 480 | 9 | return $valueNode instanceof VariableNode && |
|
| 481 | 9 | (count($variables) === 0 || ! array_key_exists($valueNode->name->value, $variables)); |
|
| 482 | } |
||
| 483 | |||
| 484 | /** |
||
| 485 | * Produces a PHP value given a GraphQL Value AST. |
||
| 486 | * |
||
| 487 | * Unlike `valueFromAST()`, no type is provided. The resulting PHP value |
||
| 488 | * will reflect the provided GraphQL value AST. |
||
| 489 | * |
||
| 490 | * | GraphQL Value | PHP Value | |
||
| 491 | * | -------------------- | ------------- | |
||
| 492 | * | Input Object | Assoc Array | |
||
| 493 | * | List | Array | |
||
| 494 | * | Boolean | Boolean | |
||
| 495 | * | String | String | |
||
| 496 | * | Int / Float | Int / Float | |
||
| 497 | * | Enum | Mixed | |
||
| 498 | * | Null | null | |
||
| 499 | * |
||
| 500 | * @param Node $valueNode |
||
| 501 | * @param mixed[]|null $variables |
||
| 502 | * |
||
| 503 | * @return mixed |
||
| 504 | * |
||
| 505 | * @throws Exception |
||
| 506 | * |
||
| 507 | * @api |
||
| 508 | */ |
||
| 509 | 6 | public static function valueFromASTUntyped($valueNode, ?array $variables = null) |
|
| 510 | { |
||
| 511 | switch (true) { |
||
| 512 | 6 | case $valueNode instanceof NullValueNode: |
|
| 513 | 2 | return null; |
|
| 514 | 6 | case $valueNode instanceof IntValueNode: |
|
| 515 | 3 | return intval($valueNode->value, 10); |
|
| 516 | 5 | case $valueNode instanceof FloatValueNode: |
|
| 517 | 2 | return floatval($valueNode->value); |
|
| 518 | 5 | case $valueNode instanceof StringValueNode: |
|
| 519 | 5 | case $valueNode instanceof EnumValueNode: |
|
| 520 | 5 | case $valueNode instanceof BooleanValueNode: |
|
| 521 | 4 | return $valueNode->value; |
|
| 522 | 4 | case $valueNode instanceof ListValueNode: |
|
| 523 | 4 | return array_map( |
|
| 524 | static function ($node) use ($variables) { |
||
| 525 | 4 | return self::valueFromASTUntyped($node, $variables); |
|
| 526 | 4 | }, |
|
| 527 | 4 | iterator_to_array($valueNode->values) |
|
| 528 | ); |
||
| 529 | 2 | case $valueNode instanceof ObjectValueNode: |
|
| 530 | 2 | return array_combine( |
|
| 531 | 2 | array_map( |
|
| 532 | static function ($field) { |
||
| 533 | 2 | return $field->name->value; |
|
| 534 | 2 | }, |
|
| 535 | 2 | iterator_to_array($valueNode->fields) |
|
| 536 | ), |
||
| 537 | 2 | array_map( |
|
| 538 | static function ($field) use ($variables) { |
||
| 539 | 2 | return self::valueFromASTUntyped($field->value, $variables); |
|
| 540 | 2 | }, |
|
| 541 | 2 | iterator_to_array($valueNode->fields) |
|
| 542 | ) |
||
| 543 | ); |
||
| 544 | 1 | case $valueNode instanceof VariableNode: |
|
| 545 | 1 | $variableName = $valueNode->name->value; |
|
| 546 | |||
| 547 | 1 | return $variables && isset($variables[$variableName]) |
|
| 548 | 1 | ? $variables[$variableName] |
|
| 549 | 1 | : null; |
|
| 550 | } |
||
| 551 | |||
| 552 | throw new Error('Unexpected value kind: ' . $valueNode->kind . '.'); |
||
| 553 | } |
||
| 554 | |||
| 555 | /** |
||
| 556 | * Returns type definition for given AST Type node |
||
| 557 | * |
||
| 558 | * @param NamedTypeNode|ListTypeNode|NonNullTypeNode $inputTypeNode |
||
| 559 | * |
||
| 560 | * @return Type|null |
||
| 561 | * |
||
| 562 | * @throws Exception |
||
| 563 | * |
||
| 564 | * @api |
||
| 565 | */ |
||
| 566 | 349 | public static function typeFromAST(Schema $schema, $inputTypeNode) |
|
| 583 | } |
||
| 584 | |||
| 585 | /** |
||
| 586 | * Returns operation type ("query", "mutation" or "subscription") given a document and operation name |
||
| 587 | * |
||
| 588 | * @param string $operationName |
||
| 589 | * |
||
| 590 | * @return bool|string |
||
| 591 | * |
||
| 592 | * @api |
||
| 593 | */ |
||
| 594 | 23 | public static function getOperation(DocumentNode $document, $operationName = null) |
|
| 609 | } |
||
| 610 | } |
||
| 611 |
Loading history...
