graphql 1.13.14 → 2.0.19

data/lib/graphql/tracing/opentelemetry_tracing.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Tracing
-    class OpenTelemetryTracing < PlatformTracing
-      self.platform_keys = {
-        'lex' => 'graphql.lex',
-        'parse' => 'graphql.parse',
-        'validate' => 'graphql.validate',
-        'analyze_query' => 'graphql.analyze_query',
-        'analyze_multiplex' => 'graphql.analyze_multiplex',
-        'execute_query' => 'graphql.execute_query',
-        'execute_query_lazy' => 'graphql.execute_query_lazy',
-        'execute_multiplex' => 'graphql.execute_multiplex'
-      }
-
-      def platform_trace(platform_key, key, data)
-        return yield if platform_key.nil?
-
-        tracer.in_span(platform_key, attributes: attributes_for(key, data)) do |span, _context|
-          yield.tap do |response|
-            errors = response[:errors]&.compact&.map { |e| e.to_h }&.to_json if key == 'validate'
-            unless errors.nil?
-              span.add_event(
-                'graphql.validation.error',
-                attributes: {
-                  'message' => errors
-                }
-              )
-            end
-          end
-        end
-      end
-
-      def platform_field_key(type, field)
-        "#{type.graphql_name}.#{field.graphql_name}"
-      end
-
-      def platform_authorized_key(type)
-        "#{type.graphql_name}.authorized"
-      end
-
-      def platform_resolve_type_key(type)
-        "#{type.graphql_name}.resolve_type"
-      end
-
-      private
-
-      def tracer
-        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.tracer
-      end
-
-      def config
-        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.config
-      end
-
-      def platform_key_enabled?(ctx, key)
-        return false unless config[key]
-
-        ns = ctx.namespace(:opentelemetry)
-        return true if ns.empty? # restores original behavior so that keys are returned if tracing is not set in context.
-        return false unless ns.key?(key) && ns[key]
-
-        return true
-      end
-
-      def attributes_for(key, data)
-        attributes = {}
-        case key
-        when 'execute_query'
-          attributes['selected_operation_name'] = data[:query].selected_operation_name if data[:query].selected_operation_name
-          attributes['selected_operation_type'] = data[:query].selected_operation.operation_type
-          attributes['query_string'] = data[:query].query_string
-        end
-        attributes
-      end
-
-      def cached_platform_key(ctx, key, trace_phase)
-        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
-
-        cache.fetch(key) do
-          cache[key] = if trace_phase == :field
-            return unless platform_key_enabled?(ctx, :enable_platform_field)
-
-            yield
-          elsif trace_phase == :authorized
-            return unless platform_key_enabled?(ctx, :enable_platform_authorized)
-
-            yield
-          elsif trace_phase == :resolve_type
-            return unless platform_key_enabled?(ctx, :enable_platform_resolve_type)
-
-            yield
-          else
-            raise "Unknown trace phase"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/tracing/skylight_tracing.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Tracing
-    class SkylightTracing < PlatformTracing
-      self.platform_keys = {
-        "lex" => "graphql.language",
-        "parse" => "graphql.language",
-        "validate" => "graphql.prepare",
-        "analyze_query" => "graphql.prepare",
-        "analyze_multiplex" => "graphql.prepare",
-        "execute_multiplex" => "graphql.execute",
-        "execute_query" => "graphql.execute",
-        "execute_query_lazy" => "graphql.execute",
-      }
-
-      # @param set_endpoint_name [Boolean] If true, the GraphQL operation name will be used as the endpoint name.
-      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
-      #   It can also be specified per-query with `context[:set_skylight_endpoint_name]`.
-      def initialize(options = {})
-        GraphQL::Deprecation.warn("GraphQL::Tracing::SkylightTracing is deprecated and will be removed in GraphQL-Ruby 2.0, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
-        @set_endpoint_name = options.fetch(:set_endpoint_name, false)
-        super
-      end
-
-      def platform_trace(platform_key, key, data)
-        if key == "execute_query"
-          query = data[:query]
-          title = query.selected_operation_name || "<anonymous>"
-          category = platform_key
-          set_endpoint_name_override = query.context[:set_skylight_endpoint_name]
-          if set_endpoint_name_override == true || (set_endpoint_name_override.nil? && @set_endpoint_name)
-            # Assign the endpoint so that queries will be grouped
-            instrumenter = Skylight.instrumenter
-            if instrumenter
-              current_trace = instrumenter.current_trace
-              if current_trace
-                op_type = query.selected_operation ? query.selected_operation.operation_type : "query"
-                endpoint = "GraphQL/#{op_type}.#{title}"
-                current_trace.endpoint = endpoint
-              end
-            end
-          end
-        elsif key.start_with?("execute_field")
-          title = platform_key
-          category = key
-        else
-          title = key
-          category = platform_key
-        end
-
-        Skylight.instrument(category: category, title: title) do
-          yield
-        end
-      end
-
-      def platform_field_key(type, field)
-        "graphql.#{type.graphql_name}.#{field.graphql_name}"
-      end
-
-      def platform_authorized_key(type)
-        "graphql.authorized.#{type.graphql_name}"
-      end
-
-      def platform_resolve_type_key(type)
-        "graphql.resolve_type.#{type.graphql_name}"
-      end
-    end
-  end
-end

data/lib/graphql/types/relay/node_field.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Types
-    module Relay
-      # Don't use this field directly, instead, use one of these approaches:
-      #
-      # @example Adding this field directly
-      #   include GraphQL::Types::Relay::HasNodeField
-      #
-      # @example Implementing a similar field in your own Query root
-      #
-      #   field :node, GraphQL::Types::Relay::Node, null: true,
-      #     description: "Fetches an object given its ID" do
-      #       argument :id, ID, required: true
-      #     end
-      #
-      #   def node(id:)
-      #     context.schema.object_from_id(id, context)
-      #   end
-      #
-      DeprecatedNodeField = GraphQL::Schema::Field.new(owner: nil, **HasNodeField.field_options, &HasNodeField.field_block)
-    end
-  end
-end

data/lib/graphql/types/relay/nodes_field.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Types
-    module Relay
-      # Don't use this directly, instead, use one of these:
-      #
-      # @example Adding this field directly
-      #   include GraphQL::Types::Relay::HasNodesField
-      #
-      # @example Implementing a similar field in your own Query root
-      #
-      #   field :nodes, [GraphQL::Types::Relay::Node, null: true], null: false,
-      #     description: Fetches a list of objects given a list of IDs." do
-      #       argument :ids, [ID], required: true
-      #     end
-      #
-      #   def nodes(ids:)
-      #     ids.map do |id|
-      #       context.schema.object_from_id(context, id)
-      #     end
-      #   end
-      #
-      def self.const_missing(const_name)
-        if const_name == :NodesField
-          message = "NodesField is deprecated, use `include GraphQL::Types::Relay::HasNodesField` instead."
-          message += "\n(referenced from #{caller(1, 1).first})"
-          GraphQL::Deprecation.warn(message)
-
-          DeprecatedNodesField
-        elsif const_name == :NodeField
-          message = "NodeField is deprecated, use `include GraphQL::Types::Relay::HasNodeField` instead."
-          message += "\n(referenced from #{caller(1, 1).first})"
-          GraphQL::Deprecation.warn(message)
-
-          DeprecatedNodeField
-        else
-          super
-        end
-      end
-      DeprecatedNodesField = GraphQL::Schema::Field.new(owner: nil, **HasNodesField.field_options, &HasNodesField.field_block)
-    end
-  end
-end

data/lib/graphql/union_type.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class UnionType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    # Rubocop was unhappy about the syntax when this was a proc literal
-    class AcceptPossibleTypesDefinition
-      def self.call(target, possible_types, options = {})
-        target.add_possible_types(possible_types, **options)
-      end
-    end
-
-    deprecated_accepts_definitions :resolve_type, :type_membership_class,
-      possible_types: AcceptPossibleTypesDefinition
-    ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
-
-    attr_accessor :resolve_type_proc
-    attr_reader :type_memberships
-    attr_accessor :type_membership_class
-
-    def initialize
-      super
-      @type_membership_class = GraphQL::Schema::TypeMembership
-      @type_memberships = []
-      @cached_possible_types = nil
-      @resolve_type_proc = nil
-    end
-
-    def initialize_copy(other)
-      super
-      @type_membership_class = other.type_membership_class
-      @type_memberships = other.type_memberships.dup
-      @cached_possible_types = nil
-    end
-
-    def kind
-      GraphQL::TypeKinds::UNION
-    end
-
-    # @return [Boolean] True if `child_type_defn` is a member of this {UnionType}
-    def include?(child_type_defn, ctx = GraphQL::Query::NullContext)
-      possible_types(ctx).include?(child_type_defn)
-    end
-
-    # @return [Array<GraphQL::ObjectType>] Types which may be found in this union
-    def possible_types(ctx = GraphQL::Query::NullContext)
-      if ctx == GraphQL::Query::NullContext
-        # Only cache the default case; if we cached for every `ctx`, it would be a memory leak
-        # (The warden should cache calls to this method, so it's called only once per query,
-        # unless user code calls it directly.)
-        @cached_possible_types ||= possible_types_for_context(ctx)
-      else
-        possible_types_for_context(ctx)
-      end
-    end
-
-    def possible_types=(types)
-      # This is a re-assignment, so clear the previous values
-      @type_memberships = []
-      @cached_possible_types = nil
-      add_possible_types(types, **{})
-    end
-
-    def add_possible_types(types, **options)
-      @type_memberships ||= []
-      Array(types).each { |t|
-        @type_memberships << self.type_membership_class.new(self, t, **options)
-      }
-      nil
-    end
-
-    # Get a possible type of this {UnionType} by type name
-    # @param type_name [String]
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and is a member of this {UnionType}, (else `nil`)
-    def get_possible_type(type_name, ctx)
-      type = ctx.query.get_type(type_name)
-      type if type && ctx.query.warden.possible_types(self).include?(type)
-    end
-
-    # Check if a type is a possible type of this {UnionType}
-    # @param type [String, GraphQL::BaseType] Name of the type or a type definition
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [Boolean] True if the `type` exists and is a member of this {UnionType}, (else `nil`)
-    def possible_type?(type, ctx)
-      type_name = type.is_a?(String) ? type : type.graphql_name
-      !get_possible_type(type_name, ctx).nil?
-    end
-
-    def resolve_type(value, ctx)
-      ctx.query.resolve_type(self, value)
-    end
-
-    def resolve_type=(new_resolve_type_proc)
-      @resolve_type_proc = new_resolve_type_proc
-    end
-
-    def type_memberships=(type_memberships)
-      @type_memberships = type_memberships
-    end
-
-    private
-
-    def possible_types_for_context(ctx)
-      visible_types = []
-      @type_memberships.each do |type_membership|
-        if type_membership.visible?(ctx)
-          visible_types << BaseType.resolve_related_type(type_membership.object_type)
-        end
-      end
-      visible_types
-    end
-  end
-end