graphql-persisted_queries 0.4.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12531a6f0099e3220f5ea0bf400b1ccd23f2e6f3161d91d54c05ae404d3e1532
-  data.tar.gz: 4660b422f801db343ce2f8e04ea21576ae500d7d9519f87399300e957f555160
+  metadata.gz: a54ca19186e396ff8a0148b3fc272ed6980dd62e150ca027620d51c105373cb8
+  data.tar.gz: 5c49f66f61b87648f08259fb93e3f810a656b24fdc4f6ecbcdeed5e2f2b9db8f
 SHA512:
-  metadata.gz: c2d317723d55e67aebc607624e32e7052c53f378e8dd4584d161102167f5f44c221580518ab912a88db3e8b82381455ba77b20aefce5904602159c33bd23b88c
-  data.tar.gz: b831aeb69392cdd662fcf285cc8f48051feb3cd3703db862bd4434cfdbb67acd4b85cf70ae64cbcee61f7df969cbd913c152517af4a7da2b7121ae99fd0282a4
+  metadata.gz: 36d204d8c8874a85c454a0e74884ac750b538cc993ade9e1d70b038e089934012beb515d9aa8d2fc8a5e4ed90c9a7a4e3dce975fef24919271d7472d2e158b77
+  data.tar.gz: 15f63fca919296e2bdf7624a4eaefd78a05415f17839d6ef5cd56881ba3b8c05e68f9929ccc93b0b503383226607d8dce34a8b11bb9ed99064eabb088f81c3fd

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master
 
