Server : Apache System : Linux server2.corals.io 4.18.0-348.2.1.el8_5.x86_64 #1 SMP Mon Nov 15 09:17:08 EST 2021 x86_64 User : corals ( 1002) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system Directory : /home/corals/old/vendor/webonyx/graphql-php/src/Utils/ |
<?php declare(strict_types=1);
namespace GraphQL\Utils;
use GraphQL\Error\Error;
use GraphQL\Error\InvariantViolation;
use GraphQL\Executor\Values;
use GraphQL\Language\AST\DirectiveDefinitionNode;
use GraphQL\Language\AST\EnumTypeDefinitionNode;
use GraphQL\Language\AST\EnumTypeExtensionNode;
use GraphQL\Language\AST\EnumValueDefinitionNode;
use GraphQL\Language\AST\FieldDefinitionNode;
use GraphQL\Language\AST\InputObjectTypeDefinitionNode;
use GraphQL\Language\AST\InputObjectTypeExtensionNode;
use GraphQL\Language\AST\InputValueDefinitionNode;
use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
use GraphQL\Language\AST\InterfaceTypeExtensionNode;
use GraphQL\Language\AST\ListTypeNode;
use GraphQL\Language\AST\NamedTypeNode;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\NodeList;
use GraphQL\Language\AST\NonNullTypeNode;
use GraphQL\Language\AST\ObjectTypeDefinitionNode;
use GraphQL\Language\AST\ObjectTypeExtensionNode;
use GraphQL\Language\AST\ScalarTypeDefinitionNode;
use GraphQL\Language\AST\ScalarTypeExtensionNode;
use GraphQL\Language\AST\TypeDefinitionNode;
use GraphQL\Language\AST\TypeExtensionNode;
use GraphQL\Language\AST\TypeNode;
use GraphQL\Language\AST\UnionTypeDefinitionNode;
use GraphQL\Language\AST\UnionTypeExtensionNode;
use GraphQL\Type\Definition\CustomScalarType;
use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\EnumType;
use GraphQL\Type\Definition\FieldDefinition;
use GraphQL\Type\Definition\InputObjectField;
use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\InputType;
use GraphQL\Type\Definition\InterfaceType;
use GraphQL\Type\Definition\NamedType;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\OutputType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\UnionType;
/**
* @see FieldDefinition, InputObjectField
*
* @phpstan-import-type UnnamedFieldDefinitionConfig from FieldDefinition
* @phpstan-import-type InputObjectFieldConfig from InputObjectField
* @phpstan-import-type UnnamedInputObjectFieldConfig from InputObjectField
*
* @phpstan-type ResolveType callable(string, Node|null): Type&NamedType
* @phpstan-type TypeConfigDecorator callable(array<string, mixed>, Node&TypeDefinitionNode, array<string, Node&TypeDefinitionNode>): array<string, mixed>
*/
class ASTDefinitionBuilder
{
/** @var array<string, Node&TypeDefinitionNode> */
private array $typeDefinitionsMap;
/**
* @var callable
*
* @phpstan-var ResolveType
*/
private $resolveType;
/**
* @var callable|null
*
* @phpstan-var TypeConfigDecorator|null
*/
private $typeConfigDecorator;
/** @var array<string, Type&NamedType> */
private array $cache;
/** @var array<string, array<int, Node&TypeExtensionNode>> */
private array $typeExtensionsMap;
/**
* @param array<string, Node&TypeDefinitionNode> $typeDefinitionsMap
* @param array<string, array<int, Node&TypeExtensionNode>> $typeExtensionsMap
*
* @phpstan-param ResolveType $resolveType
* @phpstan-param TypeConfigDecorator|null $typeConfigDecorator
*
* @throws InvariantViolation
*/
public function __construct(
array $typeDefinitionsMap,
array $typeExtensionsMap,
callable $resolveType,
callable $typeConfigDecorator = null
) {
$this->typeDefinitionsMap = $typeDefinitionsMap;
$this->typeExtensionsMap = $typeExtensionsMap;
$this->resolveType = $resolveType;
$this->typeConfigDecorator = $typeConfigDecorator;
$this->cache = Type::builtInTypes();
}
/** @throws \Exception */
public function buildDirective(DirectiveDefinitionNode $directiveNode): Directive
{
$locations = [];
foreach ($directiveNode->locations as $location) {
$locations[] = $location->value;
}
return new Directive([
'name' => $directiveNode->name->value,
'description' => $directiveNode->description->value ?? null,
'args' => $this->makeInputValues($directiveNode->arguments),
'isRepeatable' => $directiveNode->repeatable,
'locations' => $locations,
'astNode' => $directiveNode,
]);
}
/**
* @param NodeList<InputValueDefinitionNode> $values
*
* @throws \Exception
*
* @return array<string, UnnamedInputObjectFieldConfig>
*/
private function makeInputValues(NodeList $values): array
{
/** @var array<string, UnnamedInputObjectFieldConfig> $map */
$map = [];
foreach ($values as $value) {
// Note: While this could make assertions to get the correctly typed
// value, that would throw immediately while type system validation
// with validateSchema() will produce more actionable results.
/** @var Type&InputType $type */
$type = $this->buildWrappedType($value->type);
$config = [
'name' => $value->name->value,
'type' => $type,
'description' => $value->description->value ?? null,
'deprecationReason' => $this->getDeprecationReason($value),
'astNode' => $value,
];
if ($value->defaultValue !== null) {
$config['defaultValue'] = AST::valueFromAST($value->defaultValue, $type);
}
$map[$value->name->value] = $config;
}
return $map;
}
/**
* @param array<InputObjectTypeDefinitionNode|InputObjectTypeExtensionNode> $nodes
*
* @throws \Exception
*
* @return array<string, UnnamedInputObjectFieldConfig>
*/
private function makeInputFields(array $nodes): array
{
/** @var array<int, InputValueDefinitionNode>> $fields */
$fields = [];
foreach ($nodes as $node) {
\array_push($fields, ...$node->fields);
}
return $this->makeInputValues(new NodeList($fields));
}
/**
* @param ListTypeNode|NonNullTypeNode|NamedTypeNode $typeNode
*
* @throws \Exception
* @throws \ReflectionException
* @throws Error
* @throws InvariantViolation
*/
private function buildWrappedType(TypeNode $typeNode): Type
{
if ($typeNode instanceof ListTypeNode) {
return Type::listOf($this->buildWrappedType($typeNode->type));
}
if ($typeNode instanceof NonNullTypeNode) {
// @phpstan-ignore-next-line contained type is NullableType
return Type::nonNull($this->buildWrappedType($typeNode->type));
}
return $this->buildType($typeNode);
}
/**
* @param string|(Node&NamedTypeNode)|(Node&TypeDefinitionNode) $ref
*
* @throws \Exception
* @throws \ReflectionException
* @throws Error
* @throws InvariantViolation
*
* @return Type&NamedType
*/
public function buildType($ref): Type
{
if ($ref instanceof TypeDefinitionNode) {
return $this->internalBuildType($ref->getName()->value, $ref);
}
if ($ref instanceof NamedTypeNode) {
return $this->internalBuildType($ref->name->value, $ref);
}
return $this->internalBuildType($ref);
}
/**
* Calling this method is an equivalent of `typeMap[typeName]` in `graphql-js`.
* It is legal to access a type from the map of already-built types that doesn't exist in the map.
* Since we build types lazily, and we don't have a such map of built types,
* this method provides a way to build a type that may not exist in the SDL definitions and returns null instead.
*
* @throws \Exception
* @throws \ReflectionException
* @throws Error
* @throws InvariantViolation
*
* @return (Type&NamedType)|null
*/
public function maybeBuildType(string $name): ?Type
{
return isset($this->typeDefinitionsMap[$name])
? $this->buildType($name)
: null;
}
/**
* @param (Node&NamedTypeNode)|(Node&TypeDefinitionNode)|null $typeNode
*
* @throws \Exception
* @throws \ReflectionException
* @throws Error
* @throws InvariantViolation
*
* @return Type&NamedType
*/
private function internalBuildType(string $typeName, Node $typeNode = null): Type
{
if (isset($this->cache[$typeName])) {
return $this->cache[$typeName];
}
if (isset($this->typeDefinitionsMap[$typeName])) {
$type = $this->makeSchemaDef($this->typeDefinitionsMap[$typeName]);
if (isset($this->typeConfigDecorator)) {
try {
$config = ($this->typeConfigDecorator)(
$type->config,
$this->typeDefinitionsMap[$typeName],
$this->typeDefinitionsMap
);
} catch (\Throwable $e) {
$class = static::class;
throw new Error(
"Type config decorator passed to {$class} threw an error when building {$typeName} type: {$e->getMessage()}",
null,
null,
[],
null,
$e
);
}
// @phpstan-ignore-next-line should not happen, but function types are not enforced by PHP
if (! \is_array($config) || isset($config[0])) {
$class = static::class;
$notArray = Utils::printSafe($config);
throw new Error("Type config decorator passed to {$class} is expected to return an array, but got {$notArray}");
}
$type = $this->makeSchemaDefFromConfig($this->typeDefinitionsMap[$typeName], $config);
}
return $this->cache[$typeName] = $type;
}
return $this->cache[$typeName] = ($this->resolveType)($typeName, $typeNode);
}
/**
* @param TypeDefinitionNode&Node $def
*
* @throws \Exception
* @throws \ReflectionException
* @throws InvariantViolation
*
* @return CustomScalarType|EnumType|InputObjectType|InterfaceType|ObjectType|UnionType
*/
private function makeSchemaDef(Node $def): Type
{
switch (true) {
case $def instanceof ObjectTypeDefinitionNode:
return $this->makeTypeDef($def);
case $def instanceof InterfaceTypeDefinitionNode:
return $this->makeInterfaceDef($def);
case $def instanceof EnumTypeDefinitionNode:
return $this->makeEnumDef($def);
case $def instanceof UnionTypeDefinitionNode:
return $this->makeUnionDef($def);
case $def instanceof ScalarTypeDefinitionNode:
return $this->makeScalarDef($def);
default:
assert($def instanceof InputObjectTypeDefinitionNode, 'all implementations are known');
return $this->makeInputObjectDef($def);
}
}
/** @throws InvariantViolation */
private function makeTypeDef(ObjectTypeDefinitionNode $def): ObjectType
{
$name = $def->name->value;
/** @var array<int, ObjectTypeExtensionNode> $extensionASTNodes (proven by schema validation) */
$extensionASTNodes = $this->typeExtensionsMap[$name] ?? [];
$allNodes = [$def, ...$extensionASTNodes];
return new ObjectType([
'name' => $name,
'description' => $def->description->value ?? null,
'fields' => fn (): array => $this->makeFieldDefMap($allNodes),
'interfaces' => fn (): array => $this->makeImplementedInterfaces($allNodes),
'astNode' => $def,
'extensionASTNodes' => $extensionASTNodes,
]);
}
/**
* @param array<ObjectTypeDefinitionNode|ObjectTypeExtensionNode|InterfaceTypeDefinitionNode|InterfaceTypeExtensionNode> $nodes
*
* @phpstan-return array<string, UnnamedFieldDefinitionConfig>
*
* @throws \Exception
*/
private function makeFieldDefMap(array $nodes): array
{
$map = [];
foreach ($nodes as $node) {
foreach ($node->fields as $field) {
$map[$field->name->value] = $this->buildField($field);
}
}
return $map;
}
/**
* @throws \Exception
* @throws Error
*
* @return UnnamedFieldDefinitionConfig
*/
public function buildField(FieldDefinitionNode $field): array
{
// Note: While this could make assertions to get the correctly typed
// value, that would throw immediately while type system validation
// with validateSchema() will produce more actionable results.
/** @var OutputType&Type $type */
$type = $this->buildWrappedType($field->type);
return [
'type' => $type,
'description' => $field->description->value ?? null,
'args' => $this->makeInputValues($field->arguments),
'deprecationReason' => $this->getDeprecationReason($field),
'astNode' => $field,
];
}
/**
* Given a collection of directives, returns the string value for the
* deprecation reason.
*
* @param EnumValueDefinitionNode|FieldDefinitionNode|InputValueDefinitionNode $node
*
* @throws \Exception
* @throws \ReflectionException
* @throws InvariantViolation
*/
private function getDeprecationReason(Node $node): ?string
{
$deprecated = Values::getDirectiveValues(
Directive::deprecatedDirective(),
$node
);
return $deprecated['reason'] ?? null;
}
/**
* @param array<ObjectTypeDefinitionNode|ObjectTypeExtensionNode|InterfaceTypeDefinitionNode|InterfaceTypeExtensionNode> $nodes
*
* @throws \Exception
* @throws Error
* @throws InvariantViolation
*
* @return array<int, InterfaceType>
*/
private function makeImplementedInterfaces(array $nodes): array
{
// Note: While this could make early assertions to get the correctly
// typed values, that would throw immediately while type system
// validation with validateSchema() will produce more actionable results.
$interfaces = [];
foreach ($nodes as $node) {
foreach ($node->interfaces as $interface) {
$interfaces[] = $this->buildType($interface);
}
}
// @phpstan-ignore-next-line generic type will be validated during schema validation
return $interfaces;
}
/** @throws InvariantViolation */
private function makeInterfaceDef(InterfaceTypeDefinitionNode $def): InterfaceType
{
$name = $def->name->value;
/** @var array<int, InterfaceTypeExtensionNode> $extensionASTNodes (proven by schema validation) */
$extensionASTNodes = $this->typeExtensionsMap[$name] ?? [];
$allNodes = [$def, ...$extensionASTNodes];
return new InterfaceType([
'name' => $name,
'description' => $def->description->value ?? null,
'fields' => fn (): array => $this->makeFieldDefMap($allNodes),
'interfaces' => fn (): array => $this->makeImplementedInterfaces($allNodes),
'astNode' => $def,
'extensionASTNodes' => $extensionASTNodes,
]);
}
/**
* @throws \Exception
* @throws \ReflectionException
* @throws InvariantViolation
*/
private function makeEnumDef(EnumTypeDefinitionNode $def): EnumType
{
$name = $def->name->value;
/** @var array<int, EnumTypeExtensionNode> $extensionASTNodes (proven by schema validation) */
$extensionASTNodes = $this->typeExtensionsMap[$name] ?? [];
$values = [];
foreach ([$def, ...$extensionASTNodes] as $node) {
foreach ($node->values as $value) {
$values[$value->name->value] = [
'description' => $value->description->value ?? null,
'deprecationReason' => $this->getDeprecationReason($value),
'astNode' => $value,
];
}
}
return new EnumType([
'name' => $name,
'description' => $def->description->value ?? null,
'values' => $values,
'astNode' => $def,
'extensionASTNodes' => $extensionASTNodes,
]);
}
/** @throws InvariantViolation */
private function makeUnionDef(UnionTypeDefinitionNode $def): UnionType
{
$name = $def->name->value;
/** @var array<int, UnionTypeExtensionNode> $extensionASTNodes (proven by schema validation) */
$extensionASTNodes = $this->typeExtensionsMap[$name] ?? [];
return new UnionType([
'name' => $name,
'description' => $def->description->value ?? null,
// Note: While this could make assertions to get the correctly typed
// values below, that would throw immediately while type system
// validation with validateSchema() will produce more actionable results.
'types' => function () use ($def, $extensionASTNodes): array {
$types = [];
foreach ([$def, ...$extensionASTNodes] as $node) {
foreach ($node->types as $type) {
$types[] = $this->buildType($type);
}
}
/** @var array<int, ObjectType> $types */
return $types;
},
'astNode' => $def,
'extensionASTNodes' => $extensionASTNodes,
]);
}
/** @throws InvariantViolation */
private function makeScalarDef(ScalarTypeDefinitionNode $def): CustomScalarType
{
$name = $def->name->value;
/** @var array<int, ScalarTypeExtensionNode> $extensionASTNodes (proven by schema validation) */
$extensionASTNodes = $this->typeExtensionsMap[$name] ?? [];
return new CustomScalarType([
'name' => $name,
'description' => $def->description->value ?? null,
'astNode' => $def,
'extensionASTNodes' => $extensionASTNodes,
'serialize' => static fn ($value) => $value,
]);
}
/** @throws InvariantViolation */
private function makeInputObjectDef(InputObjectTypeDefinitionNode $def): InputObjectType
{
$name = $def->name->value;
/** @var array<int, InputObjectTypeExtensionNode> $extensionASTNodes (proven by schema validation) */
$extensionASTNodes = $this->typeExtensionsMap[$name] ?? [];
return new InputObjectType([
'name' => $name,
'description' => $def->description->value ?? null,
'fields' => fn (): array => $this->makeInputFields([$def, ...$extensionASTNodes]),
'astNode' => $def,
'extensionASTNodes' => $extensionASTNodes,
]);
}
/**
* @param array<string, mixed> $config
*
* @throws Error
*
* @return CustomScalarType|EnumType|InputObjectType|InterfaceType|ObjectType|UnionType
*/
private function makeSchemaDefFromConfig(Node $def, array $config): Type
{
switch (true) {
case $def instanceof ObjectTypeDefinitionNode:
// @phpstan-ignore-next-line assume the config matches
return new ObjectType($config);
case $def instanceof InterfaceTypeDefinitionNode:
// @phpstan-ignore-next-line assume the config matches
return new InterfaceType($config);
case $def instanceof EnumTypeDefinitionNode:
// @phpstan-ignore-next-line assume the config matches
return new EnumType($config);
case $def instanceof UnionTypeDefinitionNode:
// @phpstan-ignore-next-line assume the config matches
return new UnionType($config);
case $def instanceof ScalarTypeDefinitionNode:
// @phpstan-ignore-next-line assume the config matches
return new CustomScalarType($config);
case $def instanceof InputObjectTypeDefinitionNode:
// @phpstan-ignore-next-line assume the config matches
return new InputObjectType($config);
default:
throw new Error("Type kind of {$def->kind} not supported.");
}
}
/**
* @throws \Exception
*
* @return InputObjectFieldConfig
*/
public function buildInputField(InputValueDefinitionNode $value): array
{
$type = $this->buildWrappedType($value->type);
assert($type instanceof InputType, 'proven by schema validation');
$config = [
'name' => $value->name->value,
'type' => $type,
'description' => $value->description->value ?? null,
'astNode' => $value,
];
if ($value->defaultValue !== null) {
$config['defaultValue'] = AST::valueFromAST($value->defaultValue, $type);
}
return $config;
}
/**
* @throws \Exception
*
* @return array<string, mixed>
*/
public function buildEnumValue(EnumValueDefinitionNode $value): array
{
return [
'description' => $value->description->value ?? null,
'deprecationReason' => $this->getDeprecationReason($value),
'astNode' => $value,
];
}
}