graphql 1.9.21 → 1.10.0.pre1

data/lib/graphql/schema/directive/feature.rb

@@ -58,7 +58,7 @@ module GraphQL
         # @param context [GraphQL::Query::Context]
         # @return [Boolean] If truthy, execution will continue
         def self.enabled?(flag_name, object, context)
-          raise GraphQL::RequiredImplementationMissingError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
+          raise NotImplementedError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
         end
       end
     end

data/lib/graphql/schema/enum.rb

@@ -53,6 +53,7 @@ module GraphQL
           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.to_graphql)
           end

data/lib/graphql/schema/enum_value.rb

@@ -28,6 +28,7 @@ module GraphQL
     class EnumValue < GraphQL::Schema::Member
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
+      include GraphQL::Schema::Member::HasAstNode
 
       attr_reader :graphql_name
 
@@ -37,12 +38,13 @@ module GraphQL
       # @return [String] Explains why this value was deprecated (if present, this will be marked deprecated in introspection)
       attr_accessor :deprecation_reason
 
-      def initialize(graphql_name, desc = nil, owner:, description: nil, value: nil, deprecation_reason: nil, &block)
+      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, description: nil, value: nil, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
         @description = desc || description
         @value = value.nil? ? @graphql_name : value
         @deprecation_reason = deprecation_reason
         @owner = owner
+        @ast_node = ast_node
 
         if block_given?
           instance_eval(&block)
@@ -71,6 +73,7 @@ module GraphQL
         enum_value.value = @value
         enum_value.deprecation_reason = @deprecation_reason
         enum_value.metadata[:type_class] = self
+        enum_value.ast_node = ast_node
         enum_value
       end
 

data/lib/graphql/schema/field.rb

@@ -13,8 +13,8 @@ module GraphQL
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
+      include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
-      extend GraphQL::Schema::FindInheritedValue
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
@@ -37,7 +37,7 @@ module GraphQL
       # @return [Class] The type that this field belongs to
       attr_reader :owner
 
-      # @return [Symobol] the original name of the field, passed in by the user
+      # @return [Symbol] the original name of the field, passed in by the user
       attr_reader :original_name
 
       # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one
@@ -136,20 +136,9 @@ module GraphQL
         end
       end
 
-      # This extension is applied to fields when {#connection?} is true.
-      #
-      # You can override it in your base field definition.
-      # @return [Class] A {FieldExtension} subclass for implementing pagination behavior.
-      # @example Configuring a custom extension
-      #   class Types::BaseField < GraphQL::Schema::Field
-      #     connection_extension(MyCustomExtension)
-      #   end
-      def self.connection_extension(new_extension_class = nil)
-        if new_extension_class
-          @connection_extension = new_extension_class
-        else
-          @connection_extension ||= find_inherited_value(:connection_extension, ConnectionExtension)
-        end
+      # @return [Boolean] Should we warn if this field's name conflicts with a built-in method?
+      def method_conflict_warning?
+        @method_conflict_warning
       end
 
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
@@ -175,7 +164,9 @@ module GraphQL
       # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
       # @param extensions [Array<Class, Hash<Class => Object>>] Named extensions to apply to this field (see also {#extension})
       # @param trace [Boolean] If true, a {GraphQL::Tracing} tracer will measure this scalar field
-      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, arguments: {}, &definition_block)
+      # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
+      # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: nil, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: [], extensions: [], resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, arguments: {}, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -236,6 +227,8 @@ module GraphQL
         @trace = trace
         @relay_node_field = relay_node_field
         @relay_nodes_field = relay_nodes_field
+        @ast_node = ast_node
+        @method_conflict_warning = method_conflict_warning
 
         # Override the default from HasArguments
         @own_arguments = {}
@@ -263,7 +256,7 @@ module GraphQL
         # The problem with putting this after the definition_block
         # is that it would override arguments
         if connection?
-          self.extension(self.class.connection_extension)
+          self.extension(ConnectionExtension)
         end
 
         if definition_block
@@ -416,6 +409,7 @@ module GraphQL
         field_defn.introspection = @introspection
         field_defn.complexity = @complexity
         field_defn.subscription_scope = @subscription_scope
+        field_defn.ast_node = ast_node
 
         arguments.each do |name, defn|
           arg_graphql = defn.to_graphql
@@ -439,8 +433,11 @@ module GraphQL
 
       def type
         @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
