graphql-persisted_queries 1.1.0 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1f6baed9c4dff3350c9f18ae31670f00e03638078ea594bb78bccfecc527958
-  data.tar.gz: a5cb83ff41381f884a98449616a3c261b4edae707c474d395336b4ca05e4af12
+  metadata.gz: 49c69f6c97fdc5fa85c34915dc2f214fc38d5cbc0c22051cac9c3c2eecce27e3
+  data.tar.gz: c0579d6c06361875fe255c96eae906a9317a6f993fbefd637ac181c2dc985fac
 SHA512:
-  metadata.gz: 9210b187e0d597400a88fcc00bda7a484654436c617f8a1a228b6e8985c51a448db6e06be0a70d4f153a7d3223606c7c4afd648aa4c591b2cbe7189a1fe358fd
-  data.tar.gz: 9613679d98d1747482822749bcda81595262dae17bfc5b148a758a946f4c3e4b75ff5c8428b895bd81d720eaa7ba48c5e01273dd4fa6045a8717b56ac714afe9
+  metadata.gz: 61a3c88f6f03ccfd956d50ccd49dca4a9f2b51f13fb45672f226b8b112401944f14f974f692a3dd60b120d9bc6903efe017b9f5be62ec9f0a5d17919f0f881d9
+  data.tar.gz: 5b9f8cac85ee76c5091e3d6ae87c58ee45cc1048831c480b2a06edc84a26aa8432030da2318a50c0b72f630fa12db6c05a16751121e1f741d1ed9b44b25d4297

data/.github/workflows/rspec.yml

@@ -20,9 +20,10 @@ jobs:
       matrix:
         ruby: [2.3, 2.4, 2.5, 2.6, 2.7]
         gemfile: [
-          "gemfiles/graphql_1_8.gemfile",
-          "gemfiles/graphql_1_9.gemfile",
           "gemfiles/graphql_1_10.gemfile",
+          "gemfiles/graphql_1_11.gemfile",
+          "gemfiles/graphql_1_12_0.gemfile",
+          "gemfiles/graphql_1_12_4.gemfile",
           "gemfiles/graphql_master.gemfile"
         ]
 
@@ -49,4 +50,4 @@ jobs:
         bundle update
     - name: Run RSpec
       run: |
-        bundle exec rake spec
+        bundle exec rake ci_specs

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## master
 
