graphql 2.0.32 → 2.5.22

data/lib/graphql/analysis/ast.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require "graphql/analysis/ast/visitor"
-require "graphql/analysis/ast/analyzer"
-require "graphql/analysis/ast/field_usage"
-require "graphql/analysis/ast/query_complexity"
-require "graphql/analysis/ast/max_query_complexity"
-require "graphql/analysis/ast/query_depth"
-require "graphql/analysis/ast/max_query_depth"
-
-module GraphQL
-  module Analysis
-    module AST
-      module_function
-      # Analyze a multiplex, and all queries within.
-      # Multiplex analyzers are ran for all queries, keeping state.
-      # Query analyzers are ran per query, without carrying state between queries.
-      #
-      # @param multiplex [GraphQL::Execution::Multiplex]
-      # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
-      # @return [Array<Any>] Results from multiplex analyzers
-      def analyze_multiplex(multiplex, analyzers)
-        multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
-
-        multiplex.current_trace.analyze_multiplex(multiplex: multiplex) do
-          query_results = multiplex.queries.map do |query|
-            if query.valid?
-              analyze_query(
-                query,
-                query.analyzers,
-                multiplex_analyzers: multiplex_analyzers
-              )
-            else
-              []
-            end
-          end
-
-          multiplex_results = multiplex_analyzers.map(&:result)
-          multiplex_errors = analysis_errors(multiplex_results)
-
-          multiplex.queries.each_with_index do |query, idx|
-            query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
-          end
-          multiplex_results
-        end
-      end
-
-      # @param query [GraphQL::Query]
-      # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
-      # @return [Array<Any>] Results from those analyzers
-      def analyze_query(query, analyzers, multiplex_analyzers: [])
-        query.current_trace.analyze_query(query: query) do
-          query_analyzers = analyzers
-            .map { |analyzer| analyzer.new(query) }
-            .select { |analyzer| analyzer.analyze? }
-
-          analyzers_to_run = query_analyzers + multiplex_analyzers
-          if analyzers_to_run.any?
-            visitor = GraphQL::Analysis::AST::Visitor.new(
-              query: query,
-              analyzers: analyzers_to_run
-            )
-
-            visitor.visit
-
-            if visitor.rescued_errors.any?
-              visitor.rescued_errors
-            else
-              query_analyzers.map(&:result)
-            end
-          else
-            []
-          end
-        end
-      end
-
-      def analysis_errors(results)
-        results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
-      end
-    end
-  end
-end

data/lib/graphql/backtrace/inspect_result.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    module InspectResult
-      module_function
-
-      def inspect_result(obj)
-        case obj
-        when Hash
-          "{" +
-            obj.map do |key, val|
-              "#{key}: #{inspect_truncated(val)}"
-            end.join(", ") +
-            "}"
-        when Array
-          "[" +
-            obj.map { |v| inspect_truncated(v) }.join(", ") +
-            "]"
-        when Query::Context::SharedMethods
-          if obj.invalid_null?
-            "nil"
-          else
-            inspect_truncated(obj.value)
-          end
-        else
-          inspect_truncated(obj)
-        end
-      end
-
-      def inspect_truncated(obj)
-        case obj
-        when Hash
-          "{...}"
-        when Array
-          "[...]"
-        when Query::Context::SharedMethods
-          if obj.invalid_null?
-            "nil"
-          else
-            inspect_truncated(obj.value)
-          end
-        when GraphQL::Execution::Lazy
-          "(unresolved)"
-        else
-          "#{obj.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/graphql/backtrace/trace.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    module Trace
-      def validate(query:, validate:)
-        if query.multiplex
-          push_query_backtrace_context(query)
-        end
-        super
-      end
-
-      def analyze_query(query:)
-        if query.multiplex # missing for stand-alone static validation
-          push_query_backtrace_context(query)
-        end
-        super
-      end
-
-      def execute_query(query:)
-        push_query_backtrace_context(query)
-        super
-      end
-
-      def execute_query_lazy(query:, multiplex:)
-        query ||= multiplex.queries.first
-        push_query_backtrace_context(query)
-        super
-      end
-
-      def execute_field(field:, query:, ast_node:, arguments:, object:)
-        push_field_backtrace_context(field, query, ast_node, arguments, object)
-        super
-      end
-
-      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
-        push_field_backtrace_context(field, query, ast_node, arguments, object)
-        super
-      end
-
-      def execute_multiplex(multiplex:)
-        super
-      rescue StandardError => err
-        # This is an unhandled error from execution,
-        # Re-raise it with a GraphQL trace.
-        multiplex_context = multiplex.context
-        potential_context = multiplex_context[:last_graphql_backtrace_context]
-
-        if potential_context.is_a?(GraphQL::Query::Context) ||
-            potential_context.is_a?(Backtrace::Frame)
-          raise TracedError.new(err, potential_context)
-        else
-          raise
-        end
-      ensure
-        multiplex_context = multiplex.context
-        multiplex_context.delete(:graphql_backtrace_contexts)
-        multiplex_context.delete(:last_graphql_backtrace_context)
-      end
-
-      private
-
-      def push_query_backtrace_context(query)
-        push_data = query
-        multiplex = query.multiplex
-        push_key = []
-        push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
-        push_storage[push_key] = push_data
-        multiplex.context[:last_graphql_backtrace_context] = push_data
-      end
-
-      def push_field_backtrace_context(field, query, ast_node, arguments, object)
-        multiplex = query.multiplex
-        push_key = query.context[:current_path]
-        push_storage = multiplex.context[:graphql_backtrace_contexts]
-        parent_frame = push_storage[push_key[0..-2]]
-
-        if parent_frame.is_a?(GraphQL::Query)
-          parent_frame = parent_frame.context
-        end
-
-        push_data = Frame.new(
-          query: query,
-          path: push_key,
-          ast_node: ast_node,
-          field: field,
-          object: object,
-          arguments: arguments,
-          parent_frame: parent_frame,
-        )
-
-        push_storage[push_key] = push_data
-        multiplex.context[:last_graphql_backtrace_context] = push_data
-      end
-    end
-  end
-end

