graphql-persisted_queries 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6f0c75f1f94ba226e78445f322fc335e500a8b043c5ad0639339504b34d3c33
-  data.tar.gz: c5066d90aafb265e937c1e8de6c781874dcd8a3edff964ef4375537f5e33dbd3
+  metadata.gz: 78784d32983df6d9d75af398dcf87f1239e37dce760eb99b73c3ebcf5856ee8c
+  data.tar.gz: d2e0a437767dfa2a148654b32ebfe7669167273fcf123de9b9834ac733cc3f03
 SHA512:
-  metadata.gz: f7d34c82f9ba6fbca43bf4b2d209c4c762f1dd96e26bab8d8942241c1c3447c4b3412a7235b61742638294ae4083e67ac7b872258cfa09cd416abdde80111ebd
-  data.tar.gz: 205dade68e5c6a087cd38e3632fe21010f01c0bec57857737d0328685a74a66e42ddb9907ebdbf806fe8b1aa3d3c992600a3da8309516b9817fdd2b6a9d38703
+  metadata.gz: b070e30dea650ae02e6164440cd1b7b1a73796b98db7e691c8ff10fce9b5eb9351daebcbf68f2d2d3e7d2ccdf8bb6503f00eae2060a674be66d1229811e3f375
+  data.tar.gz: cb4f0137249ab7414857af926833de0d8060a8fc77eb7f29fb2853dfcb22f85382ed8341169a7b0015c21fd52429b7e735c67e1923545ba69d44441166c217e6

data/.github/workflows/rspec.yml

@@ -25,6 +25,7 @@ jobs:
           "gemfiles/graphql_1_12_0.gemfile",
           "gemfiles/graphql_1_12_4.gemfile",
           "gemfiles/graphql_1_13_7.gemfile",
+          "gemfiles/graphql_2_0_0.gemfile",
           "gemfiles/graphql_master.gemfile"
         ]
 

data/.gitignore

@@ -7,3 +7,5 @@
 /spec/reports/
 /tmp/
 Gemfile.lock
+
+.ruby-version

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 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][])
+
 ## 1.5.0 (2022-02-10)
 
 - [PR#53](https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries/pull/53) Support graphql-ruby 2.0.0 ([@DmitryTsepelev][])

data/gemfiles/graphql_2_0_0.gemfile

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

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

@@ -0,0 +1,162 @@
+# 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

data/lib/graphql/persisted_queries/version.rb

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

data/lib/graphql/persisted_queries.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-persisted_queries
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - DmitryTsepelev
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2022-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -141,6 +141,7 @@ files:
 - gemfiles/graphql_1_12_0.gemfile
 - gemfiles/graphql_1_12_4.gemfile
 - gemfiles/graphql_1_13_7.gemfile
+- gemfiles/graphql_2_0_0.gemfile
 - gemfiles/graphql_master.gemfile
 - graphql-persisted_queries.gemspec
 - lib/graphql/persisted_queries.rb
@@ -148,6 +149,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/multiplex_patch.rb
 - lib/graphql/persisted_queries/compiled_queries/query_patch.rb
 - lib/graphql/persisted_queries/compiled_queries/resolver.rb
@@ -173,7 +175,7 @@ homepage: https://github.com/DmitryTsepelev/graphql-ruby-persisted_queries
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -188,8 +190,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Persisted queries for graphql-ruby
 test_files: []