graphql-persisted_queries 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdeb7575727fd45b0b40fb17699bc02f700ad20f2475cfa8bb072691f4655d12
-  data.tar.gz: 60764c58124de88e7009d9c178dbd418272ffa6b5e965590e90638bf703e6f29
+  metadata.gz: 18dc641307c696315b6978f4f2e57beaa482fa43db63ab01cdb3eead99ec827c
+  data.tar.gz: a746e4c611a9478c3ced4adc2319db49d4d40e5d56dbefcb345ff871e16b8684
 SHA512:
-  metadata.gz: c2d560698a4305ffab013db083faa2665a40bc68d698d2a634435c37efb650564369eabdde5019c1d73f63846318767e6e1012bb399ac16da9e7d492269bbc00
-  data.tar.gz: 6f708c05436af2c79df4329b7b12ee75a787bfbc71663834f8ab32ea5be678ed9d38a0942485c88e3e5bf890a749e87db6d3a0195b3e0e730f0dd8c04059d813
+  metadata.gz: '08b4dac2681ea25d189bfb51d9e0fe6bbcc44033787d534f2cf02a0a1b1cc2a8cdae0a3e7a4ba5a44bc4d22c43bf5275113ad1b16e30ae2e4269db68e16a0b6d'
+  data.tar.gz: f34db005a3a4c3297a1c682290faaa94b54ff28dcba05140fb8f83cfb0e330fc4b937663f960fbf687a0bf49d97cd06cb0363094a887cf1857cea1397e4b0623

data/.github/workflows/rspec.yml

@@ -0,0 +1,55 @@
+name: RSpec
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+  schedule:
+    - cron: "0 10 * * *"
+
+jobs:
+  rspec:
+    runs-on: ubuntu-latest
+
+    env:
+      CI: true
+
+    strategy:
+      fail-fast: false
+      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"
+        ]
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+        path: /home/runner/bundle
+        key: bundle-${{ matrix.ruby }}-${{ matrix.gemfile }}-${{ hashFiles(matrix.gemfile) }}-${{ hashFiles('**/*.gemspec') }}
+        restore-keys: |
+          bundle-${{ matrix.ruby }}-${{ matrix.gemfile }}-
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install system deps
+      run: |
+        sudo apt-get update
+        sudo apt-get install libsqlite3-dev
+    - name: Bundle install
+      run: |
+        bundle config path /home/runner/bundle
+        bundle config --global gemfile ${{ matrix.gemfile }}
+        bundle install
+        bundle update
+    - name: Run RSpec
+      run: |
+        bundle exec rake ci_specs

data/.github/workflows/rubocop.yml

@@ -0,0 +1,21 @@
+name: Rubocop
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.7
+    - name: Lint Ruby code with RuboCop
+      run: |
+        bundle install --gemfile gemfiles/graphql_1_10.gemfile --jobs 4 --retry 3
+        bundle exec --gemfile gemfiles/graphql_1_10.gemfile rubocop

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master
 
+## 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][])
+
+## 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][])
@@ -47,3 +67,5 @@
 [@DmitryTsepelev]: https://github.com/DmitryTsepelev
 [@bmorton]: https://github.com/bmorton
 [@JanStevens]: https://github.com/JanStevens
+[@ogidow]: https://github.com/ogidow
+[@rbviz]: https://github.com/rbviz

data/README.md

@@ -1,5 +1,4 @@
-# GraphQL::PersistedQueries [![Build Status](https://travis-ci.org/DmitryTsepelev/graphql-ruby-persisted_queries.svg?branch=master)](https://travis-ci.org/DmitryTsepelev/graphql-ruby-persisted_queries)
-
+# 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.
 
@@ -66,6 +65,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_:

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/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/docs/http_cache.md

@@ -32,7 +32,7 @@ GraphqlSchema.execute(
   query,
   variables: ensure_hash(params[:variables]),
   context: {
-    extensions: ensure_hash(params[:extensions])
+    extensions: ensure_hash(params[:extensions]),
     request: request
   }
 )

data/gemfiles/graphql_1_11.gemfile

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

data/gemfiles/graphql_1_12_0.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+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/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,14 +33,16 @@ module GraphQL
         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 }] }
+      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)
       end
 
       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,17 +10,28 @@ 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
@@ -47,10 +58,6 @@ module GraphQL
         @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,

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

@@ -38,7 +38,7 @@ module GraphQL
         # rubocop: disable Metrics/PerceivedComplexity
         def build_redis_proc(redis_client)
           if redis_client.is_a?(Hash)
-            build_redis_proc(RedisClientBuilder.new(redis_client).build)
+            build_redis_proc(RedisClientBuilder.new(**redis_client).build)
           elsif redis_client.is_a?(Proc)
             redis_client
           elsif defined?(::Redis) && redis_client.is_a?(::Redis)

data/lib/graphql/persisted_queries/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "1.0.0"
+    VERSION = "1.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-31 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -115,22 +115,31 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rspec.yml"
+- ".github/workflows/rubocop.yml"
 - ".gitignore"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - 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_11.gemfile
+- gemfiles/graphql_1_12_0.gemfile
+- gemfiles/graphql_1_12_4.gemfile
 - gemfiles/graphql_1_8.gemfile
 - gemfiles/graphql_1_9.gemfile
 - gemfiles/graphql_master.gemfile
@@ -140,12 +149,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
@@ -160,7 +174,7 @@ homepage: https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -175,8 +189,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: []

data/.travis.yml

@@ -1,24 +0,0 @@
-language: ruby
-cache: bundler
-
-rvm:
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6
-  - ruby-head
-
-gemfile:
-  - gemfiles/graphql_1_8.gemfile
-  - gemfiles/graphql_1_9.gemfile
-  - gemfiles/graphql_1_10.gemfile
-  - gemfiles/graphql_master.gemfile
-
-
-notifications:
-  email: false
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rvm: ruby-head