graphql-persisted_queries 1.5.1 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78784d32983df6d9d75af398dcf87f1239e37dce760eb99b73c3ebcf5856ee8c
-  data.tar.gz: d2e0a437767dfa2a148654b32ebfe7669167273fcf123de9b9834ac733cc3f03
+  metadata.gz: fa710e0a1af1fe00953679781bf408f3c78201b67920671f9af36ff57edefcc0
+  data.tar.gz: cc46697bf61938af0d4359fb9b5bf4898f3bc5108b4f562f94d3003a857064a6
 SHA512:
-  metadata.gz: b070e30dea650ae02e6164440cd1b7b1a73796b98db7e691c8ff10fce9b5eb9351daebcbf68f2d2d3e7d2ccdf8bb6503f00eae2060a674be66d1229811e3f375
-  data.tar.gz: cb4f0137249ab7414857af926833de0d8060a8fc77eb7f29fb2853dfcb22f85382ed8341169a7b0015c21fd52429b7e735c67e1923545ba69d44441166c217e6
+  metadata.gz: 6028cb87dc1e0c7a78f18f29c7afbff2d2aae46fadbec983d6ebbb217016523a8722f27c993570b914b3fec6cebe0d16ad26e7091844a0e60f4bf0d80217cb11
+  data.tar.gz: a0d0dada8b7f34298a69aed43dd988ce077e010866faf33c8d206375ee0cb2f00afed1f0794753983a5b2b01f266888f7988d77a031f33c6f55d2779abd62e35

data/.github/workflows/rspec.yml

@@ -20,11 +20,10 @@ jobs:
       matrix:
         ruby: [2.6, 2.7, 3.0]
         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_1_13_7.gemfile",
+          "gemfiles/graphql_1_13_16.gemfile",
           "gemfiles/graphql_2_0_0.gemfile",
           "gemfiles/graphql_master.gemfile"
         ]

data/.github/workflows/rubocop.yml

@@ -17,5 +17,5 @@ jobs:
         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
+        bundle install --gemfile gemfiles/graphql_1_12_0.gemfile --jobs 4 --retry 3
+        bundle exec --gemfile gemfiles/graphql_1_12_0.gemfile rubocop

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## master
 
