graphql 1.9.21 → 1.10.0.pre1

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module GraphQL
   class Schema
     class Member
@@ -7,11 +6,11 @@ module GraphQL
       module HasFields
         # Add a field to this object or interface with the given definition
         # @see {GraphQL::Schema::Field#initialize} for method signature
-        # @return [void]
+        # @return [GraphQL::Schema::Field]
         def field(*args, **kwargs, &block)
           field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
           add_field(field_defn)
-          nil
+          field_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
@@ -39,28 +38,23 @@ module GraphQL
           end
         end
 
-        # A list of Ruby keywords.
-        #
-        # @api private
-        RUBY_KEYWORDS = [:class, :module, :def, :undef, :begin, :rescue, :ensure, :end, :if, :unless, :then, :elsif, :else, :case, :when, :while, :until, :for, :break, :next, :redo, :retry, :in, :do, :return, :yield, :super, :self, :nil, :true, :false, :and, :or, :not, :alias, :defined?, :BEGIN, :END, :__LINE__, :__FILE__]
-
-        # A list of GraphQL-Ruby keywords.
-        #
-        # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
-
         # A list of field names that we should advise users to pick a different
         # resolve method name.
         #
         # @api private
-        CONFLICT_FIELD_NAMES = Set.new(GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS)
+        CONFLICT_FIELD_NAMES = Set.new([
+          # GraphQL-Ruby conflicts
+          :context, :object,
+          # Ruby built-ins conflicts
+          :method, :class
+        ])
 
         # Register this field with the class, overriding a previous one if needed.
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
-          if CONFLICT_FIELD_NAMES.include?(field_defn.original_name) && field_defn.original_name == field_defn.resolver_method
-            warn "#{self.graphql_name}'s `field :#{field_defn.original_name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.original_name}` and `def resolve_#{field_defn.original_name}`)"
+          if CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.method_conflict_warning?
+            warn "#{self.graphql_name}'s `field :#{field_defn.name}` conflicts with a built-in method, use `resolver_method:` to pick a different resolver method for this field (for example, `resolver_method: :resolve_#{field_defn.resolver_method}` and `def resolve_#{field_defn.resolver_method}`). Or use `method_conflict_warning: false` to suppress this warning."
           end
           own_fields[field_defn.name] = field_defn
           nil

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

@@ -78,7 +78,7 @@ module GraphQL
 
           def call(obj, args, ctx)
             result = @inner_resolve.call(obj, args, ctx)
-            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || execution_errors?(result) || ctx.wrapped_object
+            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || result.is_a?(GraphQL::ExecutionError) || ctx.wrapped_object
               result
             else
               ctx.wrapped_object = true
@@ -88,11 +88,6 @@ module GraphQL
 
           private
 
-          def execution_errors?(result)
-            result.is_a?(GraphQL::ExecutionError) ||
-              (result.is_a?(Array) && result.any? && result.all? { |v| v.is_a?(GraphQL::ExecutionError) })
-          end
-
           def proxy_to_depth(inner_obj, depth, ctx)
             if depth > 0
               inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }

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

@@ -30,7 +30,7 @@ module GraphQL
 
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
-          raise GraphQL::RequiredImplementationMissingError
+          raise NotImplementedError
         end
       end
     end

data/lib/graphql/schema/mutation.rb

@@ -64,7 +64,7 @@ module GraphQL
 
       class << self
         # Override this method to handle legacy-style usages of `MyMutation.field`
-        def field(*args, **kwargs, &block)
+        def field(*args, &block)
           if args.empty?
             raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
           else

data/lib/graphql/schema/object.rb

@@ -35,12 +35,10 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = context.query.with_error_handling do
-            begin
-              authorized?(object, context)
-            rescue GraphQL::UnauthorizedError => err
-              context.schema.unauthorized_object(err)
-            end
+          auth_val = begin
+            authorized?(object, context)
+          rescue GraphQL::UnauthorizedError => err
+            context.schema.unauthorized_object(err)
           end
 
           context.schema.after_lazy(auth_val) do |is_authorized|
