graphql 1.12.12 → 2.4.8

data/lib/graphql/static_validation/type_stack.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module StaticValidation
-    # - Ride along with `GraphQL::Language::Visitor`
-    # - Track type info, expose it to validators
-    class TypeStack
-      # These are jumping-off points for infering types down the tree
-      TYPE_INFERRENCE_ROOTS = [
-        GraphQL::Language::Nodes::OperationDefinition,
-        GraphQL::Language::Nodes::FragmentDefinition,
-      ]
-
-      # @return [GraphQL::Schema] the schema whose types are present in this document
-      attr_reader :schema
-
-      # When it enters an object (starting with query or mutation root), it's pushed on this stack.
-      # When it exits, it's popped off.
-      # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
-      attr_reader :object_types
-
-      # When it enters a field, it's pushed on this stack (useful for nested fields, args).
-      # When it exits, it's popped off.
-      # @return [Array<GraphQL::Field>] fields which have been entered
-      attr_reader :field_definitions
-
-      # Directives are pushed on, then popped off while traversing the tree
-      # @return [Array<GraphQL::Node::Directive>] directives which have been entered
-      attr_reader :directive_definitions
-
-      # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
-      attr_reader :argument_definitions
-
-      # @return [Array<String>] fields which have been entered (by their AST name)
-      attr_reader :path
-
-      # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
-      # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
-      def initialize(schema, visitor)
-        @schema = schema
-        @object_types = []
-        @field_definitions = []
-        @directive_definitions = []
-        @argument_definitions = []
-        @path = []
-
-        PUSH_STRATEGIES.each do |node_class, strategy|
-          visitor[node_class].enter << EnterWithStrategy.new(self, strategy)
-          visitor[node_class].leave << LeaveWithStrategy.new(self, strategy)
-        end
-      end
-
-      private
-
-
-      module FragmentWithTypeStrategy
-        def push(stack, node)
-          object_type = if node.type
-            stack.schema.get_type(node.type.name)
-          else
-            stack.object_types.last
-          end
-          if !object_type.nil?
-            object_type = object_type.unwrap
-          end
-          stack.object_types.push(object_type)
-          push_path_member(stack, node)
-        end
-
-        def pop(stack, node)
-          stack.object_types.pop
-          stack.path.pop
-        end
-      end
-
-      module FragmentDefinitionStrategy
-        extend FragmentWithTypeStrategy
-        module_function
-        def push_path_member(stack, node)
-          stack.path.push("fragment #{node.name}")
-        end
-      end
-
-      module InlineFragmentStrategy
-        extend FragmentWithTypeStrategy
-        module_function
-        def push_path_member(stack, node)
-          stack.path.push("...#{node.type ? " on #{node.type.to_query_string}" : ""}")
-        end
-      end
-
-      module OperationDefinitionStrategy
-        module_function
-        def push(stack, node)
-          # eg, QueryType, MutationType
-          object_type = stack.schema.root_type_for_operation(node.operation_type)
-          stack.object_types.push(object_type)
-          stack.path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
-        end
-
-        def pop(stack, node)
-          stack.object_types.pop
-          stack.path.pop
-        end
-      end
-
-      module FieldStrategy
-        module_function
-        def push(stack, node)
-          parent_type = stack.object_types.last
-          parent_type = parent_type.unwrap
-
-          field_definition = stack.schema.get_field(parent_type, node.name)
-          stack.field_definitions.push(field_definition)
-          if !field_definition.nil?
-            next_object_type = field_definition.type
-            stack.object_types.push(next_object_type)
-          else
-            stack.object_types.push(nil)
-          end
-          stack.path.push(node.alias || node.name)
-        end
-
-        def pop(stack, node)
-          stack.field_definitions.pop
-          stack.object_types.pop
-          stack.path.pop
-        end
-      end
-
-      module DirectiveStrategy
-        module_function
-        def push(stack, node)
-          directive_defn = stack.schema.directives[node.name]
-          stack.directive_definitions.push(directive_defn)
-        end
-
-        def pop(stack, node)
-          stack.directive_definitions.pop
-        end
-      end
-
-      module ArgumentStrategy
-        module_function
-        # Push `argument_defn` onto the stack.
-        # It's possible that `argument_defn` will be nil.
-        # Push it anyways so `pop` has something to pop.
-        def push(stack, node)
-          if stack.argument_definitions.last
-            arg_type = stack.argument_definitions.last.type.unwrap
-            if arg_type.kind.input_object?
-              argument_defn = arg_type.arguments[node.name]
-            else
-              argument_defn = nil
-            end
-          elsif stack.directive_definitions.last
-            argument_defn = stack.directive_definitions.last.arguments[node.name]
-          elsif stack.field_definitions.last
-            argument_defn = stack.field_definitions.last.arguments[node.name]
-          else
-            argument_defn = nil
-          end
-          stack.argument_definitions.push(argument_defn)
-          stack.path.push(node.name)
-        end
-
-        def pop(stack, node)
-          stack.argument_definitions.pop
-          stack.path.pop
-        end
-      end
-
-      module FragmentSpreadStrategy
-        module_function
-        def push(stack, node)
-          stack.path.push("... #{node.name}")
-        end
-
-        def pop(stack, node)
-          stack.path.pop
-        end
-      end
-
-      PUSH_STRATEGIES = {
-        GraphQL::Language::Nodes::FragmentDefinition => FragmentDefinitionStrategy,
-        GraphQL::Language::Nodes::InlineFragment => InlineFragmentStrategy,
-        GraphQL::Language::Nodes::FragmentSpread => FragmentSpreadStrategy,
-        GraphQL::Language::Nodes::Argument => ArgumentStrategy,
-        GraphQL::Language::Nodes::Field => FieldStrategy,
-        GraphQL::Language::Nodes::Directive => DirectiveStrategy,
-        GraphQL::Language::Nodes::OperationDefinition => OperationDefinitionStrategy,
-      }
-
-      class EnterWithStrategy
-        def initialize(stack, strategy)
-          @stack = stack
-          @strategy = strategy
-        end
-
-        def call(node, parent)
-          @strategy.push(@stack, node)
-        end
-      end
-
-      class LeaveWithStrategy
-        def initialize(stack, strategy)
-          @stack = stack
-          @strategy = strategy
-        end
-
-        def call(node, parent)
-          @strategy.pop(@stack, node)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/string_type.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition

data/lib/graphql/subscriptions/instrumentation.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Subscriptions
-    # Wrap the root fields of the subscription type with special logic for:
-    # - Registering the subscription during the first execution
-    # - Evaluating the triggered portion(s) of the subscription during later execution
-    class Instrumentation
-      def initialize(schema:)
-        @schema = schema
-      end
-
-      def instrument(type, field)
-        if type == @schema.subscription.graphql_definition
-          # This is a root field of `subscription`
-          subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
-          field.redefine(resolve: subscribing_resolve_proc)
-        else
-          field
-        end
-      end
-
-      # If needed, prepare to gather events which this query subscribes to
-      def before_query(query)
-        if query.subscription? && !query.subscription_update?
-          query.context.namespace(:subscriptions)[:events] = []
-        end
-      end
-
-      # After checking the root fields, pass the gathered events to the store
-      def after_query(query)
-        events = query.context.namespace(:subscriptions)[:events]
-        if events && events.any?
-          @schema.subscriptions.write_subscription(query, events)
-        end
-      end
-
-      private
-
-      class SubscriptionRegistrationResolve
-        def initialize(inner_proc)
-          @inner_proc = inner_proc
-        end
-
-        # Wrap the proc with subscription registration logic
-        def call(obj, args, ctx)
-          result = nil
-          if @inner_proc && !@inner_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
-            result = @inner_proc.call(obj, args, ctx)
-          end
-
-          events = ctx.namespace(:subscriptions)[:events]
-
-          if events
-            # This is the first execution, so gather an Event
-            # for the backend to register:
-            events << Subscriptions::Event.new(
-              name: ctx.field.name,
-              arguments: args,
-              context: ctx,
-            )
-            result
-          elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
-            if !result.nil?
-              result
-            elsif obj.is_a?(GraphQL::Schema::Object)
-              # The root object is _already_ the subscription update:
-              obj.object
-            else
-              obj
-            end
-          else
-            # This is a subscription update, but this event wasn't triggered.
-            ctx.skip
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/subscriptions/subscription_root.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  class Subscriptions
-    # @api private
-    # @deprecated This module is no longer needed.
-    module SubscriptionRoot
-      def self.extended(child_cls)
-        GraphQL::Deprecation.warn "`extend GraphQL::Subscriptions::SubscriptionRoot` is no longer required; you can remove it from your Subscription type (#{child_cls})"
-        child_cls.include(InstanceMethods)
-      end
-
-      # This is for maintaining backwards compatibility:
-      # if a subscription field is created without a `subscription:` resolver class,
-      # then implement the method with the previous default behavior.
-      module InstanceMethods
-        def skip_subscription_root(*)
-          if context.query.subscription_update?
-            object
-          else
-            context.skip
-          end
-        end
-      end
-
-      def field(*args, extensions: [], **rest, &block)
-        extensions += [Extension]
-        # Backwards-compat for schemas
-        if !rest[:subscription]
-          name = args.first
-          alias_method(name, :skip_subscription_root)
-        end
-        super(*args, extensions: extensions, **rest, &block)
-      end
-
-      class Extension < GraphQL::Schema::FieldExtension
-        def after_resolve(value:, context:, object:, arguments:, **rest)
-          if value.is_a?(GraphQL::ExecutionError)
-            value
-          elsif (events = context.namespace(:subscriptions)[:events])
-            # This is the first execution, so gather an Event
-            # for the backend to register:
-            event = Subscriptions::Event.new(
-              name: field.name,
-              arguments: arguments_without_field_extras(arguments: arguments),
-              context: context,
-              field: field,
-            )
-            events << event
-            value
-          elsif context.query.subscription_topic == Subscriptions::Event.serialize(
-              field.name,
-              arguments_without_field_extras(arguments: arguments),
-              field,
-              scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
-            )
-            # This is a subscription update. The resolver returned `skip` if it should be skipped,
-            # or else it returned an object to resolve the update.
-            value
-          else
-            # This is a subscription update, but this event wasn't triggered.
-            context.skip
-          end
-        end
-
-        private
-
-        def arguments_without_field_extras(arguments:)
-          arguments.dup.tap do |event_args|
-            field.extras.each { |k| event_args.delete(k) }
-          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/default_relay.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Types
-    module Relay
-      module DefaultRelay
-        def self.extended(child_class)
-          child_class.default_relay(true)
-        end
-
-        def default_relay(new_value)
-          @default_relay = new_value
-        end
-
-        def default_relay?
-          !!@default_relay
-        end
-
-        def to_graphql
-          type_defn = super
-          type_defn.default_relay = default_relay?
-          type_defn
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Types
-    module Relay
-      # This can be used for implementing `Query.node(id: ...)`,
-      # or use it for inspiration for your own field definition.
-      #
-      # @example Adding this field directly
-      #   add_field(GraphQL::Types::Relay::NodeField)
-      #
-      # @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
-      #
-      NodeField = GraphQL::Schema::Field.new(**HasNodeField.field_options, &HasNodeField.field_block)
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Types
-    module Relay
-      # This can be used for implementing `Query.nodes(ids: ...)`,
-      # or use it for inspiration for your own field definition.
-      #
-      # @example Adding this field directly
-      #   add_field(GraphQL::Types::Relay::NodesField)
-      #
-      # @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
-      #
-      NodesField = GraphQL::Schema::Field.new(**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
-
-    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