files

Author: shmax

tests/Executor/ValidationWithCacheTest.php

@@ -0,0 +1,101 @@
+<?php declare(strict_types=1);
+
+namespace GraphQL\Tests\Executor;
+
+use DMS\PHPUnitExtensions\ArraySubset\ArraySubsetAsserts;
+use GraphQL\Deferred;
+use GraphQL\GraphQL;
+use GraphQL\Tests\Executor\TestClasses\Cat;
+use GraphQL\Tests\Executor\TestClasses\Dog;
+use GraphQL\Tests\PsrValidationCacheAdapter;
+use GraphQL\Type\Definition\InterfaceType;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Schema;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Psr16Cache;
+
+final class ValidationWithCacheTest extends TestCase
+{
+    use ArraySubsetAsserts;
+
+    /** @see it('isTypeOf used to resolve runtime type for Interface') */
+    public function testIsValidationCachedWithAdapter(): void
+    {
+        $cache = new PsrValidationCacheAdapter(new Psr16Cache(new ArrayAdapter()));
+
+
+
+        $petType = new InterfaceType([
+            'name' => 'Pet',
+            'fields' => [
+                'name' => ['type' => Type::string()],
+            ],
+        ]);
+
+        $DogType = new ObjectType([
+            'name' => 'Dog',
+            'interfaces' => [$petType],
+            'isTypeOf' => static fn ($obj): Deferred => new Deferred(static fn (): bool => $obj instanceof Dog),
+            'fields' => [
+                'name' => ['type' => Type::string()],
+                'woofs' => ['type' => Type::boolean()],
+            ],
+        ]);
+
+        $CatType = new ObjectType([
+            'name' => 'Cat',
+            'interfaces' => [$petType],
+            'isTypeOf' => static fn ($obj): Deferred => new Deferred(static fn (): bool => $obj instanceof Cat),
+            'fields' => [
+                'name' => ['type' => Type::string()],
+                'meows' => ['type' => Type::boolean()],
+            ],
+        ]);
+
+        $schema = new Schema([
+            'query' => new ObjectType([
+                'name' => 'Query',
+                'fields' => [
+                    'pets' => [
+                        'type' => Type::listOf($petType),
+                        'resolve' => static fn (): array => [
+                            new Dog('Odie', true),
+                            new Cat('Garfield', false),
+                        ],
+                    ],
+                ],
+            ]),
+            'types' => [$CatType, $DogType],
+        ]);
+
+        $query = '{
+          pets {
+            name
+            ... on Dog {
+              woofs
+            }
+            ... on Cat {
+              meows
+            }
+          }
+        }';
+
+        GraphQL::executeQuery( $schema, $query, null, null, null, null, null, null, $cache)->toArray();
+
+        // TODO: use a spy or something to prove that the validation only happens once
+        $result = GraphQL::executeQuery( $schema, $query, null, null, null, null, null, null, $cache)->toArray();
+
+        $expected = [
+            'data' => [
+                'pets' => [
+                    ['name' => 'Odie', 'woofs' => true],
+                    ['name' => 'Garfield', 'meows' => false],
+                ],
+            ],
+        ];
+
+        self::assertEquals($expected, $result);
+    }
+}

tests/PsrValidationCacheAdapter.php

@@ -0,0 +1,74 @@
+<?php declare(strict_types=1);
+
+namespace GraphQL\Tests;
+
+use GraphQL\Language\AST\DocumentNode;
+use GraphQL\Type\Schema;
+use GraphQL\Utils\SchemaPrinter;
+use GraphQL\Validator\ValidationCache;
+use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\String\Exception\InvalidArgumentException;
+
+/**
+ * @phpstan-type ErrorArray array{
+ *     message: string,
+ *     locations?: array<int, array{line: int, column: int}>
+ * }
+ */
+final class PsrValidationCacheAdapter implements ValidationCache
+{
+    private const KEY_PREFIX = 'gql_validation_';
+    private int $ttl;
+    private CacheInterface $cache;
+
+    public function __construct(
+        CacheInterface  $cache,
+        int $ttlSeconds = 300
+    ) {
+        $this->ttl = $ttlSeconds;
+        $this->cache = $cache;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function isValidated(Schema $schema, DocumentNode $ast): bool
+    {
+        try {
+            $key = $this->buildKey($schema, $ast);
+            /** @phpstan-ignore-next-line */
+            return $this->cache->has($key);
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function markValidated(Schema $schema, DocumentNode $ast): void
+    {
+        try {
+            $key = $this->buildKey($schema, $ast);
+            /** @phpstan-ignore-next-line */
+            $this->cache->set($key, true, $this->ttl);
+        } catch (\Throwable $e) {
+            // ignore silently
+        }
+    }
+
+    /**
+     * @throws \GraphQL\Error\Error
+     * @throws \GraphQL\Error\InvariantViolation
+     * @throws \GraphQL\Error\SerializationError
+     * @throws \JsonException
+     */
+    private function buildKey(Schema $schema, DocumentNode $ast): string
+    {
+        // NOTE: You can override this strategy if you want to make schema fingerprinting cheaper
+        $schemaHash = md5(SchemaPrinter::doPrint($schema));
+        $astHash = md5($ast->__toString());
+
+        return self::KEY_PREFIX . $schemaHash . '_' . $astHash;
+    }
+}