-      rescue
-        raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: #{$!.message}", $!.backtrace
+      rescue GraphQL::Schema::InvalidDocumentError => err
+        # Let this propagate up
+        raise err
+      rescue StandardError => err
+        raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: (#{err.class}) #{err.message}", err.backtrace
       end
 
       def visible?(context)
@@ -459,14 +456,14 @@ module GraphQL
         end
       end
 
-      def authorized?(object, context)
+      def authorized?(object, args, context)
         if @resolver_class
           # The resolver will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
           # Faster than `.any?`
           arguments.each_value do |arg|
-            if !arg.authorized?(object, context)
+            if args.key?(arg.keyword) && !arg.authorized?(object, args[arg.keyword], context)
               return false
             end
           end
@@ -485,21 +482,22 @@ module GraphQL
           # Some legacy fields can have `nil` here, not exactly sure why.
           # @see https://github.com/rmosolgo/graphql-ruby/issues/1990 before removing
           inner_obj = after_obj && after_obj.object
-          if authorized?(inner_obj, query_ctx)
-            ruby_args = to_ruby_args(after_obj, args, ctx)
-            # Then if it passed, resolve the field
-            if @resolve_proc
-              # Might be nil, still want to call the func in that case
-              with_extensions(inner_obj, ruby_args, query_ctx) do |extended_obj, extended_args|
-                # Pass the GraphQL args here for compatibility:
-                @resolve_proc.call(extended_obj, args, ctx)
+          ctx.schema.after_lazy(to_ruby_args(after_obj, args, ctx)) do |ruby_args|
+            if authorized?(inner_obj, ruby_args, query_ctx)
+              # Then if it passed, resolve the field
+              if @resolve_proc
+                # Might be nil, still want to call the func in that case
+                with_extensions(inner_obj, ruby_args, query_ctx) do |extended_obj, extended_args|
+                  # Pass the GraphQL args here for compatibility:
+                  @resolve_proc.call(extended_obj, args, ctx)
+                end
+              else
+                public_send_field(after_obj, ruby_args, ctx)
               end
             else
-              public_send_field(after_obj, ruby_args, ctx)
+              err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
+              query_ctx.schema.unauthorized_field(err)
             end
-          else
-            err = GraphQL::UnauthorizedFieldError.new(object: inner_obj, type: obj.class, context: ctx, field: self)
-            query_ctx.schema.unauthorized_field(err)
           end
         end
       end
@@ -516,7 +514,7 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, ctx)
+          if self.authorized?(application_object, args, ctx)
             # Apply field extensions
             with_extensions(object, args, ctx) do |extended_obj, extended_args|
               field_receiver = if @resolver_class
@@ -525,7 +523,7 @@ module GraphQL
                 else
                   extended_obj
                 end
-                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
+                @resolver_class.new(object: resolver_obj, context: ctx)
               else
                 extended_obj
               end
@@ -594,12 +592,12 @@ module GraphQL
 
       # @param ctx [GraphQL::Query::Context::FieldResolutionContext]
       def fetch_extra(extra_name, ctx)
-        if extra_name != :path && respond_to?(extra_name)
+        if extra_name != :path && extra_name != :ast_node && respond_to?(extra_name)
           self.public_send(extra_name)
         elsif ctx.respond_to?(extra_name)
           ctx.public_send(extra_name)
         else
-          raise GraphQL::RequiredImplementationMissingError, "Unknown field extra for #{self.path}: #{extra_name.inspect}"
+          raise NotImplementedError, "Unknown field extra for #{self.path}: #{extra_name.inspect}"
         end
       end
 
@@ -642,7 +640,7 @@ module GraphQL
             if extended_obj.is_a?(GraphQL::Schema::Object)
               extended_obj = extended_obj.object
             end
-            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx, field: self)
+            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx)
           end
 
           if extended_obj.respond_to?(@resolver_method)

data/lib/graphql/schema/field/connection_extension.rb

@@ -28,6 +28,17 @@ module GraphQL
             nil
           elsif value.nil?
             nil
+          elsif value.is_a?(GraphQL::Pagination::Connection)
+            # update the connection with some things that may not have been provided
+            value.context ||= context
+            value.first ||= arguments[:first]
+            value.after ||= arguments[:after]
+            value.last ||= arguments[:last]
+            value.before ||= arguments[:before]
+            value.max_page_size ||= field.max_page_size
+            value
+          elsif context.schema.new_connections?
+            context.schema.connections.wrap(field, value, arguments, context)
           else
             if object.is_a?(GraphQL::Schema::Object)
               object = object.object
@@ -43,7 +54,6 @@ module GraphQL
             )
           end
         end
-
       end
     end
   end

data/lib/graphql/schema/input_object.rb

@@ -26,7 +26,7 @@ module GraphQL
           if @ruby_style_hash.key?(ruby_kwargs_key) && loads && !arg_defn.from_resolver?
             value = @ruby_style_hash[ruby_kwargs_key]
             @ruby_style_hash[ruby_kwargs_key] = if arg_defn.type.list?
-              GraphQL::Execution::Lazy.all(value.map { |val| load_application_object(arg_defn, loads, val) })
+              value.map { |val| load_application_object(arg_defn, loads, val) }
             else
               load_application_object(arg_defn, loads, value)
             end
