include rules in the fun

Author: shmax

src/Validator/DocumentValidator.php

@@ -103,7 +103,7 @@ public static function validate(
         ?ValidationCache $cache = null
     ): array {
         if (isset($cache)) {
-            $cached = $cache->isValidated($schema, $ast);
+            $cached = $cache->isValidated($schema, $ast, $rules);
             if ($cached) {
                 return [];
             }

src/Validator/ValidationCache.php

@@ -5,6 +5,7 @@
 use GraphQL\Language\AST\DocumentNode;
 use GraphQL\Tests\PsrValidationCacheAdapter;
 use GraphQL\Type\Schema;
+use GraphQL\Validator\Rules\ValidationRule;
 
 /**
  * Implement this interface and pass an instance to GraphQL::executeQuery to enable caching of successful query validations.
@@ -17,23 +18,27 @@
 interface ValidationCache
 {
     /**
-     * Determine whether the given schema + AST pair has already been successfully validated.
+     * Determine whether the given schema/AST/rules set has already been successfully validated.
      *
      * This method should return true if the query has previously passed validation for the provided schema.
      * Only successful validations should be considered "cached" — failed validations are not cached.
      *
      * This allows for optimizations in systems where validation may not be necessary on every request.
      * For example, you can always return true for persisted queries that are known to be valid ahead of time.
      *
-     * @return bool true if validation for the given schema + AST is already known to be valid; false otherwise
+     * @param array<ValidationRule>|null $rules
+     *
+     * @return bool true if validation for the given schema + AST + rules is already known to be valid; false otherwise
      */
-    public function isValidated(Schema $schema, DocumentNode $ast): bool;
+    public function isValidated(Schema $schema, DocumentNode $ast, array $rules = null): bool;
 
     /**
+     * @param array<ValidationRule>|null $rules
+     *
      * Mark the given schema + AST pair as successfully validated.
      *
      * This is typically called after a query passes validation.
      * You should store enough information to recognize this combination on future requests.
      */
-    public function markValidated(Schema $schema, DocumentNode $ast): void;
+    public function markValidated(Schema $schema, DocumentNode $ast, array $rules = null): void;
 }

tests/Executor/TestClasses/SpyValidationCacheAdapter.php

@@ -12,14 +12,14 @@ final class SpyValidationCacheAdapter extends PsrValidationCacheAdapter
 
     public int $markValidatedCalls = 0;
 
-    public function isValidated(Schema $schema, DocumentNode $ast): bool
+    public function isValidated(Schema $schema, DocumentNode $ast, array $rules = null): bool
     {
         ++$this->isValidatedCalls;
 
         return parent::isValidated($schema, $ast);
     }
 
-    public function markValidated(Schema $schema, DocumentNode $ast): void
+    public function markValidated(Schema $schema, DocumentNode $ast, array $rules = null): void
     {
         ++$this->markValidatedCalls;
 

tests/PsrValidationCacheAdapter.php

@@ -8,6 +8,7 @@
 use GraphQL\Language\AST\DocumentNode;
 use GraphQL\Type\Schema;
 use GraphQL\Utils\SchemaPrinter;
+use GraphQL\Validator\Rules\ValidationRule;
 use GraphQL\Validator\ValidationCache;
 use Psr\SimpleCache\CacheInterface;
 use Psr\SimpleCache\InvalidArgumentException;
@@ -27,40 +28,46 @@ public function __construct(
     }
 
     /**
+     * @param array<ValidationRule>|null $rules
+     *
      * @throws \JsonException
      * @throws Error
      * @throws InvalidArgumentException&\Throwable
      * @throws InvariantViolation
      * @throws SerializationError
      */
-    public function isValidated(Schema $schema, DocumentNode $ast): bool
+    public function isValidated(Schema $schema, DocumentNode $ast, array $rules = null): bool
     {
         $key = $this->buildKey($schema, $ast);
 
         return $this->cache->has($key); // @phpstan-ignore missingType.checkedException (annotated as a union with Throwable)
     }
 
     /**
+     * @param array<ValidationRule>|null $rules
+     *
      * @throws \JsonException
      * @throws Error
      * @throws InvalidArgumentException&\Throwable
      * @throws InvariantViolation
      * @throws SerializationError
      */
-    public function markValidated(Schema $schema, DocumentNode $ast): void
+    public function markValidated(Schema $schema, DocumentNode $ast, array $rules = null): void
     {
         $key = $this->buildKey($schema, $ast);
 
         $this->cache->set($key, true, $this->ttlSeconds); // @phpstan-ignore missingType.checkedException (annotated as a union with Throwable)
     }
 
     /**
+     * @param array<ValidationRule>|null $rules
+     *
      * @throws \JsonException
      * @throws Error
      * @throws InvariantViolation
      * @throws SerializationError
      */
-    private function buildKey(Schema $schema, DocumentNode $ast): string
+    private function buildKey(Schema $schema, DocumentNode $ast, array $rules = null): string
     {
         /**
          * This default strategy generates a cache key by hashing the printed schema and AST.
@@ -69,7 +76,8 @@ private function buildKey(Schema $schema, DocumentNode $ast): string
          */
         $schemaHash = md5(SchemaPrinter::doPrint($schema));
         $astHash = md5(serialize($ast));
+        $rulesHash = md5(serialize($rules));
 
-        return "graphql_validation_{$schemaHash}_{$astHash}";
+        return "graphql_validation_{$schemaHash}_{$astHash}_$rulesHash";
     }
 }