data/lib/graphql/backtrace/tracer.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    # TODO this is not fiber-friendly
-    module Tracer
-      module_function
-
-      # Implement the {GraphQL::Tracing} API.
-      def trace(key, metadata)
-        case key
-        when "lex", "parse"
-          # No context here, don't have a query yet
-          nil
-        when "execute_multiplex", "analyze_multiplex"
-          # No query context yet
-          nil
-        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          push_key = []
-          if (query = metadata[:query]) || ((queries = metadata[:queries]) && (query = queries.first))
-            push_data = query
-            multiplex = query.multiplex
-          elsif (multiplex = metadata[:multiplex])
-            push_data = multiplex.queries.first
-          end
-        when "execute_field", "execute_field_lazy"
-          query = metadata[:query]
-          multiplex = query.multiplex
-          push_key = query.context[:current_path]
-          parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
-
-          if parent_frame.is_a?(GraphQL::Query)
-            parent_frame = parent_frame.context
-          end
-
-          push_data = Frame.new(
-            query: query,
-            path: push_key,
-            ast_node: metadata[:ast_node],
-            field: metadata[:field],
-            object: metadata[:object],
-            arguments: metadata[:arguments],
-            parent_frame: parent_frame,
-          )
-        else
-          # Custom key, no backtrace data for this
-          nil
-        end
-
-        if push_data && multiplex
-          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
-          push_storage[push_key] = push_data
-          multiplex.context[:last_graphql_backtrace_context] = push_data
-        end
-
-        if key == "execute_multiplex"
-          multiplex_context = metadata[:multiplex].context
-          begin
-            yield
-          rescue StandardError => err
-            # This is an unhandled error from execution,
-            # Re-raise it with a GraphQL trace.
-            potential_context = multiplex_context[:last_graphql_backtrace_context]
-
-            if potential_context.is_a?(GraphQL::Query::Context) ||
-                potential_context.is_a?(Backtrace::Frame)
-              raise TracedError.new(err, potential_context)
-            else
-              raise
-            end
-          ensure
-            multiplex_context.delete(:graphql_backtrace_contexts)
-            multiplex_context.delete(:last_graphql_backtrace_context)
-          end
-        else
-          yield
-        end
-      end
-    end
-  end
-end

data/lib/graphql/deprecation.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Deprecation
-    def self.warn(message)
-      Kernel.warn(message)
-    end
-  end
-end

data/lib/graphql/filter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "graphql/deprecation"
-
-module GraphQL
-  # @api private
-  class Filter
-    def initialize(only: nil, except: nil, silence_deprecation_warning: false)
-      if !silence_deprecation_warning
-        line = caller(2, 10).find { |l| !l.include?("lib/graphql") }
-        GraphQL::Deprecation.warn("GraphQL::Filter, `only:`, `except:`, and `.merge_filters` are deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).\n  #{line}")
-      end
-      @only = only
-      @except = except
-    end
-
-    # Returns true if `member, ctx` passes this filter
-    def call(member, ctx)
-      (@only ? @only.call(member, ctx) : true) &&
-      (@except ? !@except.call(member, ctx) : true)
-    end
-
-    def merge(only: nil, except: nil)
-      onlies = [self].concat(Array(only))
-      merged_only = MergedOnly.build(onlies)
-      merged_except = MergedExcept.build(Array(except))
-      self.class.new(only: merged_only, except: merged_except, silence_deprecation_warning: true)
-    end
-
-    private
-
-    class MergedOnly
-      def initialize(first, second)
-        @first = first
-        @second = second
-      end
-
-      def call(member, ctx)
-        @first.call(member, ctx) && @second.call(member, ctx)
-      end
-
-      def self.build(onlies)
-        case onlies.size
-        when 0
-          nil
-        when 1
-          onlies[0]
-        else
-          onlies.reduce { |memo, only| self.new(memo, only) }
-        end
-      end
-    end
-
-    class MergedExcept < MergedOnly
-      def call(member, ctx)
-        @first.call(member, ctx) || @second.call(member, ctx)
-      end
-    end
-  end
-end