Portiny\GraphQL\GraphQL\Schema\SchemaCacheProvider

Complexity

Total Complexity

17

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Test Coverage

Coverage

12.73%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
B	getTypeConfigDecorator()	0	46	9
A	save()	0	12	1
A	isCached()	0	3	1
A	getTypesCacheFile()	0	3	1
A	getCacheKey()	0	3	1
A	getSchema()	0	15	2
A	__construct()	0	8	1
A	getSchemaCacheFile()	0	3	1

<?php
declare(strict_types=1);

namespace Portiny\GraphQL\GraphQL\Schema;

use Closure;
use GraphQL\Language\AST\DocumentNode;
use GraphQL\Language\Parser;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Schema;
use GraphQL\Utils\AST;
use GraphQL\Utils\BuildSchema;
use GraphQL\Utils\SchemaPrinter;
use Nette\Utils\FileSystem;
use Portiny\GraphQL\Contract\Provider\MutationFieldsProviderInterface;
use Portiny\GraphQL\Contract\Provider\QueryFieldsProviderInterface;
use Portiny\GraphQL\GraphQL\Type\Types;

final class SchemaCacheProvider
{
	/**
	 * @var string
	 */
	private $cacheDir;

	/**
	 * @var QueryFieldsProviderInterface
	 */
	private $queryFieldsProvider;

	/**
	 * @var MutationFieldsProviderInterface
	 */
	private $mutationFieldsProvider;

	/**
	 * @var Schema
	 */
	private $schema;

	public function __construct(
		string $cacheDir,
		QueryFieldsProviderInterface $queryFieldsProvider,
		MutationFieldsProviderInterface $mutationFieldsProvider
	) {
		$this->cacheDir = $cacheDir;
		$this->queryFieldsProvider = $queryFieldsProvider;
		$this->mutationFieldsProvider = $mutationFieldsProvider;
	}

	public function getSchema(string $cacheKey): Schema
	{
		if ($this->schema !== null) {
			return $this->schema;
		}

		// load types from cache
		Types::loadTypesFromClasses(unserialize(FileSystem::read($this->getTypesCacheFile($cacheKey))));

		// load schema from cache
		/** @var DocumentNode $document */
		$document = AST::fromArray(require $this->getSchemaCacheFile($cacheKey));
		$this->schema = BuildSchema::build($document, $this->getTypeConfigDecorator());

		return $this->schema;
	}

	public function isCached(string $cacheKey): bool
	{
		return file_exists($this->getSchemaCacheFile($cacheKey));
	}

	public function save(string $cacheKey, Schema $schema): void
	{
		// schema cache
		$sdl = SchemaPrinter::doPrint($schema);
		$documentNode = Parser::parse($sdl);
		FileSystem::write(
			$this->getSchemaCacheFile($cacheKey),
			"<?php\nreturn " . var_export(AST::toArray($documentNode), true) . ';'
		);

		// types cache
		FileSystem::write($this->getTypesCacheFile($cacheKey), serialize(Types::getTypeClasses()));
	}

	public function getCacheKey(?array $allowedQueries = null, ?array $allowedMutations = null): string
	{
		return md5(serialize($allowedQueries) . serialize($allowedMutations));
	}

	private function getTypesCacheFile(string $cacheKey): string
	{
		return $this->cacheDir . '/types-' . $cacheKey . '.php';
	}

	private function getSchemaCacheFile(string $cacheKey): string
	{
		return $this->cacheDir . '/schema-' . $cacheKey . '.php';
	}

	private function getTypeConfigDecorator(): Closure
	{
		return function (array $typeConfig) {
			$typeConfig['resolveField'] = function ($value, $args, $context, ResolveInfo $info) use ($typeConfig) {
				$fieldName = (string) $info->fieldName;

				switch ($typeConfig['name']) {
					case 'Query':
						$queryField = $this->queryFieldsProvider->getField($fieldName);
						if ($queryField) {
							return $queryField->resolve($value, $args, $context);
						}
						break;

					case 'Mutation':
						$mutationField = $this->mutationFieldsProvider->getField($fieldName);
						if ($mutationField) {
							return $mutationField->resolve($value, $args, $context);
						}
						break;

					default:
						$type = Types::findByName($typeConfig['name']);
						if ($type instanceof ObjectType) {
							$fieldNameForResolving = $fieldName;
							if ($type->hasField($fieldNameForResolving)) {
								$typeField = $type->getField($fieldNameForResolving);
								$resolver = $typeField->resolveFn;
								if (is_callable($resolver)) {
									return $resolver($value, $args, $context, $info);
								}
							}

							$resolver = $type->resolveFieldFn;
							if (is_callable($resolver)) {
								return $resolver($value, $args, $context, $info);
							}

							return null;
						}
				}

				return null;
			};

			return $typeConfig;
		};
	}
}