graphql 1.12.12 → 2.2.14

data/lib/graphql/backwards_compatibility.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # Helpers for migrating in a backwards-compatible way
-  # Remove this in GraphQL-Ruby 2.0, when all users of it will be gone.
-  # @api private
-  module BackwardsCompatibility
-    module_function
-    # Given a callable whose API used to take `from` arguments,
-    # check its arity, and if needed, apply a wrapper so that
-    # it can be called with `to` arguments.
-    # If a wrapper is applied, warn the application with `name`.
-    #
-    # If `last`, then use the last arguments to call the function.
-    def wrap_arity(callable, from:, to:, name:, last: false)
-      arity = get_arity(callable)
-      if arity == to || arity < 0
-        # It already matches, return it as is
-        callable
-      elsif arity == from
-        # It has the old arity, so wrap it with an arity converter
-        message ="#{name} with #{from} arguments is deprecated, it now accepts #{to} arguments, see:"
-        backtrace = caller(0, 20)
-        # Find the first line in the trace that isn't library internals:
-        user_line = backtrace.find {|l| l !~ /lib\/graphql/ }
-        GraphQL::Deprecation.warn(message + "\n" + user_line + "\n")
-        wrapper = last ? LastArgumentsWrapper : FirstArgumentsWrapper
-        wrapper.new(callable, from)
-      else
-        raise "Can't wrap #{callable} (arity: #{arity}) to have arity #{to}"
-      end
-    end
-
-    def get_arity(callable)
-      case callable
-      when Method, Proc
-        callable.arity
-      else
-        callable.method(:call).arity
-      end
-    end
-
-    class FirstArgumentsWrapper
-      def initialize(callable, old_arity)
-        @callable = callable
-        @old_arity = old_arity
-      end
-
-      def call(*args)
-        backwards_compat_args = args.first(@old_arity)
-        @callable.call(*backwards_compat_args)
-      end
-    end
-
-    class LastArgumentsWrapper < FirstArgumentsWrapper
-      def call(*args)
-        backwards_compat_args = args.last(@old_arity)
-        @callable.call(*backwards_compat_args)
-      end
-    end
-  end
-end

data/lib/graphql/base_type.rb

