graphql 1.13.23 → 2.0.0

data/lib/graphql/railtie.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module GraphQL
   class Railtie < Rails::Railtie
     config.before_configuration do
@@ -10,108 +9,5 @@ module GraphQL
         Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
       end
     end
-
-    rake_tasks do
-      # Defer this so that you only need the `parser` gem when you _run_ the upgrader
-      def load_upgraders
-        require_relative './upgrader/member'
-        require_relative './upgrader/schema'
-      end
-
-      namespace :graphql do
-        task :upgrade, [:dir] do |t, args|
-          unless (dir = args[:dir])
-            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
-             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
-          end
-
-          Dir[dir].each do |file|
-            # Members (types, interfaces, etc.)
-            if file =~ /.*_(type|interface|enum|union|)\.rb$/
-              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
-            end
-          end
-
-          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
-          puts "Don't forget to create the base objects. For example, you could run:"
-          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
-        end
-
-        namespace :upgrade do
-          task :create_base_objects, [:base_dir] do |t, args|
-            unless (base_dir = args[:base_dir])
-              fail 'You have to give me a directory where your GraphQL types live. ' \
-                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
-            end
-
-            destination_file = File.join(base_dir, "types", "base_scalar.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_input_object.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_enum.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_union.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseUnion < GraphQL::Schema::Union\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_interface.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_object.rb")
-            unless File.exists?(destination_file)
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseObject < GraphQL::Schema::Object\nend"
-              end
-            end
-          end
-
-          task :schema, [:schema_file] do |t, args|
-            schema_file = args.schema_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
-
-            puts "- Transforming schema #{schema_file}"
-            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-
-          task :member, [:member_file] do |t, args|
-            member_file = args.member_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
-            next unless upgrader.upgradeable?
-
-            puts "- Transforming member #{member_file}"
-            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-        end
-      end
-    end
   end
 end

data/lib/graphql/relay/range_add.rb

@@ -35,10 +35,6 @@ module GraphQL
       # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
       # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
       def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
-        if context.nil?
-          caller_loc = caller(2, 1).first
-          GraphQL::Deprecation.warn("`context: ...` will be required by `RangeAdd.new` in GraphQL-Ruby 2.0. Add `context: context` to the call at #{caller_loc}.")
-        end
         if context && context.schema.new_connections?
           conn_class = context.schema.connections.wrapper_for(collection)
           # The rest will be added by ConnectionExtension

data/lib/graphql/relay.rb

@@ -1,18 +1,3 @@
 # frozen_string_literal: true
 
-require 'graphql/relay/page_info'
-require 'graphql/relay/edge'
-require 'graphql/relay/edge_type'
-require 'graphql/relay/edges_instrumentation'
-require 'graphql/relay/base_connection'
-require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'
-require 'graphql/relay/relation_connection'
-require 'graphql/relay/mongo_relation_connection'
-require 'graphql/relay/global_id_resolve'
-require 'graphql/relay/mutation'
-require 'graphql/relay/node'
-require 'graphql/relay/connection_instrumentation'
-require 'graphql/relay/connection_resolve'
-require 'graphql/relay/connection_type'
-require 'graphql/relay/type_extensions'

data/lib/graphql/schema/addition.rb

@@ -136,14 +136,7 @@ module GraphQL
       end
 
       def add_type(type, owner:, late_types:, path:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
         end

data/lib/graphql/schema/argument.rb

@@ -2,8 +2,6 @@
 module GraphQL
   class Schema
     class Argument
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasDirectives
@@ -44,12 +42,11 @@ module GraphQL
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
-      # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
       # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -70,7 +67,6 @@ module GraphQL
         @prepare = prepare
         @ast_node = ast_node
         @from_resolver = from_resolver
-        @method_access = method_access
         self.deprecation_reason = deprecation_reason
 
         if directives
@@ -169,26 +165,6 @@ module GraphQL
         true
       end
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        argument = GraphQL::Argument.new
-        argument.name = @name
-        argument.type = -> { type }
-        argument.description = @description
-        argument.metadata[:type_class] = self
-        argument.as = @as
-        argument.ast_node = ast_node
-        argument.method_access = @method_access
-        if NO_DEFAULT != @default_value
-          argument.default_value = @default_value
-        end
-        if self.deprecation_reason
-          argument.deprecation_reason = self.deprecation_reason
-        end
-        argument
-      end
-
       def type=(new_type)
         validate_input_type(new_type)
         # This isn't true for LateBoundTypes, but we can assume those will

data/lib/graphql/schema/build_from_definition.rb

@@ -365,7 +365,6 @@ module GraphQL
               deprecation_reason: builder.build_deprecation_reason(argument_defn.directives),
               ast_node: argument_defn,
               camelize: false,
-              method_access: false,
               directives: prepare_directives(argument_defn, type_resolver),
               **default_value_kwargs
             )