@@ -120,6 +118,7 @@ module GraphQL
           obj_type.interfaces = interfaces
           obj_type.introspection = introspection
           obj_type.mutation = mutation
+          obj_type.ast_node = ast_node
           fields.each do |field_name, field_inst|
             field_defn = field_inst.to_graphql
             obj_type.fields[field_defn.name] = field_defn

data/lib/graphql/schema/possible_types.rb

@@ -20,12 +20,12 @@ module GraphQL
         end
       end
 
-      def possible_types(type_defn, ctx)
+      def possible_types(type_defn)
         case type_defn
         when Module
-          possible_types(type_defn.graphql_definition, ctx)
+          possible_types(type_defn.graphql_definition)
         when GraphQL::UnionType
-          type_defn.possible_types(ctx)
+          type_defn.possible_types
         when GraphQL::InterfaceType
           @interface_implementers[type_defn]
         when GraphQL::BaseType

data/lib/graphql/schema/printer.rb

@@ -60,9 +60,7 @@ module GraphQL
 
       # Return the GraphQL schema string for the introspection type system
       def self.print_introspection_schema
-        query_root = ObjectType.define(name: "Root") do
-          field :throwaway_field, types.String
-        end
+        query_root = ObjectType.define(name: "Root")
         schema = GraphQL::Schema.define(query: query_root)
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -33,13 +33,9 @@ module GraphQL
         # But when using the interpreter, no instrumenters are applied.
         if context.interpreter?
           input = inputs[:input].to_kwargs
-
-          new_extras = field ? field.extras : []
-          all_extras = self.class.extras + new_extras
-
           # Transfer these from the top-level hash to the
           # shortcutted `input:` object
-          all_extras.each do |ext|
+          self.class.extras.each do |ext|
             # It's possible that the `extra` was not passed along by this point,
             # don't re-add it if it wasn't given here.
             if inputs.key?(ext)
@@ -61,7 +57,7 @@ module GraphQL
         end
 
         return_value = if input_kwargs.any?
-          super(**input_kwargs)
+          super(input_kwargs)
         else
           super()
         end

data/lib/graphql/schema/resolver.rb

@@ -29,11 +29,9 @@ module GraphQL
 
       # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
       # @param context [GraphQL::Query::Context]
-      # @param field [GraphQL::Schema::Field]
-      def initialize(object:, context:, field:)
+      def initialize(object:, context:)
         @object = object
         @context = context
-        @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
         self.class.arguments.each do |name, arg|
@@ -48,9 +46,6 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
-      # @return [GraphQL::Schema::Field]
-      attr_reader :field
-
       # This method is _actually_ called by the runtime,
       # it does some preparation and then eventually calls
       # the user-defined `#resolve` method.
@@ -76,7 +71,7 @@ module GraphQL
             context.schema.after_lazy(load_arguments_val) do |loaded_args|
               # Then call `authorized?`, which may raise or may return a lazy object
               authorized_val = if loaded_args.any?
-                authorized?(**loaded_args)
+                authorized?(loaded_args)
               else
                 authorized?
               end
@@ -108,7 +103,7 @@ module GraphQL
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
-        raise GraphQL::RequiredImplementationMissingError, "#{self.class.name}#resolve should execute the field's logic"
+        raise NotImplementedError, "#{self.class.name}#resolve should execute the field's logic"
       end
 
       # Called before arguments are prepared.
@@ -135,20 +130,8 @@ module GraphQL
       def authorized?(**inputs)
         self.class.arguments.each_value do |argument|
           arg_keyword = argument.keyword
-          if inputs.key?(arg_keyword) && !(value = inputs[arg_keyword]).nil? && (value != argument.default_value)
-            loads_type = @arguments_loads_as_type[arg_keyword]
-            # If this argument resulted in an object being loaded,
-            # then authorize this loaded object with its own policy.
-            #
-            # But if this argument was "just" a plain argument, like
-            # a boolean, then authorize it based on the mutation.
-            authorization_value = if loads_type
-              value
-            else
-              self
-            end
-
-            arg_auth, err = argument.authorized?(authorization_value, context)
+          if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
+            arg_auth, err = argument.authorized?(self, arg_value, context)
             if !arg_auth
               return arg_auth, err
             else
