graphql-persisted_queries 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47cee014870d4382ee5d140302c25a5942ac2e0b8ba3886577a9299e8e097e24
-  data.tar.gz: 1d0406419d6bcce3137863906d72c3d5a670cf56477c166d54b1dc182e016dfa
+  metadata.gz: 248a30a043f26aabeb1f2fb61599b7dc7479a2a90cc1890c4fd7125fb61426e4
+  data.tar.gz: 6fbb89bf490bcf11c6681cb624d9153bf7c2be2eeb5bdd486407c288056ab494
 SHA512:
-  metadata.gz: b5cf4c0e7d3021dff138122c176983edc1ebbf17ffad0327423389d354e19f6fdc1ef541be58adb5aa4d364aa0e21bf17226ede8dee47cb94f283d677dae326a
-  data.tar.gz: 10763b571169cdddd8c47c31f4a0350ee8a0a5d3aa6729f6a7669799800b3474810edecd5126c4c6f18c5cf5b52de7ac4f686c5ead9d648eb3032f8cddedbe4c
+  metadata.gz: aea67f0744376a70950feea5a331cefd279679c0bc2ed5786f2d2c3fe1a13a31ea87348213b41a0a6d94e7daf32c02cc08364869bb2a088fa0ec2a451f4be793
+  data.tar.gz: 458ff6a451faac1fff4e1ce51ad42f9b51bc975270e1666d1730549a726f145acd20ce35ed9d630d62d3ea1c9899e8809c8f755af3d3d53e44af3fe6b30a69d2

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.5.1 (2020-03-18)
+
+- [PR#33](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/33) Support AST analyzers ([@DmitryTsepelev][])
+
 ## 0.5.0 (2020-03-12)
 
 - [PR#29](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/29) Instrumentation via graphql-ruby's tracer feature ([@bmorton][])

data/README.md

@@ -14,11 +14,9 @@
   </a>
 </p>
 
-## Installation
+## Getting started
 
-1. Add the gem to your Gemfile `gem 'graphql-persisted_queries'`
-
-2. Install and configure [apollo-link-persisted-queries](https://github.com/apollographql/apollo-link-persisted-queries):
+First of all, install and configure [apollo-link-persisted-queries](https://github.com/apollographql/apollo-link-persisted-queries) on the front–end side:
 
 ```js
 import { createPersistedQueryLink } from "apollo-link-persisted-queries";
@@ -35,15 +33,25 @@ const client = new ApolloClient({
 });
 ```
 
-3. Add plugin to the schema:
+Add the gem to your Gemfile `gem 'graphql-persisted_queries'` and add the plugin to your schema class:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries
+end
+```
+
+**Heads up!** If you've already switched to interpreter mode and and AST analyzers—make sure AST plugin is added _before_ `GraphQL::PersistedQueries`:
 
 ```ruby
 class GraphqlSchema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
   use GraphQL::PersistedQueries
 end
 ```
 
-4. Pass `:extensions` argument to all calls of `GraphqlSchema#execute` (start with `GraphqlController` and `GraphqlChannel`)
+Pass `:extensions` argument to all calls of `GraphqlSchema#execute`, usually it happens in `GraphqlController`, `GraphqlChannel` and tests.
 
 ```ruby
 GraphqlSchema.execute(
@@ -55,16 +63,11 @@ GraphqlSchema.execute(
 )
 ```
 
-5. Run the app! 🔥
+You're all set!
 
-## Usage with BatchLink
+## Advanced usage
 
-It's possible to group queries using [batch-link](https://www.apollographql.com/docs/link/links/batch-http/) and send them as a single HTTP request. 
-In this case you need to use `GraphqlSchema.multiplex(queries)` instead of `#execute`. The gem supports it too, no action required!
-
-## Alternative stores
-
-All the queries are stored in memory by default, but you can easily switch to _redis_ or _memcached_:
+All the queries are stored in memory by default, but you can easily switch to another storage (e.g., _redis_:
 
 ```ruby
 class GraphqlSchema < GraphQL::Schema
@@ -72,145 +75,20 @@ class GraphqlSchema < GraphQL::Schema
 end
 ```
 
-### Redis
-
-If you have `ENV["REDIS_URL"]` configured – you don't need to pass it explicitly. Also, you can pass `:redis_host`, `:redis_port` and `:redis_db_name` 
-inside the `:redis_client` hash to build the URL from scratch or pass the configured `Redis` or `ConnectionPool` object:
-
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries,
-      store: :redis,
-      redis_client: { redis_host: "127.0.0.2", redis_port: "2214", redis_db_name: "7" }
-  # or
-  use GraphQL::PersistedQueries,
-      store: :redis,
-      redis_client: Redis.new(url: "redis://127.0.0.2:2214/7")
-  # or
-  use GraphQL::PersistedQueries,
-      store: :redis,
-      redis_client: ConnectionPool.new { Redis.new(url: "redis://127.0.0.2:2214/7") }
-end
-```
-
-You can also pass options for expiration and namespace to override the defaults:
-
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries,
-      store: :redis,
-      redis_client: { redis_url: ENV["MY_REDIS_URL"] },
-      expiration: 172800, # optional, default is 24 hours
-      namespace: "my-custom-namespace" # optional, default is "graphql-persisted-query"
-end
-```
-
-### Memcached
-
-If you have `ENV["MEMCACHE_SERVERS"]` configured - you don't need to pass it explicitly. Also, you can pass `:memcached_host` and `:memcached_port` 
-inside the `:dalli_client` hash to build the server name from scratch or pass the configured `Dalli::Client` object:
-
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries,
-      store: :memcached,
-      dalli_client: { memcached_host: "127.0.0.2", memcached_port: "11211" }
-  # or
-  use GraphQL::PersistedQueries,
-      store: :memcached,
-      dalli_client: Dalli::Client.new("127.0.0.2:11211")
-  # or
-  use GraphQL::PersistedQueries,
-      store: :memcached,
-      dalli_client: { memcached_url: "127.0.0.2:11211" }
-end
-```
-
-You can also pass options for `expiration` and `namespace` to override the defaults. 
-Any additional argument inside `dalli_client` will be forwarded to `Dalli::Client.new`. 
-Following example configures Dalli `pool_size` and `compress` options:
+We currently support `memory`, `redis`, `redis_with_local_cache` and `memcached` out of the box. The detailed documentation can be found [here](docs/alternative_stores.md).
 
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries,
-      store: :memcached,
-      dalli_client: { 
-        memcached_url: "127.0.0.2:11211", 
-        pool_size: 5,
-        compress: true
-      },
-      expiration: 172800, # optional, default is 24 hours
-      namespace: "my-custom-namespace" # optional, default is "graphql-persisted-query"
-end
-```
-
-### Supported stores
-
-We currently support a few different stores that can be configured out of the box:
-
-- `:memory`: This is the default in-memory store and is great for getting started, but will require each instance to cache results independently which can result in lots of ["new query path"](https://blog.apollographql.com/improve-graphql-performance-with-automatic-persisted-queries-c31d27b8e6ea) requests.
-- `:redis`: This store will allow you to share a Redis cache across all instances of your GraphQL application so that each instance doesn't have to ask the client for the query again if it hasn't seen it yet.
-- `:redis_with_local_cache`: This store combines both the `:memory` and `:redis` approaches so that we can reduce the number of network requests we make while mitigating the independent cache issue.  This adapter is configured identically to the `:redis` store.
-- `:memcached`: This store will allow you to share a Memcached cache across all instances of your GraphQL application. The client is implemented with the Dalli gem.
-
-## Alternative hash functions
-
-[apollo-link-persisted-queries](https://github.com/apollographql/apollo-link-persisted-queries) uses _SHA256_ by default so this gem uses it as a default too, but if you want to override it – you can use `:hash_generator` option:
-
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries, hash_generator: :md5
-end
-```
-
-If string or symbol is passed – the gem would try to find the class in the `Digest` namespace. Altenatively, you  can pass a lambda, e.g.:
-
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries, hash_generator: proc { |_value| "super_safe_hash!!!" }
-end
-```
-
-## Error handling
-
-You may optionally specify an object that will be called whenever an error occurs while attempting to resolve or save a query.  This will give you the opportunity to both handle (e.g. graceful Redis failure) and/or log the error.  By default, errors will be raised when a failure occurs within a `StoreAdapter`.
-
-An error handler can be a proc or an implementation of `GraphQL::PersistedQueries::ErrorHandlers::BaseErrorHandler`.  Here's an example for treating Redis failures as cache misses:
-
-```ruby
-class GracefulRedisErrorHandler < GraphQL::PersistedQueries::ErrorHandlers::BaseErrorHandler
-  def call(error)
-    case error
-    when Redis::BaseError
-      # Treat Redis errors as a cache miss, but you should log the error into
-      # your instrumentation framework here.
-    else
-      raise error
-    end
-
-    # Return nothing to ensure handled errors are treated as cache misses
-    return
-  end
-end
-
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries, error_handler: GracefulRedisErrorHandler.new
-end
-```
+When the error occurs, the gem tries to not interrupt the regular flow of the app (e.g., when something is wrong with the storage, it will just answer that persisted query is not found). You can add a [custom](docs/error_handling.md) error handler and try to fix the problem or just log it.
 
-## GET requests and HTTP cache
+Since our queries are slim now, we can switch back to HTTP GET, you can find a [guide](docs/http_cache.md) here.
 
-Using `GET` requests for persisted queries allows you to enable HTTP caching (e.g., turn on CDN). This is how to turn them on:
-1. Change the way link is initialized on front-end side (`createPersistedQueryLink({ useGETForHashedQueries: true })`);
-2. Register a new route `get "/graphql", to: "graphql#execute"`;
-3. Put the request object to the GraphQL context in the controller `GraphqlSchema.execute(query, variables: variables, context: { request: request })`;
-4. Turn the `verify_http_method` option on (`use GraphQL::PersistedQueries, verify_http_method: true`) to enforce using `POST` requests for performing mutations (otherwise the error `Mutations cannot be performed via HTTP GET` will be returned).
+[batch-link](https://www.apollographql.com/docs/link/links/batch-http/) allows to group queries on the client side into a single HTTP request before sending to the server. In this case you need to use `GraphqlSchema.multiplex(queries)` instead of `#execute`. The gem supports it too, no action required!
 
-HTTP method verification is important, because when mutations are allowed via `GET` requests, it's easy to perform an attack by sending the link containing mutation to a signed in user.
+[apollo-link-persisted-queries](https://github.com/apollographql/apollo-link-persisted-queries) uses _SHA256_ for building hashes by default. Check out this [guide](docs/hash.md) if you want to override this behavior.
 
-## Tracing and instrumentation
+An experimental tracing feature can be enabled by setting `tracing: true` when configuring the plugin. Read more about this feature in the [Tracing guide](docs/tracing.md).
 
-An experimental tracing feature can be enabled by setting `tracing: true` when configuring the plugin.  Read more about this feature in the [Tracing guide](docs/tracing.md).
+> 📖 Read more about the gem internals: [Persisted queries in GraphQL:
+Slim down Apollo requests to your Ruby application](https://evilmartians.com/chronicles/persisted-queries-in-graphql-slim-down-apollo-requests-to-your-ruby-application)
 
 ## Contributing
 

data/docs/alternative_stores.md

@@ -0,0 +1,80 @@
+# Alternative stores
+
+We currently support a few different stores that can be configured out of the box:
+
+- `:memory`: This is the default in-memory store and is great for getting started, but will require each instance to cache results independently which can result in lots of ["new query path"](https://blog.apollographql.com/improve-graphql-performance-with-automatic-persisted-queries-c31d27b8e6ea) requests.
+- `:redis`: This store will allow you to share a Redis cache across all instances of your GraphQL application so that each instance doesn't have to ask the client for the query again if it hasn't seen it yet.
+- `:redis_with_local_cache`: This store combines both the `:memory` and `:redis` approaches so that we can reduce the number of network requests we make while mitigating the independent cache issue.  This adapter is configured identically to the `:redis` store.
+- `:memcached`: This store will allow you to share a Memcached cache across all instances of your GraphQL application. The client is implemented with the Dalli gem.
+
+## Redis
+
+If you have `ENV["REDIS_URL"]` configured – you don't need to pass it explicitly. Also, you can pass `:redis_host`, `:redis_port` and `:redis_db_name`
+inside the `:redis_client` hash to build the URL from scratch or pass the configured `Redis` or `ConnectionPool` object:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries,
+      store: :redis,
+      redis_client: { redis_host: "127.0.0.2", redis_port: "2214", redis_db_name: "7" }
+  # or
+  use GraphQL::PersistedQueries,
+      store: :redis,
+      redis_client: Redis.new(url: "redis://127.0.0.2:2214/7")
+  # or
+  use GraphQL::PersistedQueries,
+      store: :redis,
+      redis_client: ConnectionPool.new { Redis.new(url: "redis://127.0.0.2:2214/7") }
+end
+```
+
+You can also pass options for expiration and namespace to override the defaults:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries,
+      store: :redis,
+      redis_client: { redis_url: ENV["MY_REDIS_URL"] },
+      expiration: 172800, # optional, default is 24 hours
+      namespace: "my-custom-namespace" # optional, default is "graphql-persisted-query"
+end
+```
+
+## Memcached
+
+If you have `ENV["MEMCACHE_SERVERS"]` configured - you don't need to pass it explicitly. Also, you can pass `:memcached_host` and `:memcached_port`
+inside the `:dalli_client` hash to build the server name from scratch or pass the configured `Dalli::Client` object:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries,
+      store: :memcached,
+      dalli_client: { memcached_host: "127.0.0.2", memcached_port: "11211" }
+  # or
+  use GraphQL::PersistedQueries,
+      store: :memcached,
+      dalli_client: Dalli::Client.new("127.0.0.2:11211")
+  # or
+  use GraphQL::PersistedQueries,
+      store: :memcached,
+      dalli_client: { memcached_url: "127.0.0.2:11211" }
+end
+```
+
+You can also pass options for `expiration` and `namespace` to override the defaults.
+Any additional argument inside `dalli_client` will be forwarded to `Dalli::Client.new`.
+Following example configures Dalli `pool_size` and `compress` options:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries,
+      store: :memcached,
+      dalli_client: {
+        memcached_url: "127.0.0.2:11211",
+        pool_size: 5,
+        compress: true
+      },
+      expiration: 172800, # optional, default is 24 hours
+      namespace: "my-custom-namespace" # optional, default is "graphql-persisted-query"
+end
+```

data/docs/error_handling.md

@@ -0,0 +1,26 @@
+# Error handling
+
+You may optionally specify an object that will be called whenever an error occurs while attempting to resolve or save a query.  This will give you the opportunity to both handle (e.g. graceful Redis failure) and/or log the error.  By default, errors will be raised when a failure occurs within a `StoreAdapter`.
+
+An error handler can be a proc or an implementation of `GraphQL::PersistedQueries::ErrorHandlers::BaseErrorHandler`.  Here's an example for treating Redis failures as cache misses:
+
+```ruby
+class GracefulRedisErrorHandler < GraphQL::PersistedQueries::ErrorHandlers::BaseErrorHandler
+  def call(error)
+    case error
+    when Redis::BaseError
+      # Treat Redis errors as a cache miss, but you should log the error into
+      # your instrumentation framework here.
+    else
+      raise error
+    end
+
+    # Return nothing to ensure handled errors are treated as cache misses
+    return
+  end
+end
+
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, error_handler: GracefulRedisErrorHandler.new
+end
+```

data/docs/hash.md

@@ -0,0 +1,17 @@
+# Alternative hash functions
+
+[apollo-link-persisted-queries](https://github.com/apollographql/apollo-link-persisted-queries) uses _SHA256_ by default so this gem uses it as a default too, but if you want to override it – you can use `:hash_generator` option:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, hash_generator: :md5
+end
+```
+
+If string or symbol is passed – the gem would try to find the class in the `Digest` namespace. Altenatively, you  can pass a lambda, e.g.:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, hash_generator: proc { |_value| "super_safe_hash!!!" }
+end
+```

data/docs/http_cache.md

@@ -0,0 +1,42 @@
+# GET requests and HTTP cache
+
+Using `GET` requests for persisted queries allows you to enable HTTP caching (e.g., turn on CDN).
+
+Firstly, turn on the `useGETForHashedQueries` parameter on the front-end side:
+
+```js
+import { createPersistedQueryLink } from "apollo-link-persisted-queries";
+import { createHttpLink } from "apollo-link-http";
+import { InMemoryCache } from "apollo-cache-inmemory";
+import ApolloClient from "apollo-client";
+
+
+// use this with Apollo Client
+const link = createPersistedQueryLink({ useGETForHashedQueries: true }).concat(createHttpLink({ uri: "/graphql" }));
+const client = new ApolloClient({
+  cache: new InMemoryCache(),
+  link: link,
+});
+```
+
+Register a new route in `routes.rb`:
+
+```ruby
+get "/graphql", to: "graphql#execute"
+```
+
+Put the request object to the GraphQL context everywhere you execute GraphQL queries:
+
+```ruby
+GraphqlSchema.execute(query, variables: variables, context: { request: request })
+```
+
+Turn the `verify_http_method` option when configuring the plugin to enforce using `POST` requests for performing mutations (otherwise the error `Mutations cannot be performed via HTTP GET` will be returned):
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, verify_http_method: true
+end
+```
+
+HTTP method verification is important, because when mutations are allowed via `GET` requests, it's easy to perform an attack by sending the link containing mutation to a signed in user.

data/lib/graphql/persisted_queries.rb

@@ -5,7 +5,6 @@ require "graphql/persisted_queries/schema_patch"
 require "graphql/persisted_queries/store_adapters"
 require "graphql/persisted_queries/version"
 require "graphql/persisted_queries/builder_helpers"
-require "graphql/persisted_queries/http_method_analyzer"
 
 module GraphQL
   # Plugin definition

data/lib/graphql/persisted_queries/analyzers/http_method_analyzer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module Analyzers
+      # Verifies that mutations are not executed using GET requests
+      class HttpMethodAnalyzer
+        def initial_value(query)
+          { query: query }
+        end
+
+        def call(memo, _visit_type, _irep_node)
+          memo
+        end
+
+        def final_value(memo)
+          HttpMethodValidator.new(memo[:query]).perform
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/analyzers/http_method_ast_analyzer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module Analyzers
+      # Verifies that mutations are not executed using GET requests
+      class HttpMethodAstAnalyzer < GraphQL::Analysis::AST::Analyzer
+        def initialize(query)
+          super
+          @query = query
+        end
+
+        def result
+          HttpMethodValidator.new(@query).perform
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/analyzers/http_method_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module Analyzers
+      # Verifies that mutations are not executed using GET requests
+      class HttpMethodValidator
+        def initialize(query)
+          @query = query
+        end
+
+        def perform
+          return if !@query.context[:request]&.get? || !@query.mutation?
+
+          GraphQL::AnalysisError.new("Mutations cannot be performed via HTTP GET")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/schema_patch.rb

@@ -3,6 +3,7 @@
 require "graphql/persisted_queries/hash_generator_builder"
 require "graphql/persisted_queries/resolver"
 require "graphql/persisted_queries/multiplex_resolver"
+require "graphql/persisted_queries/analyzers/http_method_validator"
 
 module GraphQL
   module PersistedQueries
@@ -35,12 +36,10 @@ module GraphQL
       def verify_http_method=(verify)
         return unless verify
 
-        analyzer = HttpMethodAnalyzer.new
-
-        if Gem::Dependency.new("graphql", ">= 1.10.0").match?("graphql", GraphQL::VERSION)
-          query_analyzer(analyzer)
+        if graphql10?
+          query_analyzer(prepare_analyzer)
         else
-          query_analyzers << analyzer
+          query_analyzers << prepare_analyzer
         end
       end
 
@@ -60,6 +59,22 @@ module GraphQL
           persisted_query_store.tracers = tracers if persisted_queries_tracing_enabled?
         end
       end
+
+      private
+
+      def graphql10?
+        Gem::Dependency.new("graphql", ">= 1.10.0").match?("graphql", GraphQL::VERSION)
+      end
+
+      def prepare_analyzer
+        if graphql10? && using_ast_analysis?
+          require "graphql/persisted_queries/analyzers/http_method_ast_analyzer"
+          Analyzers::HttpMethodAstAnalyzer
+        else
+          require "graphql/persisted_queries/analyzers/http_method_analyzer"
+          Analyzers::HttpMethodAnalyzer.new
+        end
+      end
     end
   end
 end

data/lib/graphql/persisted_queries/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "0.5.0"
+    VERSION = "0.5.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-12 00:00:00.000000000 Z
+date: 2020-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -125,6 +125,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- docs/alternative_stores.md
+- docs/error_handling.md
+- docs/hash.md
+- docs/http_cache.md
 - docs/tracing.md
 - gemfiles/graphql_1_10.gemfile
 - gemfiles/graphql_1_8.gemfile
@@ -132,12 +136,14 @@ files:
 - gemfiles/graphql_master.gemfile
 - graphql-persisted_queries.gemspec
 - lib/graphql/persisted_queries.rb
+- lib/graphql/persisted_queries/analyzers/http_method_analyzer.rb
+- lib/graphql/persisted_queries/analyzers/http_method_ast_analyzer.rb
+- lib/graphql/persisted_queries/analyzers/http_method_validator.rb
 - lib/graphql/persisted_queries/builder_helpers.rb
 - lib/graphql/persisted_queries/error_handlers.rb
 - lib/graphql/persisted_queries/error_handlers/base_error_handler.rb
 - lib/graphql/persisted_queries/error_handlers/default_error_handler.rb
 - lib/graphql/persisted_queries/hash_generator_builder.rb
-- lib/graphql/persisted_queries/http_method_analyzer.rb
 - lib/graphql/persisted_queries/multiplex_resolver.rb
 - lib/graphql/persisted_queries/resolver.rb
 - lib/graphql/persisted_queries/schema_patch.rb

data/lib/graphql/persisted_queries/http_method_analyzer.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module PersistedQueries
-    # Verifies that mutations are not executed using GET requests
-    class HttpMethodAnalyzer
-      def analyze?(query)
-        query.context[:request]
-      end
-
-      def initial_value(query)
-        {
-          get_request: query.context[:request]&.get?,
-          mutation: query.mutation?
-        }
-      end
-
-      def call(memo, _visit_type, _irep_node)
-        memo
-      end
-
-      def final_value(memo)
-        return if !memo[:get_request] || !memo[:mutation]
-
-        GraphQL::AnalysisError.new("Mutations cannot be performed via HTTP GET")
-      end
-    end
-  end
-end