+## 1.0.2 (2020-06-29)
+
+- [PR#35](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/35) fix args for GraphQL::Query::Result ([@ogidow ][])
+
+## 1.0.1 (2020-06-25)
+
+- [PR#34](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/34) Return GraphQL::Query::Result when raise error ([@ogidow ][])
+
+## 🥳 1.0.0 (2020-03-31)
+
+- [PR#30](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/30) **BREAKING CHANGE** Move extenstions to the query context ([@DmitryTsepelev][])
+
+## 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][])
+
 ## 0.4.0 (2020-02-26)
 
 - [PR#26](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/26) Add Memcached store ([@JanStevens][])
@@ -35,3 +55,4 @@
 [@DmitryTsepelev]: https://github.com/DmitryTsepelev
 [@bmorton]: https://github.com/bmorton
 [@JanStevens]: https://github.com/JanStevens
+[@ogidow]: https://github.com/ogidow

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,7 +33,7 @@ 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
@@ -43,170 +41,55 @@ class GraphqlSchema < GraphQL::Schema
 end
 ```
 
-4. Pass `:extensions` argument to all calls of `GraphqlSchema#execute` (start with `GraphqlController` and `GraphqlChannel`)
-
-```ruby
-GraphqlSchema.execute(
-  params[:query],
-  variables: ensure_hash(params[:variables]),
-  context: {},
-  operation_name: params[:operationName],
-  extensions: ensure_hash(params[:extensions])
-)
-```
-
-5. Run the app! 🔥
-
-## Usage with BatchLink
-
-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_:
-
-```ruby
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries, store: :redis, redis_client: { redis_url: ENV["MY_REDIS_URL"] }
-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:
+**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::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" }
+  use GraphQL::Execution::Interpreter
+  use GraphQL::Analysis::AST
+  use GraphQL::PersistedQueries
 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:
+Pass `:extensions` argument as part of a `context` to all calls of `GraphqlSchema#execute`, usually it happens in `GraphqlController`, `GraphqlChannel` and tests:
 
 ```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
+GraphqlSchema.execute(
+  params[:query],
+  variables: ensure_hash(params[:variables]),
+  context: {
+    extensions: ensure_hash(params[:extensions])
+  },
+  operation_name: params[:operationName]
+)
 ```
 
-### Supported stores
-
-We currently support a few different stores that can be configured out of the box:
+You're all set!
 
-- `: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.
+## Advanced usage
 
-## 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.:
+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
-  use GraphQL::PersistedQueries, hash_generator: proc { |_value| "super_safe_hash!!!" }
+  use GraphQL::PersistedQueries, store: :redis, redis_client: { redis_url: ENV["MY_REDIS_URL"] }
 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`.
+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).
 
-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:
+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.
 
-```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
+Since our queries are slim now, we can switch back to HTTP GET, you can find a [guide](docs/http_cache.md) here.
 
-class GraphqlSchema < GraphQL::Schema
-  use GraphQL::PersistedQueries, error_handler: GracefulRedisErrorHandler.new
-end
-```
+[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!
 
-## GET requests and HTTP cache
+[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.
 
-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).
+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).
 
-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.
+> 📖 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,49 @@
+# 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: ensure_hash(params[:variables]),
+  context: {
+    extensions: ensure_hash(params[:extensions]),
+    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/docs/tracing.md

@@ -0,0 +1,51 @@
+# Tracing
+
+Tracing is an experimental feature that, when enabled, uses the tracing system defined in `graphql-ruby` to surface these events:
+
+* `persisted_queries.fetch_query.cache_hit` - Triggered when a store adapter successfully looks up a hash and finds a query.
+* `persisted_queries.fetch_query.cache_miss` - Triggered when a store adapter attempts to look up a hash but cannot find it.
+* `persisted_queries.save_query` - Triggered when a store adapter persists a query.
+
+All events include a metadata hash as their `data` parameter.  This hash currently only includes the name of the adapter that triggered the event.
+
+## Usage
+
+Tracing must be opted into via the plugin configuration for the events to trigger.  Once they are enabled, any tracer that is defined on the schema will get the following events yielded to them.  An example configuration will look similar to this:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, tracing: true
+  tracer MyPersistedQueriesTracer
+end
+```
+
+Tracers in this plugin integrate with the `GraphQL::Tracing` feature in [`graphql-ruby`](https://github.com/rmosolgo/graphql-ruby).  The same tracers are used for tracing events directly from `graphql-ruby` and this plugin.  The [guide on "Tracing"](https://graphql-ruby.org/queries/tracing.html) in `graphql-ruby` has implementation details, but an example tracer would look similar to this:
+
+```ruby
+class MyPersistedQueriesTracer
+  def self.trace(key, data)
+    yield.tap do |result|
+      # Note: this tracer will get called for these persisted queries events as
+      # well as all events traced by the graphql-ruby gem.
+      case key
+      when "persisted_queries.fetch_query.cache_hit"
+        # data = { adapter: :redis }
+        # result = nil
+        # increment a counter metric to track cache hits
+      when "persisted_queries.fetch_query.cache_miss"
+        # data = { adapter: :redis }
+        # result = nil
+        # increment a counter metric to track cache misses
+      when "persisted_queries.save_query"
+        # data = { adapter: :redis }
+        # result = return value from method call
+        # increment a counter metric to track saved queries
+      end
+    end
+  end
+end
+```
+
+## Be aware of tracers-as-notifications
+
+A word of caution about the `cache_hit` and `cache_miss` events: they yield an empty block.  The `GraphQL::Tracing` feature typically wraps around the code performing the event.  The `save_query` event works this way, too -- the block that is yielded is essentially the `StoreAdapter#save` method.  This means you can add timing instrumentation for this call.  However, the `cache_hit` and `cache_miss` events are simply event notifications and do not wrap any code.  This means that they won't yield anything meaningful and they can't be timed.

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
@@ -21,6 +20,8 @@ module GraphQL
       error_handler = options.delete(:error_handler) || :default
       schema.configure_persisted_query_error_handler(error_handler)
 
+      schema.persisted_queries_tracing_enabled = options.delete(:tracing)
+
       store = options.delete(:store) || :memory
       schema.configure_persisted_query_store(store, options)
     end

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/multiplex_resolver.rb

@@ -29,12 +29,13 @@ module GraphQL
       end
 
       def resolve_persisted_query(query_params, pos)
-        extensions = query_params.delete(:extensions)
+        extensions = query_params.dig(:context, :extensions)
         return unless extensions
 
         query_params[:query] = Resolver.new(extensions, @schema).resolve(query_params[:query])
       rescue Resolver::NotFound, Resolver::WrongHash => e
-        results[pos] = { "errors" => [{ "message" => e.message }] }
+        values = { "errors" => [{ "message" => e.message }] }
+        results[pos] = GraphQL::Query::Result.new(query: GraphQL::Query.new(@schema, query_params[:query]), values: values)
       end
 
       def perform_multiplex

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
@@ -16,9 +17,12 @@ module GraphQL
       end
 
       attr_reader :persisted_query_store, :hash_generator_proc, :persisted_query_error_handler
+      attr_writer :persisted_queries_tracing_enabled
 
       def configure_persisted_query_store(store, options)
-        @persisted_query_store = StoreAdapters.build(store, options)
+        @persisted_query_store = StoreAdapters.build(store, options).tap do |adapter|
+          adapter.tracers = tracers if persisted_queries_tracing_enabled?
+        end
       end
 
       def configure_persisted_query_error_handler(handler)
@@ -32,18 +36,45 @@ 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
 
+      def persisted_queries_tracing_enabled?
+        @persisted_queries_tracing_enabled
+      end
+
       def multiplex(queries, **kwargs)
         MultiplexResolver.new(self, queries, kwargs).resolve
       end
+
+      def tracer(name)
+        super.tap do
+          # Since tracers can be set before *and* after our plugin hooks in,
+          # we need to set tracers both when this plugin gets initialized
+          # and any time a tracer is added after initialization
+          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/store_adapters/base_store_adapter.rb

@@ -5,15 +5,42 @@ module GraphQL
     module StoreAdapters
       # Base class for all store adapters
       class BaseStoreAdapter
-        def initialize(_options); end
+        include GraphQL::Tracing::Traceable
+        attr_writer :tracers
 
-        def fetch_query(_hash)
+        def initialize(_options)
+          @name = :base
+        end
+
+        def fetch_query(hash)
+          fetch(hash).tap do |result|
+            event = result ? "cache_hit" : "cache_miss"
+            trace("fetch_query.#{event}", adapter: @name)
+          end
+        end
+
+        def save_query(hash, query)
+          trace("save_query", adapter: @name) { save(hash, query) }
+        end
+
+        protected
+
+        def fetch(_hash)
           raise NotImplementedError
         end
 
-        def save_query(_hash, _query)
+        def save(_hash, _query)
           raise NotImplementedError
         end
+
+        def trace(key, metadata)
+          if @tracers
+            key = "persisted_queries.#{key}"
+            block_given? ? super : super {}
+          elsif block_given?
+            yield
+          end
+        end
       end
     end
   end

data/lib/graphql/persisted_queries/store_adapters/memcached_store_adapter.rb

@@ -14,13 +14,16 @@ module GraphQL
           @dalli_proc = build_dalli_proc(dalli_client)
           @expiration = expiration || DEFAULT_EXPIRATION
           @namespace = namespace || DEFAULT_NAMESPACE
+          @name = :memcached
         end
 
-        def fetch_query(hash)
+        protected
+
+        def fetch(hash)
           @dalli_proc.call { |dalli| dalli.get(key_for(hash)) }
         end
 
-        def save_query(hash, query)
+        def save(hash, query)
           @dalli_proc.call { |dalli| dalli.set(key_for(hash), query, @expiration) }
         end
 

data/lib/graphql/persisted_queries/store_adapters/memory_store_adapter.rb

@@ -7,13 +7,16 @@ module GraphQL
       class MemoryStoreAdapter < BaseStoreAdapter
         def initialize(_options)
           @storage = {}
+          @name = :memory
         end
 
-        def fetch_query(hash)
+        protected
+
+        def fetch(hash)
           @storage[hash]
         end
 
-        def save_query(hash, query)
+        def save(hash, query)
           @storage[hash] = query
         end
       end

data/lib/graphql/persisted_queries/store_adapters/redis_store_adapter.rb

@@ -14,13 +14,16 @@ module GraphQL
           @redis_proc = build_redis_proc(redis_client)
           @expiration = expiration || DEFAULT_EXPIRATION
           @namespace = namespace || DEFAULT_NAMESPACE
+          @name = :redis
         end
 
-        def fetch_query(hash)
+        protected
+
+        def fetch(hash)
           @redis_proc.call { |redis| redis.get(key_for(hash)) }
         end
 
-        def save_query(hash, query)
+        def save(hash, query)
           @redis_proc.call { |redis| redis.set(key_for(hash), query, ex: @expiration) }
         end
 

data/lib/graphql/persisted_queries/store_adapters/redis_with_local_cache_store_adapter.rb

@@ -19,9 +19,20 @@ module GraphQL
             namespace: namespace
           )
           @memory_adapter = memory_adapter_class.new(nil)
+          @name = :redis_with_local_cache
         end
 
-        def fetch_query(hash)
+        # We don't need to implement our own traces for this adapter since the
+        # underlying adapters will emit the proper events for us.  However,
+        # since tracers can be defined at any time, we need to pass them through.
+        def tracers=(tracers)
+          @memory_adapter.tracers = tracers
+          @redis_adapter.tracers = tracers
+        end
+
+        protected
+
+        def fetch(hash)
           result = @memory_adapter.fetch_query(hash)
           result ||= begin
             inner_result = @redis_adapter.fetch_query(hash)
@@ -31,7 +42,7 @@ module GraphQL
           result
         end
 
-        def save_query(hash, query)
+        def save(hash, query)
           @redis_adapter.save_query(hash, query)
           @memory_adapter.save_query(hash, query)
         end

data/lib/graphql/persisted_queries/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "0.4.0"
+    VERSION = "1.0.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.2
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-26 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -125,18 +125,25 @@ 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
 - gemfiles/graphql_1_9.gemfile
 - 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