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