graphql-persisted_queries 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff010e4d5d11f8e7028d4152a880de6d4503bda6b6e777fbc0e7b3bc19058ac8
-  data.tar.gz: 0d213b909ab7668c8248d64ab43c1e80f223d5b46b3d9b3954272728e5b96cec
+  metadata.gz: 18dc641307c696315b6978f4f2e57beaa482fa43db63ab01cdb3eead99ec827c
+  data.tar.gz: a746e4c611a9478c3ced4adc2319db49d4d40e5d56dbefcb345ff871e16b8684
 SHA512:
-  metadata.gz: fc0ec99c3950301f1d23779b7706f24f77b5bbffd4f6df9d167379fc25eff9e6eebeb12296331c9a50972152b9fd7e457262bf6fa8379e2dce6d9e4668cb6e9b
-  data.tar.gz: dd09cab2aff3905cd6afca029f16377b963856f160eb9c4730ce64fdc2b8cbce861f402c26f748d38fa1fd466a9af04165d284f9792f33f777ffe5c8e2eaebcb
+  metadata.gz: '08b4dac2681ea25d189bfb51d9e0fe6bbcc44033787d534f2cf02a0a1b1cc2a8cdae0a3e7a4ba5a44bc4d22c43bf5275113ad1b16e30ae2e4269db68e16a0b6d'
+  data.tar.gz: f34db005a3a4c3297a1c682290faaa94b54ff28dcba05140fb8f83cfb0e330fc4b937663f960fbf687a0bf49d97cd06cb0363094a887cf1857cea1397e4b0623

data/.github/workflows/rspec.yml

@@ -23,6 +23,9 @@ jobs:
           "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 +52,4 @@ jobs:
         bundle update
     - name: Run RSpec
       run: |
-        bundle exec rake spec
+        bundle exec rake ci_specs

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## 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][])

data/README.md

@@ -65,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/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
+    # 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
 
@@ -25,5 +35,18 @@ module GraphQL
       store = options.delete(:store) || :memory
       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/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

@@ -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)

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,9 +10,20 @@ 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
 
@@ -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/base_store_adapter.rb

@@ -12,15 +12,18 @@ module GraphQL
           @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/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "1.1.1"
+    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.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-03 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -124,14 +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_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
@@ -141,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