@@ -272,7 +255,6 @@ module GraphQL
             arguments: arguments,
             null: null,
             complexity: complexity,
-            extensions: extensions,
           }
         end
 
@@ -326,18 +308,6 @@ module GraphQL
           inherited_lookups.merge(own_arguments_loads_as_type)
         end
 
-        # Registers new extension
-        # @param extension [Class] Extension class
-        # @param options [Hash] Optional extension options
-        def extension(extension, **options)
-          extensions << {extension => options}
-        end
-
-        # @api private
-        def extensions
-          @extensions ||= []
-        end
-
         private
 
         def own_arguments_loads_as_type

data/lib/graphql/schema/scalar.rb

@@ -24,6 +24,7 @@ module GraphQL
           type_defn.coerce_input = method(:coerce_input)
           type_defn.metadata[:type_class] = self
           type_defn.default_scalar = default_scalar
+          type_defn.ast_node = ast_node
           type_defn
         end
 

data/lib/graphql/schema/subscription.rb

@@ -29,7 +29,7 @@ module GraphQL
       # propagate null.
       null false
 
-      def initialize(object:, context:, field:)
+      def initialize(object:, context:)
         super
         # Figure out whether this is an update or an initial subscription
         @mode = context.query.subscription_update? ? :update : :subscribe
@@ -39,12 +39,12 @@ module GraphQL
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
         # have an unexpected `@mode`
-        public_send("resolve_#{@mode}", **args)
+        public_send("resolve_#{@mode}", args)
       end
 
       # Wrap the user-defined `#subscribe` hook
-      def resolve_subscribe(**args)
-        ret_val = args.any? ? subscribe(**args) : subscribe
+      def resolve_subscribe(args)
+        ret_val = args.any? ? subscribe(args) : subscribe
         if ret_val == :no_response
           context.skip
         else
@@ -62,8 +62,8 @@ module GraphQL
       end
 
       # Wrap the user-provided `#update` hook
-      def resolve_update(**args)
-        ret_val = args.any? ? update(**args) : update
+      def resolve_update(args)
+        ret_val = args.any? ? update(args) : update
         if ret_val == :no_update
           raise NoUpdateError
         else

data/lib/graphql/schema/timeout_middleware.rb

@@ -35,10 +35,9 @@ module GraphQL
 
       def call(parent_type, parent_object, field_definition, field_args, query_context)
         ns = query_context.namespace(self.class)
-        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        timeout_at = ns[:timeout_at] ||= now + @max_seconds
+        timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
 
-        if timeout_at < now
+        if timeout_at < Time.now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
         else
           yield

data/lib/graphql/schema/type_expression.rb

@@ -9,25 +9,35 @@ module GraphQL
       # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
       # @return [GraphQL::BaseType, nil]
       def self.build_type(types, ast_node)
-        case ast_node
-        when GraphQL::Language::Nodes::TypeName
-          types.fetch(ast_node.name, nil)
-        when GraphQL::Language::Nodes::NonNullType
-          ast_inner_type = ast_node.of_type
-          inner_type = build_type(types, ast_inner_type)
-          wrap_type(inner_type, GraphQL::NonNullType)
-        when GraphQL::Language::Nodes::ListType
-          ast_inner_type = ast_node.of_type
-          inner_type = build_type(types, ast_inner_type)
-          wrap_type(inner_type, GraphQL::ListType)
-        end
+        t = type_from_ast(types, ast_node)
+        # maybe nil:
+        t ? t.graphql_definition : t
       end
 
-      def self.wrap_type(type, wrapper)
-        if type.nil?
-          nil
-        else
-          wrapper.new(of_type: type)
+      class << self
+        private
+
+        def type_from_ast(types, ast_node)
+          case ast_node
+          when GraphQL::Language::Nodes::TypeName
+            types.fetch(ast_node.name, nil)
+          when GraphQL::Language::Nodes::NonNullType
+            ast_inner_type = ast_node.of_type
+            inner_type = build_type(types, ast_inner_type)
+            wrap_type(inner_type, GraphQL::Schema::NonNull)
+          when GraphQL::Language::Nodes::ListType
+            ast_inner_type = ast_node.of_type
+            inner_type = build_type(types, ast_inner_type)
+            wrap_type(inner_type, GraphQL::Schema::List)
+          end
+        end
+
+        def wrap_type(of_type, wrapper)
+          if of_type.nil?
+            nil
+          else
+            wrapper.new(of_type)
+          end
         end
       end
     end