@@ -57,10 +57,6 @@ module GraphQL
         to_h
       end
 
-      def prepare
-        self
-      end
-
       def unwrap_value(value)
         case value
         when Array
@@ -117,6 +113,7 @@ module GraphQL
           type_defn.description = description
           type_defn.metadata[:type_class] = self
           type_defn.mutation = mutation
+          type_defn.ast_node = ast_node
           arguments.each do |name, arg|
             type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition
           end

data/lib/graphql/schema/interface.rb

@@ -12,6 +12,7 @@ module GraphQL
         include GraphQL::Schema::Member::HasPath
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
+        include GraphQL::Schema::Member::HasAstNode
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -89,6 +90,7 @@ module GraphQL
           type_defn.name = graphql_name
           type_defn.description = description
           type_defn.orphan_types = orphan_types
+          type_defn.ast_node = ast_node
           fields.each do |field_name, field_inst|
             field_defn = field_inst.graphql_definition
             type_defn.fields[field_defn.name] = field_defn

data/lib/graphql/schema/introspection_system.rb

@@ -22,10 +22,7 @@ module GraphQL
           if schema.disable_introspection_entry_points
             {}
           else
-            entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
-            entry_point_fields.delete('__schema') if schema.disable_schema_introspection_entry_point
-            entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point
-            entry_point_fields
+            get_fields_from_class(class_sym: :EntryPoints)
           end
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end

data/lib/graphql/schema/loader.rb

@@ -34,7 +34,7 @@ module GraphQL
       end
 
       NullResolveType = ->(type, obj, ctx) {
-        raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
+        raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
       }
 
       NullScalarCoerce = ->(val, _ctx) { val }
@@ -51,7 +51,7 @@ module GraphQL
           when "NON_NULL"
             NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
           else
-            fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
+            fail NotImplementedError, "#{kind} not implemented"
           end
         end
 
@@ -118,20 +118,14 @@ module GraphQL
               }]
             )
           when "FIELD"
-            defns = {
+            GraphQL::Field.define(
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
-            }
-
-            # Avoid passing an empty hash, which warns on Ruby 2.7
-            if type["args"].any?
-              defns[:arguments] = Hash[type["args"].map { |arg|
+              arguments: Hash[type["args"].map { |arg|
                 [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
               }]
-            end
-
-            GraphQL::Field.define(**defns)
+            )
           when "ARGUMENT"
             kwargs = {}
             if type["defaultValue"]
@@ -177,7 +171,7 @@ module GraphQL
               }
             )
           else
-            fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
+            fail NotImplementedError, "#{type["kind"]} not implemented"
           end
         end
       end

data/lib/graphql/schema/member.rb

@@ -3,6 +3,7 @@ require 'graphql/schema/member/accepts_definition'
 require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
+require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_path'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
@@ -24,6 +25,7 @@ module GraphQL
       extend Scoped
       extend RelayShortcuts
       extend HasPath
+      extend HasAstNode
     end
   end
 end

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -74,7 +74,7 @@ module GraphQL
 
         # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
         def to_graphql
-          raise GraphQL::RequiredImplementationMissingError
+          raise NotImplementedError
         end
 
         alias :unwrap :itself
@@ -88,7 +88,7 @@ module GraphQL
         # without any namespaces and with any `-Type` suffix removed
         def default_graphql_name
           @default_graphql_name ||= begin
-            raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+            raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
 
             name.split("::").last.sub(/Type\Z/, "")
           end

data/lib/graphql/schema/member/build_type.rb

@@ -64,6 +64,8 @@ module GraphQL
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            type_expr
           when Module
             # This is a way to check that it's the right kind of module:
             if type_expr.respond_to?(:graphql_definition)
@@ -72,6 +74,8 @@ module GraphQL
               # Eg `String` => GraphQL::STRING_TYPE
               parse_type(type_expr.name, null: true)
             end
+          when Proc
+            parse_type(type_expr.call, null: true)
           when false
             raise ArgumentError, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
           end

data/lib/graphql/schema/member/cached_graphql_definition.rb

@@ -15,6 +15,11 @@ module GraphQL
           @graphql_definition ||= to_graphql
         end
 
+        # This is for a common interface with .define-based types
+        def type_class
+          self
+        end
+
         # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
         def initialize_copy(original)
           super

data/lib/graphql/schema/member/has_ast_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasAstNode
+        # If this schema was parsed from a `.graphql` file (or other SDL),
+        # this is the AST node that defined this part of the schema.
+        def ast_node(new_ast_node = nil)
+          if new_ast_node
+            @ast_node = new_ast_node
+          end
+          @ast_node
+        end
+      end
+    end
+  end
+end