+## 1.6.1 (2022-11-17)
+
+- [PR#60](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/60)
+Handle situations when prepare_ast happens before instrumentation ([@DmitryTsepelev][])
+
+## 1.6.0 (2022-10-10)
+
+- [PR#57](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/57) Refactor code to use instrumentation instead of a monkey patch, deprecate graphql-ruby 1.10 and 1.11 ([@DmitryTsepelev][])
+
 ## 1.5.1 (2022-09-28)
 
 - [PR#56](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/56) Support graphql-ruby 2.0.14 ([@DmitryTsepelev][])

data/README.md

@@ -1,4 +1,4 @@
-# GraphQL::PersistedQueries
+# GraphQL::PersistedQueries ![](https://ruby-gem-downloads-badge.herokuapp.com/graphql-persisted_queries?type=total)
 
 `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.
 
@@ -6,13 +6,6 @@
 - 🤝**Clients share cached queries** – it's enough to miss cache only once for each unique query
 - 🎅**Works for clients without persisted query support**
 
-
-<p align="center">
-  <a href="https://evilmartians.com/?utm_source=graphql-ruby-persisted_queries">
-    <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
-  </a>
-</p>
-
 ## Getting started
 
 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:
@@ -92,6 +85,10 @@ An experimental tracing feature can be enabled by setting `tracing: true` when c
 > 📖 Read more about the gem internals: [Persisted queries in GraphQL:
 Slim down Apollo requests to your Ruby application](https://evilmartians.com/chronicles/persisted-queries-in-graphql-slim-down-apollo-requests-to-your-ruby-application)
 
+## Credits
+
+Initially sponsored by [Evil Martians](http://evilmartians.com).
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries.

data/gemfiles/{graphql_1_10.gemfile → graphql_1_13_16.gemfile}

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

data/graphql-persisted_queries.gemspec

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module PersistedQueries
+    module CompiledQueries
+      # Instrumentation to support compiled queries
+      module Instrumentation
+        class << self
+          # Actions to perform before the query resolution
+          def before_query(query)
+            return unless query.context[:extensions]
+
+            query.try_load_document!
+            return if query.document || query.query_string
+
+            query.persisted_query_not_found!
+            query.context.errors << GraphQL::ExecutionError.new(NotFound::MESSAGE)
+          end
+
+          def after_query(*); end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module GraphQL
 
         def add_not_found_error(query)
           query.context.errors.clear
-          query.context.errors << GraphQL::ExecutionError.new("PersistedQueryNotFound")
+          query.context.errors << GraphQL::ExecutionError.new(NotFound::MESSAGE)
           GraphQL::Execution::Multiplex::NO_OPERATION
         end
       end

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

@@ -5,28 +5,47 @@ module GraphQL
     module CompiledQueries
       # Patches GraphQL::Query to support compiled queries
       module QueryPatch
+        def persisted_query_not_found!
+          @persisted_query_not_found = true
+        end
+
         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?
+          return super if @context[:extensions].nil? || @document
 
-          @persisted_query_not_found = not_loaded_document && query_string.nil?
+          try_load_document!
 
           super.tap do
-            resolver.persist(query_string, @document) if not_loaded_document && query_string
+            if @context.errors.any?(&method(:not_found_error?))
+              @context.errors.select!(&method(:not_found_error?))
+            end
+
+            if @persisted_document_not_found && query_string
+              resolver.persist(query_string, @document)
+            end
           end
         end
 
+        def try_load_document!
+          return if @document || @persisted_document_not_found
+
+          compiled_query_resolver = CompiledQueries::Resolver.new(schema, context[:extensions])
+          @document = compiled_query_resolver.fetch
+          @persisted_document_not_found = @document.nil?
+        end
+
         private
 
         def resolver
           @resolver ||= Resolver.new(@schema, @context[:extensions])
         end
+
+        def not_found_error?(error)
+          error.message == GraphQL::PersistedQueries::NotFound::MESSAGE
+        end
       end
     end
   end

data/lib/graphql/persisted_queries/errors.rb

@@ -4,8 +4,10 @@ module GraphQL
   module PersistedQueries
     # Raised when persisted query is not found in the storage
     class NotFound < StandardError
+      MESSAGE = "PersistedQueryNotFound"
+
       def message
-        "PersistedQueryNotFound"
+        MESSAGE
       end
     end
 

data/lib/graphql/persisted_queries/schema_patch.rb

@@ -3,6 +3,7 @@
 require "graphql/persisted_queries/hash_generator_builder"
 require "graphql/persisted_queries/resolver"
 require "graphql/persisted_queries/multiplex_resolver"
+require "graphql/persisted_queries/compiled_queries/instrumentation"
 require "graphql/persisted_queries/analyzers/http_method_validator"
 
 module GraphQL
@@ -13,10 +14,12 @@ module GraphQL
         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)
+          if compiled_queries
+            schema.instrument :query, CompiledQueries::Instrumentation
+          else
+            schema.singleton_class.class_eval { alias_method :multiplex_original, :multiplex }
+            schema.singleton_class.prepend(MultiplexPatch)
+          end
         end
       end
 

data/lib/graphql/persisted_queries/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module PersistedQueries
-    VERSION = "1.5.1"
+    VERSION = "1.6.1"
   end
 end

data/lib/graphql/persisted_queries.rb

@@ -10,7 +10,6 @@ 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/interpreter_patch"
 require "graphql/persisted_queries/compiled_queries/query_patch"
 
 module GraphQL
@@ -38,16 +37,12 @@ module GraphQL
     end
     # rubocop:enable Metrics/MethodLength
 
-    def self.configure_compiled_queries # rubocop:disable 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
 
-      if Gem::Dependency.new("graphql", ">= 2.0.14").match?("graphql", GraphQL::VERSION)
-        GraphQL::Execution::Interpreter.singleton_class.prepend(
-          GraphQL::PersistedQueries::CompiledQueries::InterpreterPatch
-        )
-      else
+      if Gem::Dependency.new("graphql", "< 2.0.14").match?("graphql", GraphQL::VERSION)
         GraphQL::Execution::Multiplex.singleton_class.prepend(
           GraphQL::PersistedQueries::CompiledQueries::MultiplexPatch
         )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.1
 platform: ruby
 authors:
 - DmitryTsepelev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-28 00:00:00.000000000 Z
+date: 2022-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -136,10 +136,9 @@ files:
 - 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_13_16.gemfile
 - gemfiles/graphql_1_13_7.gemfile
 - gemfiles/graphql_2_0_0.gemfile
 - gemfiles/graphql_master.gemfile
@@ -149,7 +148,7 @@ 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/interpreter_patch.rb
+- lib/graphql/persisted_queries/compiled_queries/instrumentation.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

data/gemfiles/graphql_1_11.gemfile

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

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

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module PersistedQueries
-    module CompiledQueries
-      # Patches GraphQL::Execution::Multiplex to support compiled queries
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Layout/IndentationWidth
-      # rubocop:disable Metrics/PerceivedComplexity, Metrics/ModuleLength, Metrics/LineLength
-      # rubocop:disable Metrics/BlockLength, Style/BracesAroundHashParameters, Style/CommentAnnotation
-      # rubocop:disable Naming/RescuedExceptionsVariableName, Layout/SpaceInsideHashLiteralBraces
-      # rubocop:disable Lint/ShadowingOuterLocalVariable, Style/BlockDelimiters, Metrics/MethodLength
-      # rubocop:disable Style/Next, Layout/ElseAlignment, Layout/EndAlignment, Lint/RescueException
-      module InterpreterPatch
-        # This method is fully copied from the gem because I didn't find a way to patch it. In future we will
-        # need to keep it in sync and migrate the monkey patch to newer versions of the file.
-        def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
-          queries = query_options.map do |opts|
-            case opts
-            when Hash
-              GraphQL::Query.new(schema, nil, **opts)
-            when GraphQL::Query
-              opts
-            else
-              raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
-            end
-          end
-
-          multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
-            schema = multiplex.schema
-            queries = multiplex.queries
-            query_instrumenters = schema.instrumenters[:query]
-            multiplex_instrumenters = schema.instrumenters[:multiplex]
-
-            # First, run multiplex instrumentation, then query instrumentation for each query
-            call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-              each_query_call_hooks(query_instrumenters, queries) do
-                schema = multiplex.schema
-                multiplex_analyzers = schema.multiplex_analyzers
-                queries = multiplex.queries
-                if multiplex.max_complexity
-                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
-                end
-
-                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-                begin
-                  # Since this is basically the batching context,
-                  # share it for a whole multiplex
-                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
-                  # Do as much eager evaluation of the query as possible
-                  results = []
-                  queries.each_with_index do |query, idx|
-                    multiplex.dataloader.append_job {
-                      operation = query.selected_operation
-                      result =
-                        # MONKEY PATCH START
-                        if query.persisted_query_not_found?
-                          query.context.errors.clear
-                          query.context.errors << GraphQL::ExecutionError.new("PersistedQueryNotFound")
-                          singleton_class::NO_OPERATION
-                        # MONKEY PATCH END
-                        elsif operation.nil? || !query.valid? || query.context.errors.any?
-                          singleton_class::NO_OPERATION
-                        else
-                          begin
-                            # Although queries in a multiplex _share_ an Interpreter instance,
-                            # they also have another item of state, which is private to that query
-                            # in particular, assign it here:
-                            runtime = GraphQL::Execution::Interpreter::Runtime.new(query: query)
-                            query.context.namespace(:interpreter)[:runtime] = runtime
-
-                            query.trace("execute_query", {query: query}) do
-                              runtime.run_eager
-                            end
-                          rescue GraphQL::ExecutionError => err
-                            query.context.errors << err
-                            singleton_class::NO_OPERATION
-                          end
-                        end
-                      results[idx] = result
-                    }
-                  end
-
-                  multiplex.dataloader.run
-
-                  # Then, work through lazy results in a breadth-first way
-                  multiplex.dataloader.append_job {
-                    tracer = multiplex
-                    query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
-                    queries = multiplex ? multiplex.queries : [query]
-                    final_values = queries.map do |query|
-                      runtime = query.context.namespace(:interpreter)[:runtime]
-                      # it might not be present if the query has an error
-                      runtime ? runtime.final_result : nil
-                    end
-                    final_values.compact!
-                    tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-                      GraphQL::Execution::Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
-                    end
-                    queries.each do |query|
-                      runtime = query.context.namespace(:interpreter)[:runtime]
-                      if runtime
-                        runtime.delete_interpreter_context(:current_path)
-                        runtime.delete_interpreter_context(:current_field)
-                        runtime.delete_interpreter_context(:current_object)
-                        runtime.delete_interpreter_context(:current_arguments)
-                      end
-                    end
-                  }
-                  multiplex.dataloader.run
-
-                  # Then, find all errors and assign the result to the query object
-                  results.each_with_index do |data_result, idx|
-                    query = queries[idx]
-                    # Assign the result so that it can be accessed in instrumentation
-                    query.result_values = if data_result.equal?(singleton_class::NO_OPERATION)
-                      if !query.valid? || query.context.errors.any?
-                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
-                        { "errors" => query.static_errors.map(&:to_h) }
-                      else
-                        data_result
-                      end
-                    else
-                      result = {
-                        "data" => query.context.namespace(:interpreter)[:runtime].final_result
-                      }
-
-                      if query.context.errors.any?
-                        error_result = query.context.errors.map(&:to_h)
-                        result["errors"] = error_result
-                      end
-
-                      result
-                    end
-                    if query.context.namespace?(:__query_result_extensions__)
-                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
-                    end
-                    # Get the Query::Result, not the Hash
-                    results[idx] = query.result
-                  end
-
-                  results
-                rescue Exception
-                  # TODO rescue at a higher level so it will catch errors in analysis, too
-                  # Assign values here so that the query's `@executed` becomes true
-                  queries.map { |q| q.result_values ||= {} }
-                  raise
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Layout/IndentationWidth
-    # rubocop:enable Metrics/PerceivedComplexity, Metrics/ModuleLength, Metrics/LineLength
-    # rubocop:enable Metrics/BlockLength, Style/BracesAroundHashParameters, Style/CommentAnnotation
-    # rubocop:enable Naming/RescuedExceptionsVariableName, Layout/SpaceInsideHashLiteralBraces
-    # rubocop:enable Lint/ShadowingOuterLocalVariable, Style/BlockDelimiters, Metrics/MethodLength
-    # rubocop:enable Style/Next, Layout/ElseAlignment, Layout/EndAlignment, Lint/RescueException
-  end
-end