data/lib/graphql/schema/union.rb

@@ -5,19 +5,13 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
-        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
+        def possible_types(*types)
           if types.any?
-            types.each do |t|
-              type_memberships << type_membership_class.new(self, t, **options)
-            end
+            @possible_types = types
           else
-            visible_types = []
-            type_memberships.each do |type_membership|
-              if type_membership.visible?(context)
-                visible_types << type_membership.object_type
-              end
-            end
-            visible_types
+            all_possible_types = @possible_types || []
+            all_possible_types += super if defined?(super)
+            all_possible_types.uniq
           end
         end
 
@@ -25,7 +19,8 @@ module GraphQL
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name
           type_defn.description = description
-          type_defn.type_memberships = type_memberships
+          type_defn.possible_types = possible_types
+          type_defn.ast_node = ast_node
           if respond_to?(:resolve_type)
             type_defn.resolve_type = method(:resolve_type)
           end
@@ -33,23 +28,9 @@ module GraphQL
           type_defn
         end
 
-        def type_membership_class(membership_class = nil)
-          if membership_class
-            @type_membership_class = membership_class
-          else
-            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
-          end
-        end
-
         def kind
           GraphQL::TypeKinds::UNION
         end
-
-        private
-
-        def type_memberships
-          @type_memberships ||= []
-        end
       end
     end
   end

data/lib/graphql/schema/validation.rb

@@ -77,18 +77,6 @@ module GraphQL
           }
         end
 
-        def self.count_at_least(item_name, minimum_count, get_items_proc)
-          ->(type) {
-            items = get_items_proc.call(type)
-
-            if items.size < minimum_count
-              "#{type.name} must define at least #{minimum_count} #{item_name}. #{items.size} defined."
-            else
-              nil
-            end
-          }
-        end
-
         def self.assert_named_items_are_valid(item_name, get_items_proc)
           ->(type) {
             items = get_items_proc.call(type)
@@ -104,9 +92,7 @@ module GraphQL
           }
         end
 
-        HAS_AT_LEAST_ONE_FIELD = Rules.count_at_least("field", 1, ->(type) { type.all_fields })
         FIELDS_ARE_VALID = Rules.assert_named_items_are_valid("field", ->(type) { type.all_fields })
-        HAS_AT_LEAST_ONE_ARGUMENT = Rules.count_at_least("argument", 1, ->(type) { type.arguments })
 
         HAS_ONE_OR_MORE_POSSIBLE_TYPES = ->(type) {
           type.possible_types.length >= 1 ? nil : "must have at least one possible type"
@@ -135,7 +121,7 @@ module GraphQL
 
         TYPE_IS_VALID_INPUT_TYPE = ->(type) {
           outer_type = type.type
-          inner_type = outer_type.is_a?(GraphQL::BaseType) ? outer_type.unwrap : nil
+          inner_type = outer_type.respond_to?(:unwrap) ? outer_type.unwrap : nil
 
           case inner_type
           when GraphQL::ScalarType, GraphQL::InputObjectType, GraphQL::EnumType
@@ -274,13 +260,11 @@ module GraphQL
           Rules::DESCRIPTION_IS_STRING_OR_NIL,
         ],
         GraphQL::ObjectType => [
-          Rules::HAS_AT_LEAST_ONE_FIELD,
           Rules.assert_property_list_of(:interfaces, GraphQL::InterfaceType),
           Rules::FIELDS_ARE_VALID,
           Rules::INTERFACES_ARE_IMPLEMENTED,
         ],
         GraphQL::InputObjectType => [
-          Rules::HAS_AT_LEAST_ONE_ARGUMENT,
           Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
           Rules::ARGUMENTS_ARE_VALID,
         ],