+## 1.2.3 (2021-05-14)
+
+- [PR#49](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/49) Allow nil redis_client with ENV["REDIS_URL"] ([@louim][])
+
+## 1.2.2 (2021-04-21)
+
+- [PR#47](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/47) Properly initialize memory adapter inside RedisWithLocalCacheStoreAdapter ([@DmitryTsepelev][])
+
+## 1.2.1 (2021-03-07)
+
+- [PR#43](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/43) Properly handle configuration when schema is inherited ([@DmitryTsepelev][])
+- [PR#44](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/44) Deprecate graphql-ruby 1.8 and 1.9  ([@DmitryTsepelev][])
+
+## 1.2.0 (2021-02-24)
+
+- [PR#39](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/39) Implement compiled queries  ([@DmitryTsepelev][])
+
+## 1.1.1 (2020-12-03)
+
+- [PR#37](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/37) Fix deprecation warnings ([@rbviz][])
+
 ## 1.1.0 (2020-11-16)
 
 - [PR#36](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/36) Support Ruby 2.7.0 ([@DmitryTsepelev][])
@@ -60,3 +81,5 @@
 [@bmorton]: https://github.com/bmorton
 [@JanStevens]: https://github.com/JanStevens
 [@ogidow]: https://github.com/ogidow
+[@rbviz]: https://github.com/rbviz
+[@louim]: https://github.com/louim

data/README.md

@@ -1,6 +1,6 @@
 # GraphQL::PersistedQueries
 
-`GraphQL::PersistedQueries` is the implementation of [persisted queries](https://github.com/apollographql/apollo-link-persisted-queries) for [graphql-ruby](https://github.com/rmosolgo/graphql-ruby). With this plugin your backend will cache all the queries, while frontend will send the full query only when it's not found at the backend storage.
+`GraphQL::PersistedQueries` is the implementation of [persisted queries](https://www.apollographql.com/docs/react/api/link/persisted-queries/) for [graphql-ruby](https://github.com/rmosolgo/graphql-ruby). With this plugin your backend will cache all the queries, while frontend will send the full query only when it's not found at the backend storage.
 
 - 🗑**Heavy query parameter will be omitted in most of cases** – network requests will become less heavy
 - 🤝**Clients share cached queries** – it's enough to miss cache only once for each unique query
@@ -15,20 +15,18 @@
 
 ## Getting started
 
-First of all, install and configure [apollo-link-persisted-queries](https://github.com/apollographql/apollo-link-persisted-queries) on the front–end side:
+First of all, install and configure [apollo's persisted queries](https://www.apollographql.com/docs/react/api/link/persisted-queries/) 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";
+import { HttpLink, InMemoryCache, ApolloClient } from "@apollo/client";
+import { createPersistedQueryLink } from "@apollo/client/link/persisted-queries";
+import { sha256 } from 'crypto-hash';
 
-
-// use this with Apollo Client
-const link = createPersistedQueryLink().concat(createHttpLink({ uri: "/graphql" }));
+const httpLink = new HttpLink({ uri: "/graphql" });
+const persistedQueriesLink = createPersistedQueryLink({ sha256 });
 const client = new ApolloClient({
   cache: new InMemoryCache(),
-  link: link,
+  link: persistedQueriesLink.concat(httpLink);
 });
 ```
 
@@ -65,6 +63,20 @@ GraphqlSchema.execute(
 
 You're all set!
 
+## Compiled queries (increases performance up to 2x!)
+
+When query arrives to the backend, GraphQL execution engine needs some time to _parse_ it and build the AST. In case of a huge query it might take [a lot](https://gist.github.com/DmitryTsepelev/36e290cf64b4ec0b18294d0a57fb26ff#file-1_result-md) of time. What if we cache the AST instead of a query text and skip parsing completely? The only thing you need to do is to turn `:compiled_queries` option on:
+
+```ruby
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, compiled_queries: true
+end
+```
+
+Using this option might make your endpoint up to 2x faster according to the [benchmark](docs/compiled_queries_benchmark.md).
+
+**Heads up!** This feature only works on `graphql-ruby` 1.12.0 or later, but I guess it might be backported.
+
 ## Advanced usage
 
 All the queries are stored in memory by default, but you can easily switch to another storage (e.g., _redis_:
@@ -81,9 +93,9 @@ When the error occurs, the gem tries to not interrupt the regular flow of the ap
 
 Since our queries are slim now, we can switch back to HTTP GET, you can find a [guide](docs/http_cache.md) here.
 
-[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!
+[batch-link](https://www.apollographql.com/docs/react/api/link/apollo-link-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!
 
-[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.
+[persisted-queries-link](https://www.apollographql.com/docs/react/api/link/persisted-queries/) uses _SHA256_ for building hashes by default. Check out this [guide](docs/hash.md) if you want to override this behavior.
 
 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).
 

data/Rakefile

@@ -5,4 +5,32 @@ require "rubocop/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new
 
-task default: [:rubocop, :spec]
+desc "Run specs for compiled queries"
+RSpec::Core::RakeTask.new("spec:compiled_queries") do |task|
+  task.pattern = "**/compiled_queries/**"
+  task.verbose = false
+end
+
+RSpec::Core::RakeTask.new("spec:without_compiled_queries") do |task|
+  task.exclude_pattern = "**/compiled_queries/**"
+  task.verbose = false
+end
+
+task ci_specs: ["spec:without_compiled_queries", "spec:compiled_queries"]
+
+task :bench_gql do
+  cmd = %w[bundle exec ruby benchmark/plain_gql.rb]
+  system(*cmd)
+end
+
+task :bench_pq do
+  cmd = %w[bundle exec ruby benchmark/persisted_queries.rb]
+  system(*cmd)
+end
+
+task :bench_compiled do
+  cmd = %w[bundle exec ruby benchmark/compiled_queries.rb]
+  system(*cmd)
+end
+
+task bench: [:bench_gql, :bench_pq, :bench_compiled]

data/benchmark/compiled_queries.rb

@@ -0,0 +1,41 @@
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+  gem "graphql", "1.12.4"
+end
+
+$:.push File.expand_path("../lib", __dir__)
+
+require "benchmark"
+require "graphql/persisted_queries"
+require_relative "helpers"
+
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries, compiled_queries: true
+
+  query QueryType
+end
+
+GraphqlSchema.to_definition
+
+puts
+puts "Schema with compiled queries:"
+puts
+
+Benchmark.bm(28) do |x|
+  [false, true].each do |with_nested|
+    FIELD_COUNTS.each do |field_count|
+      query = generate_query(field_count, with_nested)
+      sha256 = Digest::SHA256.hexdigest(query)
+
+      context = { extensions: { "persistedQuery" => { "sha256Hash" => sha256 } } }
+      # warmup
+      GraphqlSchema.execute(query, context: context)
+
+      x.report("#{field_count} fields#{" (nested)" if with_nested}") do
+        GraphqlSchema.execute(query, context: context)
+      end
+    end
+  end
+end

data/benchmark/helpers.rb

@@ -0,0 +1,31 @@
+FIELD_COUNTS = [10, 50, 100, 200, 300]
+
+def generate_fields(field_count, with_nested)
+  fields = field_count.times.map do |i|
+    field = "field#{i+1}"
+    field += "\s{#{generate_fields(field_count, false)}}" if with_nested
+    field
+  end
+
+  fields.join("\n")
+end
+
+def generate_query(field_count, with_nested)
+  <<-gql
+    query {
+      #{generate_fields(field_count, with_nested)}
+    }
+  gql
+end
+
+class ChildType < GraphQL::Schema::Object
+  FIELD_COUNTS.max.times do |i|
+    field "field#{i + 1}".to_sym, String, null: false, method: :itself
+  end
+end
+
+class QueryType < GraphQL::Schema::Object
+  FIELD_COUNTS.max.times do |i|
+    field "field#{i + 1}".to_sym, ChildType, null: false, method: :itself
+  end
+end

data/benchmark/persisted_queries.rb

@@ -0,0 +1,41 @@
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+  gem "graphql", "1.12.4"
+end
+
+$:.push File.expand_path("../lib", __dir__)
+
+require "benchmark"
+require "graphql/persisted_queries"
+require_relative "helpers"
+
+class GraphqlSchema < GraphQL::Schema
+  use GraphQL::PersistedQueries
+
+  query QueryType
+end
+
+GraphqlSchema.to_definition
+
+puts
+puts "Schema with persisted queries:"
+puts
+
+Benchmark.bm(28) do |x|
+  [false, true].each do |with_nested|
+    FIELD_COUNTS.each do |field_count|
+      query = generate_query(field_count, with_nested)
+      sha256 = Digest::SHA256.hexdigest(query)
+      context = { extensions: { "persistedQuery" => { "sha256Hash" => sha256 } } }
+
+      # warmup
+      GraphqlSchema.execute(query, context: context)
+
+      x.report("#{field_count} fields#{" (nested)" if with_nested}") do
+        GraphqlSchema.execute(query, context: context)
+      end
+    end
+  end
+end

data/benchmark/plain_gql.rb

@@ -0,0 +1,33 @@
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+  gem "graphql", "1.12.4"
+end
+
+$:.push File.expand_path("../lib", __dir__)
+
+require "benchmark"
+require "graphql/persisted_queries"
+require_relative "helpers"
+
+class GraphqlSchema < GraphQL::Schema
+  query QueryType
+end
+
+GraphqlSchema.to_definition
+
+puts "Plain schema:"
+puts
+
+Benchmark.bm(28) do |x|
+  [false, true].each do |with_nested|
+    FIELD_COUNTS.each do |field_count|
+      query = generate_query(field_count, with_nested)
+
+      x.report("#{field_count} fields#{" (nested)" if with_nested}") do
+        GraphqlSchema.execute(query)
+      end
+    end
+  end
+end

data/docs/alternative_stores.md

@@ -25,6 +25,9 @@ class GraphqlSchema < GraphQL::Schema
   use GraphQL::PersistedQueries,
       store: :redis,
       redis_client: ConnectionPool.new { Redis.new(url: "redis://127.0.0.2:2214/7") }
+  # or with ENV["REDIS_URL"]
+  use GraphQL::PersistedQueries,
+      store: :redis
 end
 ```
 

data/docs/compiled_queries_benchmark.md

@@ -0,0 +1,75 @@
+# Compiled queries benchmarks
+
+The name of benchmark consists of a field count and optional "nested" label. In case of non–nested one we just generate a query with that field count, e.g. `2 fields` means:
+
+```gql
+query {
+  field1
+  field2
+}
+```
+
+In case of "nested" benchmark we also put a list of fields to each top–level field, e.g. `2 fields (nested)` means:
+
+```gql
+query {
+  field1 {
+    field1
+    field2
+  }
+  field2 {
+    field1
+    field2
+  }
+}
+```
+
+Field resolver just returns a string, so real–world tests might be way slower because of IO.
+
+Here are the results:
+
+```
+Plain schema:
+
+                                   user     system      total        real
+10 fields                      0.001061   0.000039   0.001100 (  0.001114)
+50 fields                      0.001658   0.000003   0.001661 (  0.001661)
+100 fields                     0.004587   0.000026   0.004613 (  0.004614)
+200 fields                     0.006447   0.000016   0.006463 (  0.006476)
+300 fields                     0.024493   0.000073   0.024566 (  0.024614)
+10 fields (nested)             0.003061   0.000043   0.003104 (  0.003109)
+50 fields (nested)             0.056927   0.000995   0.057922 (  0.057997)
+100 fields (nested)            0.245235   0.001336   0.246571 (  0.246727)
+200 fields (nested)            0.974444   0.006531   0.980975 (  0.981810)
+300 fields (nested)            2.175855   0.012773   2.188628 (  2.190130)
+
+Schema with persisted queries:
+
+                                   user     system      total        real
+10 fields                      0.000606   0.000007   0.000613 (  0.000607)
+50 fields                      0.001855   0.000070   0.001925 (  0.001915)
+100 fields                     0.003239   0.000009   0.003248 (  0.003239)
+200 fields                     0.007542   0.000009   0.007551 (  0.007551)
+300 fields                     0.014975   0.000237   0.015212 (  0.015318)
+10 fields (nested)             0.002992   0.000068   0.003060 (  0.003049)
+50 fields (nested)             0.062314   0.000274   0.062588 (  0.062662)
+100 fields (nested)            0.256404   0.000865   0.257269 (  0.257419)
+200 fields (nested)            0.978408   0.007437   0.985845 (  0.986579)
+300 fields (nested)            2.263338   0.010994   2.274332 (  2.275967)
+
+Schema with compiled queries:
+
+                                   user     system      total        real
+10 fields                      0.000526   0.000009   0.000535 (  0.000530)
+50 fields                      0.001280   0.000012   0.001292 (  0.001280)
+100 fields                     0.002292   0.000004   0.002296 (  0.002286)
+200 fields                     0.005462   0.000001   0.005463 (  0.005463)
+300 fields                     0.014229   0.000121   0.014350 (  0.014348)
+10 fields (nested)             0.002027   0.000069   0.002096 (  0.002104)
+50 fields (nested)             0.029933   0.000087   0.030020 (  0.030040)
+100 fields (nested)            0.133933   0.000502   0.134435 (  0.134756)
+200 fields (nested)            0.495052   0.003545   0.498597 (  0.499452)
+300 fields (nested)            1.041463   0.005130   1.046593 (  1.047137)
+```
+
+Results gathered from my MacBook Pro Mid 2014 (2,5 GHz Quad-Core Intel Core i7, 16 GB 1600 MHz DDR3).

data/gemfiles/{graphql_1_8.gemfile → graphql_1_11.gemfile}

@@ -1,5 +1,5 @@
 source "https://rubygems.org"
 
-gem "graphql", "~> 1.8.0"
+gem "graphql", "~> 1.11.0"
 
 gemspec path: "../"

data/gemfiles/{graphql_1_9.gemfile → graphql_1_12_0.gemfile}

@@ -1,5 +1,5 @@
 source "https://rubygems.org"
 
-gem "graphql", "~> 1.9.0"
+gem "graphql", "~> 1.12.0"
 
 gemspec path: "../"

data/gemfiles/graphql_1_12_4.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "graphql", "~> 1.12.4"
+
+gemspec path: "../"

data/graphql-persisted_queries.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = ">= 2.3"
 
-  spec.add_dependency "graphql", ">= 1.8"
+  spec.add_dependency "graphql", ">= 1.10"
 
   spec.add_development_dependency "rspec", "~> 3.9"
   spec.add_development_dependency "rake", ">= 10.0"

data/lib/graphql/persisted_queries.rb

@@ -1,17 +1,27 @@
 # frozen_string_literal: true
 
+require "graphql/persisted_queries/resolver_helpers"
+require "graphql/persisted_queries/errors"
 require "graphql/persisted_queries/error_handlers"
 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/compiled_queries/resolver"
+require "graphql/persisted_queries/compiled_queries/multiplex_patch"
+require "graphql/persisted_queries/compiled_queries/query_patch"
+
 module GraphQL
   # Plugin definition
   module PersistedQueries
-    def self.use(schema_defn, options = {})
+    # rubocop:disable Metrics/MethodLength
+    def self.use(schema_defn, **options)
       schema = schema_defn.is_a?(Class) ? schema_defn : schema_defn.target
-      SchemaPatch.patch(schema)
+
+      compiled_queries = options.delete(:compiled_queries)
+      SchemaPatch.patch(schema, compiled_queries)
+      configure_compiled_queries if compiled_queries
 
       schema.hash_generator = options.delete(:hash_generator) || :sha256
 
@@ -23,7 +33,20 @@ module GraphQL
       schema.persisted_queries_tracing_enabled = options.delete(:tracing)
 
       store = options.delete(:store) || :memory
-      schema.configure_persisted_query_store(store, options)
+      schema.configure_persisted_query_store(store, **options)
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.configure_compiled_queries
+      if Gem::Dependency.new("graphql", "< 1.12.0").match?("graphql", GraphQL::VERSION)
+        raise ArgumentError, "compiled_queries are not supported for graphql-ruby < 1.12.0"
+      end
+
+      GraphQL::Execution::Multiplex.singleton_class.prepend(
+        GraphQL::PersistedQueries::CompiledQueries::MultiplexPatch
+      )
+
+      GraphQL::Query.prepend(GraphQL::PersistedQueries::CompiledQueries::QueryPatch)
     end
   end
 end

data/lib/graphql/persisted_queries/compiled_queries/multiplex_patch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module CompiledQueries
+      # Patches GraphQL::Execution::Multiplex to support compiled queries
+      module MultiplexPatch
+        if Gem::Dependency.new("graphql", ">= 1.12.4").match?("graphql", GraphQL::VERSION)
+          def begin_query(results, idx, query, multiplex)
+            return super unless query.persisted_query_not_found?
+
+            results[idx] = add_not_found_error(query)
+          end
+        else
+          def begin_query(query, multiplex)
+            return super unless query.persisted_query_not_found?
+
+            add_not_found_error(query)
+          end
+        end
+
+        def add_not_found_error(query)
+          query.context.errors.clear
+          query.context.errors << GraphQL::ExecutionError.new("PersistedQueryNotFound")
+          GraphQL::Execution::Multiplex::NO_OPERATION
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/compiled_queries/query_patch.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module CompiledQueries
+      # Patches GraphQL::Query to support compiled queries
+      module QueryPatch
+        def persisted_query_not_found?
+          @persisted_query_not_found
+        end
+
+        def prepare_ast
+          return super unless @context[:extensions]
+
+          @document = resolver.fetch
+          not_loaded_document = @document.nil?
+
+          @persisted_query_not_found = not_loaded_document && query_string.nil?
+
+          super.tap do
+            resolver.persist(query_string, @document) if not_loaded_document && query_string
+          end
+        end
+
+        private
+
+        def resolver
+          @resolver ||= Resolver.new(@schema, @context[:extensions])
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/compiled_queries/resolver.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module CompiledQueries
+      # Fetches and persists compiled query
+      class Resolver
+        include GraphQL::PersistedQueries::ResolverHelpers
+
+        def initialize(schema, extensions)
+          @schema = schema
+          @extensions = extensions
+        end
+
+        def fetch
+          return if hash.nil?
+
+          with_error_handling do
+            compiled_query = @schema.persisted_query_store.fetch_query(hash, compiled_query: true)
+            Marshal.load(compiled_query) if compiled_query # rubocop:disable Security/MarshalLoad
+          end
+        end
+
+        def persist(query_string, compiled_query)
+          return if hash.nil?
+
+          validate_hash!(query_string)
+
+          with_error_handling do
+            @schema.persisted_query_store.save_query(
+              hash, Marshal.dump(compiled_query), compiled_query: true
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/error_handlers.rb

@@ -7,13 +7,13 @@ module GraphQL
   module PersistedQueries
     # Contains factory methods for error handlers
     module ErrorHandlers
-      def self.build(handler, options = nil)
+      def self.build(handler, **options)
         if handler.is_a?(ErrorHandlers::BaseErrorHandler)
           handler
         elsif handler.is_a?(Proc)
           build_from_proc(handler)
         else
-          build_by_name(handler, options)
+          build_by_name(handler, **options)
         end
       end
 
@@ -25,8 +25,8 @@ module GraphQL
         proc
       end
 
-      def self.build_by_name(name, options)
-        const_get("#{BuilderHelpers.camelize(name)}ErrorHandler").new(options || {})
+      def self.build_by_name(name, **options)
+        const_get("#{BuilderHelpers.camelize(name)}ErrorHandler").new(**options)
       rescue NameError => e
         raise e.class, "Persisted query error handler for :#{name} haven't been found", e.backtrace
       end

data/lib/graphql/persisted_queries/error_handlers/base_error_handler.rb

@@ -5,7 +5,7 @@ module GraphQL
     module ErrorHandlers
       # Base class for all error handlers
       class BaseErrorHandler
-        def initialize(_options); end
+        def initialize(**_options); end
 
         def call(_error)
           raise NotImplementedError

data/lib/graphql/persisted_queries/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    # Raised when persisted query is not found in the storage
+    class NotFound < StandardError
+      def message
+        "PersistedQueryNotFound"
+      end
+    end
+
+    # Raised when provided hash is not matched with query
+    class WrongHash < StandardError
+      def message
+        "Wrong hash was passed"
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/multiplex_resolver.rb

@@ -4,7 +4,7 @@ module GraphQL
   module PersistedQueries
     # Resolves multiplex query
     class MultiplexResolver
-      def initialize(schema, queries, kwargs)
+      def initialize(schema, queries, **kwargs)
         @schema = schema
         @queries = queries
         @kwargs = kwargs
@@ -33,7 +33,7 @@ module GraphQL
         return unless extensions
 
         query_params[:query] = Resolver.new(extensions, @schema).resolve(query_params[:query])
-      rescue Resolver::NotFound, Resolver::WrongHash => e
+      rescue GraphQL::PersistedQueries::NotFound, GraphQL::PersistedQueries::WrongHash => e
         values = { "errors" => [{ "message" => e.message }] }
         query = GraphQL::Query.new(@schema, query_params[:query])
         results[pos] = GraphQL::Query::Result.new(query: query, values: values)
@@ -42,7 +42,7 @@ module GraphQL
       def perform_multiplex
         resolve_idx = (0...@queries.count).select { |i| results[i].nil? }
         multiplex_result = @schema.multiplex_original(
-          resolve_idx.map { |i| @queries.at(i) }, @kwargs
+          resolve_idx.map { |i| @queries.at(i) }, **@kwargs
         )
         resolve_idx.each_with_index { |res_i, mult_i| results[res_i] = multiplex_result[mult_i] }
       end

data/lib/graphql/persisted_queries/resolver.rb

@@ -4,54 +4,32 @@ module GraphQL
   module PersistedQueries
     # Fetches or stores query string in the storage
     class Resolver
-      # Raised when persisted query is not found in the storage
-      class NotFound < StandardError
-        def message
-          "PersistedQueryNotFound"
-        end
-      end
-
-      # Raised when provided hash is not matched with query
-      class WrongHash < StandardError
-        def message
-          "Wrong hash was passed"
-        end
-      end
+      include GraphQL::PersistedQueries::ResolverHelpers
 
       def initialize(extensions, schema)
         @extensions = extensions
         @schema = schema
       end
 
-      def resolve(query_str)
-        return query_str if hash.nil?
+      def resolve(query_string)
+        return query_string if hash.nil?
 
-        if query_str
-          persist_query(query_str)
+        if query_string
+          persist_query(query_string)
         else
-          query_str = with_error_handling { @schema.persisted_query_store.fetch_query(hash) }
-          raise NotFound if query_str.nil?
+          query_string = with_error_handling { @schema.persisted_query_store.fetch_query(hash) }
+          raise GraphQL::PersistedQueries::NotFound if query_string.nil?
         end
 
-        query_str
+        query_string
       end
 
       private
 
-      def with_error_handling
-        yield
-      rescue StandardError => e
-        @schema.persisted_query_error_handler.call(e)
-      end
-
-      def persist_query(query_str)
-        raise WrongHash if @schema.hash_generator_proc.call(query_str) != hash
-
-        with_error_handling { @schema.persisted_query_store.save_query(hash, query_str) }
-      end
+      def persist_query(query_string)
+        validate_hash!(query_string)
 
-      def hash
-        @hash ||= @extensions.dig("persistedQuery", "sha256Hash")
+        with_error_handling { @schema.persisted_query_store.save_query(hash, query_string) }
       end
     end
   end

data/lib/graphql/persisted_queries/resolver_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    # Helper functions for resolvers
+    module ResolverHelpers
+      module_function
+
+      def with_error_handling
+        yield
+      rescue StandardError => e
+        @schema.persisted_query_error_handler.call(e)
+      end
+
+      def validate_hash!(query_string)
+        return if @schema.hash_generator_proc.call(query_string) == hash
+
+        raise GraphQL::PersistedQueries::WrongHash
+      end
+
+      def hash
+        @hash ||= @extensions.dig("persistedQuery", "sha256Hash")
+      end
+    end
+  end
+end

data/lib/graphql/persisted_queries/schema_patch.rb

@@ -10,21 +10,39 @@ module GraphQL
     # Patches GraphQL::Schema to support persisted queries
     module SchemaPatch
       class << self
-        def patch(schema)
-          schema.singleton_class.class_eval { alias_method :multiplex_original, :multiplex }
+        def patch(schema, compiled_queries)
           schema.singleton_class.prepend(SchemaPatch)
+
+          return if compiled_queries
+
+          schema.singleton_class.class_eval { alias_method :multiplex_original, :multiplex }
+          schema.singleton_class.prepend(MultiplexPatch)
+        end
+      end
+
+      # Patches GraphQL::Schema to override multiplex (not needed for compiled queries)
+      module MultiplexPatch
+        def multiplex(queries, **kwargs)
+          MultiplexResolver.new(self, queries, **kwargs).resolve
         end
       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).tap do |adapter|
+      def configure_persisted_query_store(store, **options)
+        @persisted_query_store = StoreAdapters.build(store, **options).tap do |adapter|
           adapter.tracers = tracers if persisted_queries_tracing_enabled?
         end
       end
 
+      def persisted_query_store
+        @persisted_query_store ||= find_inherited_value(:persisted_query_store)
+      end
+
+      def persisted_query_error_handler
+        @persisted_query_error_handler ||= find_inherited_value(:persisted_query_error_handler)
+      end
+
       def configure_persisted_query_error_handler(handler)
         @persisted_query_error_handler = ErrorHandlers.build(handler)
       end
@@ -33,22 +51,17 @@ module GraphQL
         @hash_generator_proc = HashGeneratorBuilder.new(hash_generator).build
       end
 
-      def verify_http_method=(verify)
-        return unless verify
-
-        if graphql10?
-          query_analyzer(prepare_analyzer)
-        else
-          query_analyzers << prepare_analyzer
-        end
+      def hash_generator_proc
+        @hash_generator_proc ||= find_inherited_value(:hash_generator_proc)
       end
 
-      def persisted_queries_tracing_enabled?
-        @persisted_queries_tracing_enabled
+      def verify_http_method=(verify)
+        query_analyzer(prepare_analyzer) if verify
       end
 
-      def multiplex(queries, **kwargs)
-        MultiplexResolver.new(self, queries, kwargs).resolve
+      def persisted_queries_tracing_enabled?
+        @persisted_queries_tracing_enabled ||=
+          find_inherited_value(:persisted_queries_tracing_enabled?)
       end
 
       def tracer(name)
@@ -62,12 +75,8 @@ module GraphQL
 
       private
 
-      def graphql10?
-        Gem::Dependency.new("graphql", ">= 1.10.0").match?("graphql", GraphQL::VERSION)
-      end
-
       def prepare_analyzer
-        if graphql10? && using_ast_analysis?
+        if using_ast_analysis?
           require "graphql/persisted_queries/analyzers/http_method_ast_analyzer"
           Analyzers::HttpMethodAstAnalyzer
         else

data/lib/graphql/persisted_queries/store_adapters.rb

@@ -10,16 +10,16 @@ module GraphQL
   module PersistedQueries
     # Contains factory methods for store adapters
     module StoreAdapters
-      def self.build(adapter, options = nil)
+      def self.build(adapter, **options)
         if adapter.is_a?(StoreAdapters::BaseStoreAdapter)
           adapter
         else
-          build_by_name(adapter, options)
+          build_by_name(adapter, **options)
         end
       end
 
-      def self.build_by_name(name, options)
-        const_get("#{BuilderHelpers.camelize(name)}StoreAdapter").new(options || {})
+      def self.build_by_name(name, **options)
+        const_get("#{BuilderHelpers.camelize(name)}StoreAdapter").new(**options)
       rescue NameError => e
         raise e.class, "Persisted query store adapter for :#{name} haven't been found", e.backtrace
       end

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

@@ -8,19 +8,22 @@ module GraphQL
         include GraphQL::Tracing::Traceable
         attr_writer :tracers
 
-        def initialize(_options)
+        def initialize(**_options)
           @name = :base
         end
 
-        def fetch_query(hash)
-          fetch(hash).tap do |result|
+        def fetch_query(hash, compiled_query: false)
+          key = build_key(hash, compiled_query)
+
+          fetch(key).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) }
+        def save_query(hash, query, compiled_query: false)
+          key = build_key(hash, compiled_query)
+          trace("save_query", adapter: @name) { save(key, query) }
         end
 
         protected
@@ -41,6 +44,13 @@ module GraphQL
             yield
           end
         end
+
+        private
+
+        def build_key(hash, compiled_query)
+          key = "#{RUBY_ENGINE}-#{RUBY_VERSION}:#{GraphQL::VERSION}:#{hash}"
+          compiled_query ? "compiled:#{key}" : key
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module GraphQL
 
         def build_dalli_proc(dalli_client)
           if dalli_client.is_a?(Hash)
-            build_dalli_proc(MemcachedClientBuilder.new(dalli_client).build)
+            build_dalli_proc(MemcachedClientBuilder.new(**dalli_client).build)
           elsif dalli_client.is_a?(Proc)
             dalli_client
           elsif defined?(::Dalli::Client) && dalli_client.is_a?(::Dalli::Client)

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

@@ -5,7 +5,7 @@ module GraphQL
     module StoreAdapters
       # Memory adapter for storing persisted queries
       class MemoryStoreAdapter < BaseStoreAdapter
-        def initialize(_options)
+        def initialize(**_options)
           @storage = {}
           @name = :memory
         end

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

@@ -10,7 +10,7 @@ module GraphQL
         DEFAULT_EXPIRATION = 24 * 60 * 60
         DEFAULT_NAMESPACE = "graphql-persisted-query"
 
-        def initialize(redis_client:, expiration: nil, namespace: nil)
+        def initialize(redis_client: {}, expiration: nil, namespace: nil)
           @redis_proc = build_redis_proc(redis_client)
           @expiration = expiration || DEFAULT_EXPIRATION
           @namespace = namespace || DEFAULT_NAMESPACE

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

@@ -18,7 +18,7 @@ module GraphQL
             expiration: expiration,
             namespace: namespace
           )
-          @memory_adapter = memory_adapter_class.new(nil)
+          @memory_adapter = memory_adapter_class.new
           @name = :redis_with_local_cache
         end
 

data/lib/graphql/persisted_queries/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "1.1.0"
+    VERSION = "1.2.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.3
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-16 00:00:00.000000000 Z
+date: 2021-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -124,16 +124,22 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/compiled_queries.rb
+- benchmark/helpers.rb
+- benchmark/persisted_queries.rb
+- benchmark/plain_gql.rb
 - bin/console
 - bin/setup
 - docs/alternative_stores.md
+- docs/compiled_queries_benchmark.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_1_11.gemfile
+- gemfiles/graphql_1_12_0.gemfile
+- gemfiles/graphql_1_12_4.gemfile
 - gemfiles/graphql_master.gemfile
 - graphql-persisted_queries.gemspec
 - lib/graphql/persisted_queries.rb
@@ -141,12 +147,17 @@ files:
 - 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/compiled_queries/multiplex_patch.rb
+- lib/graphql/persisted_queries/compiled_queries/query_patch.rb
+- lib/graphql/persisted_queries/compiled_queries/resolver.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/errors.rb
 - lib/graphql/persisted_queries/hash_generator_builder.rb
 - lib/graphql/persisted_queries/multiplex_resolver.rb
 - lib/graphql/persisted_queries/resolver.rb
+- lib/graphql/persisted_queries/resolver_helpers.rb
 - lib/graphql/persisted_queries/schema_patch.rb
 - lib/graphql/persisted_queries/store_adapters.rb
 - lib/graphql/persisted_queries/store_adapters/base_store_adapter.rb
@@ -161,7 +172,7 @@ homepage: https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -176,8 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Persisted queries for graphql-ruby
 test_files: []