data/lib/graphql/schema/directive.rb

@@ -8,7 +8,6 @@ module GraphQL
     # - {.resolve}: Wraps field resolution (so it should call `yield` to continue)
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
-      extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -22,7 +21,7 @@ module GraphQL
         # but downcase the first letter.
         def default_graphql_name
           @default_graphql_name ||= begin
-            camelized_name = super.dup
+            camelized_name = super
             camelized_name[0] = camelized_name[0].downcase
             camelized_name
           end
@@ -55,26 +54,6 @@ module GraphQL
           default_directive
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        def to_graphql
-          defn = GraphQL::Directive.new
-          defn.name = self.graphql_name
-          defn.description = self.description
-          defn.locations = self.locations
-          defn.default_directive = self.default_directive
-          defn.ast_node = ast_node
-          defn.metadata[:type_class] = self
-          all_argument_definitions.each do |arg_defn|
-            arg_graphql = arg_defn.to_graphql(silence_deprecation_warning: true)
-            defn.arguments[arg_graphql.name] = arg_graphql # rubocop:disable Development/ContextIsPassedCop -- legacy-related
-          end
-          # Make a reference to a classic-style Arguments class
-          defn.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(defn)
-
-          defn
-        end
-
         # If false, this part of the query won't be evaluated
         def include?(_object, arguments, context)
           static_include?(arguments, context)

data/lib/graphql/schema/enum.rb

@@ -20,10 +20,9 @@ module GraphQL
   #   end
   class Schema
     class Enum < GraphQL::Schema::Member
-      extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
-      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      class UnresolvedValueError < GraphQL::Error
         def initialize(value:, enum:, context:)
           fix_message = ", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
           message = if (cp = context[:current_path]) && (cf = context[:current_field])
@@ -108,22 +107,6 @@ module GraphQL
           enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 
-        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-        # @return [GraphQL::EnumType]
-        def to_graphql
-          enum_type = GraphQL::EnumType.new
-          enum_type.name = graphql_name
-          enum_type.description = description
-          enum_type.introspection = introspection
-          enum_type.ast_node = ast_node
-          values.each do |name, val|
-            enum_type.add_value(val.deprecated_to_graphql)
-          end
-          enum_type.metadata[:type_class] = self
-          enum_type
-        end
-
         # @return [Class] for handling `value(...)` inputs and building `GraphQL::Enum::EnumValue`s out of them
         def enum_value_class(new_enum_value_class = nil)
           if new_enum_value_class
@@ -139,8 +122,9 @@ module GraphQL
           GraphQL::TypeKinds::ENUM
         end
 
-        def validate_non_null_input(value_name, ctx, max_errors: nil)
+        def validate_non_null_input(value_name, ctx)
           result = GraphQL::Query::InputValidationResult.new
+
           allowed_values = ctx.warden.enum_values(self)
           matching_value = allowed_values.find { |v| v.graphql_name == value_name }
 

data/lib/graphql/schema/enum_value.rb

@@ -13,12 +13,6 @@ module GraphQL
     #       # arguments to `value(...)` in Enum classes are passed here
     #       super
     #     end
-    #
-    #     def to_graphql
-    #       enum_value = super
-    #       # customize the derived GraphQL::EnumValue here
-    #       enum_value
-    #     end
     #   end
     #
     #   class BaseEnum < GraphQL::Schema::Enum
@@ -26,8 +20,6 @@ module GraphQL
     #     enum_value_class CustomEnumValue
     #   end
     class EnumValue < GraphQL::Schema::Member
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasDirectives
@@ -73,20 +65,6 @@ module GraphQL
         @value
       end
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      # @return [GraphQL::EnumType::EnumValue] A runtime-ready object derived from this object
-      def to_graphql
-        enum_value = GraphQL::EnumType::EnumValue.new
-        enum_value.name = @graphql_name
-        enum_value.description = @description
-        enum_value.value = @value
-        enum_value.deprecation_reason = self.deprecation_reason
-        enum_value.metadata[:type_class] = self
-        enum_value.ast_node = ast_node
-        enum_value
-      end
-
       def inspect
         "#<#{self.class} #{path} @value=#{@value.inspect}#{description ? " @description=#{description.inspect}" : ""}>"
       end