@@ -1,230 +0,0 @@
-# frozen_string_literal: true
-require "graphql/relay/type_extensions"
-
-module GraphQL
-  # The parent for all type classes.
-  class BaseType
-    include GraphQL::Define::NonNullWithBang
-    include GraphQL::Define::InstanceDefinable
-    include GraphQL::Relay::TypeExtensions
-
-    accepts_definitions :name, :description,
-        :introspection,
-        :default_scalar,
-        :default_relay,
-        {
-          connection: GraphQL::Define::AssignConnection,
-          global_id_field: GraphQL::Define::AssignGlobalIdField,
-        }
-
-    ensure_defined(:graphql_name, :name, :description, :introspection?, :default_scalar?)
-
-    attr_accessor :ast_node
-
-    def initialize
-      @introspection = false
-      @default_scalar = false
-      @default_relay = false
-    end
-
-    def initialize_copy(other)
-      super
-      # Reset these derived defaults
-      @connection_type = nil
-      @edge_type = nil
-    end
-
-    # @return [String] the name of this type, must be unique within a Schema
-    attr_reader :name
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_name :name
-    # Future-compatible alias
-    # @see {GraphQL::SchemaMember}
-    alias :graphql_definition :itself
-
-    def type_class
-      metadata[:type_class]
-    end
-
-    def name=(name)
-      GraphQL::NameValidator.validate!(name)
-      @name = name
-    end
-
-    # @return [String, nil] a description for this type
-    attr_accessor :description
-
-    # @return [Boolean] Is this type a predefined introspection type?
-    def introspection?
-      @introspection
-    end
-
-    # @return [Boolean] Is this type a built-in scalar type? (eg, `String`, `Int`)
-    def default_scalar?
-      @default_scalar
-    end
-
-    # @return [Boolean] Is this type a built-in Relay type? (`Node`, `PageInfo`)
-    def default_relay?
-      @default_relay
-    end
-
-    # @api private
-    attr_writer :introspection, :default_scalar, :default_relay
-
-    # @param other [GraphQL::BaseType] compare to this object
-    # @return [Boolean] are these types equivalent? (incl. non-null, list)
-    # @see {ModifiesAnotherType#==} for override on List & NonNull types
-    def ==(other)
-      other.is_a?(GraphQL::BaseType) && self.name == other.name
-    end
-
-    # If this type is modifying an underlying type,
-    # return the underlying type. (Otherwise, return `self`.)
-    def unwrap
-      self
-    end
-
-    # @return [GraphQL::NonNullType] a non-null version of this type
-    def to_non_null_type
-      GraphQL::NonNullType.new(of_type: self)
-    end
-
-    # @return [GraphQL::ListType] a list version of this type
-    def to_list_type
-      GraphQL::ListType.new(of_type: self)
-    end
-
-    module ModifiesAnotherType
-      def unwrap
-        self.of_type.unwrap
-      end
-
-      def ==(other)
-        other.is_a?(ModifiesAnotherType) && other.of_type == of_type
-      end
-    end
-
-    # Find out which possible type to use for `value`.
-    # Returns self if there are no possible types (ie, not Union or Interface)
-    def resolve_type(value, ctx)
-      self
-    end
-
-    # Print the human-readable name of this type using the query-string naming pattern
-    def to_s
-      name
-    end
-
-    alias :inspect :to_s
-    alias :to_type_signature :to_s
-
-    def valid_isolated_input?(value)
-      valid_input?(value, GraphQL::Query::NullContext)
-    end
-
-    def validate_isolated_input(value)
-      validate_input(value, GraphQL::Query::NullContext)
-    end
-
-    def coerce_isolated_input(value)
-      coerce_input(value, GraphQL::Query::NullContext)
-    end
-
-    def coerce_isolated_result(value)
-      coerce_result(value, GraphQL::Query::NullContext)
-    end
-
-    def valid_input?(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("valid_isolated_input?")
-        ctx = GraphQL::Query::NullContext
-      end
-
-      validate_input(value, ctx).valid?
-    end
-
-    def validate_input(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("validate_isolated_input")
-        ctx = GraphQL::Query::NullContext
-      end
-
-      if value.nil?
-        GraphQL::Query::InputValidationResult.new
-      else
-        validate_non_null_input(value, ctx)
-      end
-    end
-
-    def coerce_input(value, ctx = nil)
-      if value.nil?
-        nil
-      else
-        if ctx.nil?
-          warn_deprecated_coerce("coerce_isolated_input")
-          ctx = GraphQL::Query::NullContext
-        end
-        coerce_non_null_input(value, ctx)
-      end
-    end
-
-    def coerce_result(value, ctx)
-      raise GraphQL::RequiredImplementationMissingError
-    end
-
-    # Types with fields may override this
-    # @param name [String] field name to lookup for this type
-    # @return [GraphQL::Field, nil]
-    def get_field(name)
-      nil
-    end
-
-    # During schema definition, types can be defined inside procs or as strings.
-    # This function converts it to a type instance
-    # @return [GraphQL::BaseType]
-    def self.resolve_related_type(type_arg)
-      case type_arg
-      when Proc
-        # lazy-eval it, then try again
-        resolve_related_type(type_arg.call)
-      when String
-        # Get a constant by this name
-        resolve_related_type(Object.const_get(type_arg))
-      else
-        if type_arg.respond_to?(:graphql_definition)
-          type_arg.graphql_definition
-        else
-          type_arg
-        end
-      end
-    end
-
-    # Return a GraphQL string for the type definition
-    # @param schema [GraphQL::Schema]
-    # @param printer [GraphQL::Schema::Printer]
-    # @see {GraphQL::Schema::Printer#initialize for additional options}
-    # @return [String] type definition
-    def to_definition(schema, printer: nil, **args)
-      printer ||= GraphQL::Schema::Printer.new(schema, **args)
-      printer.print_type(self)
-    end
-
-    # Returns true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
-    def non_null?
-      false
-    end
-
-    # Returns true if this is a list type. A non-nullable list is considered a list.
-    def list?
-      false
-    end
-
-    private
-
-    def warn_deprecated_coerce(alt_method_name)
-      GraphQL::Deprecation.warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
-    end
-  end
-end

data/lib/graphql/boolean_type.rb

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

data/lib/graphql/compatibility/execution_specification/counter_schema.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Compatibility
-    module ExecutionSpecification
-      module CounterSchema
-        def self.build(execution_strategy)
-          counter_type = nil
-          schema = nil
-
-          has_count_interface = GraphQL::InterfaceType.define do
-            name "HasCount"
-            field :count, types.Int
-            field :counter, ->{ has_count_interface }
-          end
-
-          counter_type = GraphQL::ObjectType.define do
-            name "Counter"
-            interfaces [has_count_interface]
-            field :count, types.Int, resolve: ->(o,a,c) { schema.metadata[:count] += 1 }
-            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
-          end
-
-          alt_counter_type = GraphQL::ObjectType.define do
-            name "AltCounter"
-            interfaces [has_count_interface]
-            field :count, types.Int, resolve: ->(o,a,c) { schema.metadata[:count] += 1 }
-            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
-          end
-
-          has_counter_interface = GraphQL::InterfaceType.define do
-            name "HasCounter"
-            field :counter, has_count_interface
-          end
-
-          query_type = GraphQL::ObjectType.define do
-            name "Query"
-            interfaces [has_counter_interface]
-            field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
-          end
-
-          schema = GraphQL::Schema.define(
-            query: query_type,
-            resolve_type: ->(t, o, c) { o == :counter ? counter_type : nil },
-            orphan_types: [alt_counter_type, counter_type],
-            query_execution_strategy: execution_strategy,
-          )
-          schema.metadata[:count] = 0
-          schema
-        end
-      end
-    end
-  end
-end

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Compatibility
-    module ExecutionSpecification
-      module SpecificationSchema
-        BOGUS_NODE = OpenStruct.new({ bogus: true })
-
-        DATA = {
-          "1001" => OpenStruct.new({
-            name: "Fannie Lou Hamer",
-            birthdate: Time.new(1917, 10, 6),
-            organization_ids: [],
-          }),
-          "1002" => OpenStruct.new({
-            name: "John Lewis",
-            birthdate: Time.new(1940, 2, 21),
-            organization_ids: ["2001"],
-          }),
-          "1003" => OpenStruct.new({
-            name: "Diane Nash",
-            birthdate: Time.new(1938, 5, 15),
-            organization_ids: ["2001", "2002"],
-          }),
-          "1004" => OpenStruct.new({
-            name: "Ralph Abernathy",
-            birthdate: Time.new(1926, 3, 11),
-            organization_ids: ["2002"],
-          }),
-          "2001" => OpenStruct.new({
-            name: "SNCC",
-            leader_id: nil, # fail on purpose
-          }),
-          "2002" => OpenStruct.new({
-            name: "SCLC",
-            leader_id: "1004",
-          }),
-          "2003" => BOGUS_NODE,
-        }
-
-        # A list object must implement #each
-        class CustomCollection
-          def initialize(storage)
-            @storage = storage
-          end
-
-          def each(&block)
-            @storage.each(&block)
-          end
-        end
-
-        module TestMiddleware
-          def self.call(parent_type, parent_object, field_definition, field_args, query_context, &next_middleware)
-            query_context[:middleware_log] && query_context[:middleware_log] << field_definition.name
-            next_middleware.call
-          end
-        end
-
-        def self.build(execution_strategy)
-          organization_type = nil
-
-          timestamp_type = GraphQL::ScalarType.define do
-            name "Timestamp"
-            coerce_input ->(value, _ctx) { Time.at(value.to_i) }
-            coerce_result ->(value, _ctx) { value.to_i }
-          end
-
-          named_entity_interface_type = GraphQL::InterfaceType.define do
-            name "NamedEntity"
-            field :name, !types.String
-          end
-
-          person_type = GraphQL::ObjectType.define do
-            name "Person"
-            interfaces [named_entity_interface_type]
-            field :name, !types.String
-            field :birthdate, timestamp_type
-            field :age, types.Int do
-              argument :on, !timestamp_type
-              resolve ->(obj, args, ctx) {
-                if obj.birthdate.nil?
-                  nil
-                else
-                  age_on = args[:on]
-                  age_years = age_on.year - obj.birthdate.year
-                  this_year_birthday = Time.new(age_on.year, obj.birthdate.month, obj.birthdate.day)
-                  if this_year_birthday > age_on
-                    age_years -= 1
-                  end
-                end
-                age_years
-              }
-            end
-            field :organizations, types[organization_type] do
-              resolve ->(obj, args, ctx) {
-                CustomCollection.new(obj.organization_ids.map { |id| DATA[id] })
-              }
-            end
-            field :first_organization, !organization_type do
-              resolve ->(obj, args, ctx) {
-                DATA[obj.organization_ids.first]
-              }
-            end
-          end
-
-          organization_type = GraphQL::ObjectType.define do
-            name "Organization"
-            interfaces [named_entity_interface_type]
-            field :name, !types.String
-            field :leader, !person_type do
-              resolve ->(obj, args, ctx) {
-                DATA[obj.leader_id] || (ctx[:return_error] ? ExecutionError.new("Error on Nullable") : nil)
-              }
-            end
-            field :returnedError, types.String do
-              resolve ->(o, a, c) {
-                GraphQL::ExecutionError.new("This error was returned")
-              }
-            end
-            field :raisedError, types.String do
-              resolve ->(o, a, c) {
-                raise GraphQL::ExecutionError.new("This error was raised")
-              }
-            end
-
-            field :nodePresence, !types[!types.Boolean] do
-              resolve ->(o, a, ctx) {
-                [
-                  ctx.irep_node.is_a?(GraphQL::InternalRepresentation::Node),
-                  ctx.ast_node.is_a?(GraphQL::Language::Nodes::AbstractNode),
-                  false, # just testing
-                ]
-              }
-            end
-          end
-
-          node_union_type = GraphQL::UnionType.define do
-            name "Node"
-            possible_types [person_type, organization_type]
-          end
-
-          query_type = GraphQL::ObjectType.define do
-            name "Query"
-            field :node, node_union_type do
-              argument :id, !types.ID
-              resolve ->(obj, args, ctx) {
-                obj[args[:id]]
-              }
-            end
-
-            field :requiredNode, node_union_type.to_non_null_type do
-              argument :id, !types.ID
-              resolve ->(obj, args, ctx) {
-                obj[args[:id]]
-              }
-            end
-
-            field :organization, !organization_type do
-              argument :id, !types.ID
-              resolve ->(obj, args, ctx) {
-                if args[:id].start_with?("2")
-                  obj[args[:id]]
-                else
-                  # test context.skip
-                  ctx.skip
-                end
-              }
-            end
-
-            field :organizations, types[organization_type] do
-              resolve ->(obj, args, ctx) {
-                [obj["2001"], obj["2002"]]
-              }
-            end
-          end
-
-          GraphQL::Schema.define do
-            query_execution_strategy execution_strategy
-            query query_type
-
-            resolve_type ->(type, obj, ctx) {
-              if obj.respond_to?(:birthdate)
-                person_type
-              elsif obj.respond_to?(:leader_id)
-                organization_type
-              else
-                nil
-              end
-            }
-
-            type_error ->(err, ctx) {
-              ctx[:type_errors] && (ctx[:type_errors] << err.value)
-              ctx[:gobble] || GraphQL::Schema::DefaultTypeError.call(err, ctx)
-            }
-            middleware(TestMiddleware)
-          end
-        end
-      end
-    end
-  end
-end