graphql 1.9.17 → 2.0.20

data/lib/graphql/subscriptions/subscription_root.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  class Subscriptions
-    # Extend this module in your subscription root when using {GraphQL::Execution::Interpreter}.
-    module SubscriptionRoot
-      def self.extended(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:
-            events << Subscriptions::Event.new(
-              name: field.name,
-              arguments: arguments,
-              context: context,
-              field: field,
-            )
-            # TODO compat with non-class-based subscriptions?
-            value
-          elsif context.query.subscription_topic == Subscriptions::Event.serialize(
-              field.name,
-              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
-      end
-    end
-  end
-end

data/lib/graphql/tracing/skylight_tracing.rb

@@ -1,62 +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 = {})
-        warn("GraphQL::Tracing::SkylightTracing is deprecated, 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
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Types
-    module Relay
-      class BaseField < GraphQL::Schema::Field
-        def initialize(edge_class: nil, **rest, &block)
-          @edge_class = edge_class
-          super(**rest, &block)
-        end
-
-        def to_graphql
-          field = super
-          if @edge_class
-            field.edge_class = @edge_class
-          end
-          field
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Types
-    module Relay
-      module BaseInterface
-        include GraphQL::Schema::Interface
-
-        field_class(Types::Relay::BaseField)
-
-        definition_methods do
-          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
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Types
-    module Relay
-      class BaseObject < GraphQL::Schema::Object
-        field_class(Types::Relay::BaseField)
-        class << self
-          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
-end

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

@@ -1,43 +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(
-        name: "node",
-        owner: nil,
-        type: GraphQL::Types::Relay::Node,
-        null: true,
-        description: "Fetches an object given its ID.",
-        relay_node_field: true,
-      ) do
-        argument :id, "ID!", required: true,
-          description: "ID of the object."
-
-        def resolve(obj, args, ctx)
-          ctx.schema.object_from_id(args[:id], ctx)
-        end
-
-        def resolve_field(obj, args, ctx)
-          resolve(obj, args, ctx)
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +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(
-        name: "nodes",
-        owner: nil,
-        type: [GraphQL::Types::Relay::Node, null: true],
-        null: false,
-        description: "Fetches a list of objects given a list of IDs.",
-        relay_nodes_field: true,
-      ) do
-        argument :ids, "[ID!]!", required: true,
-          description: "IDs of the objects."
-
-        def resolve(obj, args, ctx)
-          args[:ids].map { |id| ctx.schema.object_from_id(id, ctx) }
-        end
-
-        def resolve_field(obj, args, ctx)
-          resolve(obj, args, ctx)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/union_type.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # A Union is is a collection of object types which may appear in the same place.
-  #
-  # The members of a union are declared with `possible_types`.
-  #
-  # @example A union of object types
-  #   MediaUnion = GraphQL::UnionType.define do
-  #     name "Media"
-  #     description "Media objects which you can enjoy"
-  #     possible_types [AudioType, ImageType, VideoType]
-  #   end
-  #
-  # A union itself has no fields; only its members have fields.
-  # So, when you query, you must use fragment spreads to access fields.
-  #
-  # @example Querying for fields on union members
-  #  {
-  #    searchMedia(name: "Jens Lekman") {
-  #      ... on Audio { name, duration }
-  #      ... on Image { name, height, width }
-  #      ... on Video { name, length, quality }
-  #    }
-  #  }
-  #
-  class UnionType < GraphQL::BaseType
-    accepts_definitions :resolve_type, :type_membership_class,
-      possible_types: ->(target, possible_types, options = {}) { target.add_possible_types(possible_types, options) }
-    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.schema.possible_types(self, ctx).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