graphql 1.8.0 → 1.12.12

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/schema/find_inherited_value"
+
 module GraphQL
   class Schema
     class Member
@@ -7,26 +9,27 @@ module GraphQL
       # @api private
       # @see Classes that extend this, eg {GraphQL::Schema::Object}
       module BaseDSLMethods
+        include GraphQL::Schema::FindInheritedValue
+
         # Call this with a new name to override the default name for this schema member; OR
         # call it without an argument to get the name of this schema member
         #
-        # The default name is the Ruby constant name,
-        # without any namespaces and with any `-Type` suffix removed
+        # The default name is implemented in default_graphql_name
         # @param new_name [String]
         # @return [String]
         def graphql_name(new_name = nil)
-          case
-          when new_name
+          if new_name
+            GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
-          when overridden = overridden_graphql_name
-            overridden
-          else # Fallback to Ruby constant name
-            raise NotImplementedError, 'Anonymous class should declare an `graphql_name`' if name.nil?
-            
-            name.split("::").last.sub(/Type\Z/, "")
+          else
+            overridden_graphql_name || default_graphql_name
           end
         end
 
+        def overridden_graphql_name
+          defined?(@graphql_name) ? @graphql_name : nil
+        end
+
         # Just a convenience method to point out that people should use graphql_name instead
         def name(new_name = nil)
           return super() if new_name.nil?
@@ -44,8 +47,23 @@ module GraphQL
         def description(new_description = nil)
           if new_description
             @description = new_description
+          elsif defined?(@description)
+            @description
           else
-            @description || find_inherited_method(:description, nil)
+            nil
+          end
+        end
+
+        # This pushes some configurations _down_ the inheritance tree,
+        # in order to prevent repetitive lookups at runtime.
+        module ConfigurationExtension
+          def inherited(child_class)
+            child_class.introspection(introspection)
+            child_class.description(description)
+            if overridden_graphql_name
+              child_class.graphql_name(overridden_graphql_name)
+            end
+            super
           end
         end
 
@@ -53,46 +71,57 @@ module GraphQL
         def introspection(new_introspection = nil)
           if !new_introspection.nil?
             @introspection = new_introspection
+          elsif defined?(@introspection)
+            @introspection
           else
-            @introspection || find_inherited_method(:introspection, false)
+            false
           end
         end
 
+        def introspection?
+          introspection
+        end
+
         # The mutation this type was derived from, if it was derived from a mutation
         # @return [Class]
         def mutation(mutation_class = nil)
           if mutation_class
             @mutation = mutation_class
+          elsif defined?(@mutation)
+            @mutation
+          else
+            nil
           end
-          @mutation
         end
 
         # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
         def to_graphql
-          raise NotImplementedError
+          raise GraphQL::RequiredImplementationMissingError
         end
 
-        def overridden_graphql_name
-          @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
+        alias :unwrap :itself
+
+        # Creates the default name for a schema member.
+        # The default name is the Ruby constant name,
+        # 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?
+
+            name.split("::").last.sub(/Type\Z/, "")
+          end
         end
 
-        def unwrap
-          self
+        def visible?(context)
+          true
         end
 
-        private
+        def accessible?(context)
+          true
+        end
 
-        def find_inherited_method(method_name, default_value)
-          if self.is_a?(Class)
-            superclass.respond_to?(method_name) ? superclass.public_send(method_name) : default_value
-          else
-            ancestors[1..-1].each do |ancestor|
-              if ancestor.respond_to?(method_name)
-                return ancestor.public_send(method_name)
-              end
-            end
-            default_value
-          end
+        def authorized?(object, context)
+          true
         end
       end
     end

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

@@ -4,6 +4,10 @@ module GraphQL
     class Member
       # @api private
       module BuildType
+        if !String.method_defined?(:match?)
+          using GraphQL::StringMatchBackport
+        end
+
         LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
 
         module_function
@@ -16,15 +20,15 @@ module GraphQL
           when String
             case type_expr
             when "String"
-              GraphQL::STRING_TYPE
+              GraphQL::Types::String
             when "Int", "Integer"
-              GraphQL::INT_TYPE
+              GraphQL::Types::Int
             when "Float"
-              GraphQL::FLOAT_TYPE
+              GraphQL::Types::Float
             when "Boolean"
-              GraphQL::BOOLEAN_TYPE
+              GraphQL::Types::Boolean
             when "ID"
-              GraphQL::ID_TYPE
+              GraphQL::Types::ID
             when /\A\[.*\]\Z/
               list_type = true
               # List members are required by default
@@ -33,7 +37,7 @@ module GraphQL
               null = false
               parse_type(type_expr[0..-2], null: true)
             else
-              maybe_type = Object.const_get(type_expr)
+              maybe_type = constantize(type_expr)
               case maybe_type
               when GraphQL::BaseType
                 maybe_type
@@ -56,28 +60,32 @@ module GraphQL
               parse_type(type_expr.first, null: false)
             when 2
               inner_type, nullable_option = type_expr
-              if nullable_option.keys != [:null] || nullable_option.values != [true]
+              if nullable_option.keys != [:null] || (nullable_option[:null] != true && nullable_option[:null] != false)
                 raise ArgumentError, LIST_TYPE_ERROR
               end
               list_type = true
-              parse_type(inner_type, null: true)
+              parse_type(inner_type, null: nullable_option[:null])
             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)
               type_expr
             else
-              # Eg `String` => GraphQL::STRING_TYPE
+              # Eg `String` => GraphQL::Types::String
               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
 
           if return_type.nil?
-            raise "Unexpected type input: #{type_expr} (#{type_expr.class})"
+            raise "Unexpected type input: #{type_expr.inspect} (#{type_expr.class})"
           end
 
           # Apply list_type first, that way the
@@ -125,11 +133,49 @@ module GraphQL
           camelized
         end
 
+        # Resolves constant from string (based on Rails `ActiveSupport::Inflector.constantize`)
+        def constantize(string)
+          names = string.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(string) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # Owner is in Object, so raise.
+              constant.const_get(name, false)
+            end
+          end
+        end
+
         def underscore(string)
-          string
-            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
-            .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
-            .downcase
+          if string.match?(/\A[a-z_]+\Z/)
+            return string
+          end
+          string2 = string.dup
+
+          string2.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          string2.gsub!(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          string2.downcase!
+
+          string2
         end
       end
     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_arguments.rb

@@ -5,25 +5,74 @@ module GraphQL
       module HasArguments
         def self.included(cls)
           cls.extend(ArgumentClassAccessor)
+          cls.include(ArgumentObjectLoader)
         end
 
         def self.extended(cls)
           cls.extend(ArgumentClassAccessor)
+          cls.include(ArgumentObjectLoader)
         end
 
         # @see {GraphQL::Schema::Argument#initialize} for parameters
         # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
         def argument(*args, **kwargs, &block)
           kwargs[:owner] = self
+          loads = kwargs[:loads]
+          if loads
+            name = args[0]
+            name_as_string = name.to_s
+
+            inferred_arg_name = case name_as_string
+            when /_id$/
+              name_as_string.sub(/_id$/, "").to_sym
+            when /_ids$/
+              name_as_string.sub(/_ids$/, "")
+                .sub(/([^s])$/, "\\1s")
+                .to_sym
+            else
+              name
+            end
+
+            kwargs[:as] ||= inferred_arg_name
+          end
           arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          add_argument(arg_defn)
+        end
+
+        # Register this argument with the class.
+        # @param arg_defn [GraphQL::Schema::Argument]
+        # @return [GraphQL::Schema::Argument]
+        def add_argument(arg_defn)
+          @own_arguments ||= {}
           own_arguments[arg_defn.name] = arg_defn
+          arg_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
         def arguments
-          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : {})
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : nil)
           # Local definitions override inherited ones
-          inherited_arguments.merge(own_arguments)
+          if inherited_arguments
+            inherited_arguments.merge(own_arguments)
+          else
+            own_arguments
+          end
+        end
+
+        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
+        def get_argument(argument_name)
+          a = own_arguments[argument_name]
+
+          if a || !self.is_a?(Class)
+            a
+          else
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_arguments) && a = ancestor.own_arguments[argument_name]
+                return a
+              end
+            end
+            nil
+          end
         end
 
         # @param new_arg_class [Class] A class to use for building argument definitions
@@ -31,18 +80,163 @@ module GraphQL
           self.class.argument_class(new_arg_class)
         end
 
+        # @api private
+        # If given a block, it will eventually yield the loaded args to the block.
+        #
+        # If no block is given, it will immediately dataload (but might return a Lazy).
+        #
+        # @param values [Hash<String, Object>]
+        # @param context [GraphQL::Query::Context]
+        # @yield [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
+        def coerce_arguments(parent_object, values, context, &block)
+          # Cache this hash to avoid re-merging it
+          arg_defns = self.arguments
+          total_args_count = arg_defns.size
+
+          if total_args_count == 0
+            final_args = GraphQL::Execution::Interpreter::Arguments::EMPTY
+            if block_given?
+              block.call(final_args)
+              nil
+            else
+              final_args
+            end
+          else
+            finished_args = nil
+            argument_values = {}
+            resolved_args_count = 0
+            raised_error = false
+            arg_defns.each do |arg_name, arg_defn|
+              context.dataloader.append_job do
+                begin
+                  arg_defn.coerce_into_values(parent_object, values, context, argument_values)
+                rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
+                  raised_error = true
+                  if block_given?
+                    block.call(err)
+                  else
+                    finished_args = err
+                  end
+                end
+
+                resolved_args_count += 1
+                if resolved_args_count == total_args_count && !raised_error
+                  finished_args = context.schema.after_any_lazies(argument_values.values) {
+                    GraphQL::Execution::Interpreter::Arguments.new(
+                      argument_values: argument_values,
+                    )
+                  }
+
+                  if block_given?
+                    block.call(finished_args)
+                  end
+                end
+              end
+            end
+
+            if block_given?
+              nil
+            else
+              # This API returns eagerly, gotta run it now
+              context.dataloader.run
+              finished_args
+            end
+          end
+        end
+
+        # Usually, this is validated statically by RequiredArgumentsArePresent,
+        # but not for directives.
+        # TODO apply static validations on schema definitions?
+        def validate_directive_argument(arg_defn, value)
+          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+            if value.nil? && arg_defn.type.non_null?
+              raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
+            end
+          end
+        end
+
+        def arguments_statically_coercible?
+          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
+
+          @arguments_statically_coercible = arguments.each_value.all?(&:statically_coercible?)
+        end
+
         module ArgumentClassAccessor
           def argument_class(new_arg_class = nil)
             if new_arg_class
               @argument_class = new_arg_class
+            elsif defined?(@argument_class) && @argument_class
+              @argument_class
             else
-              @argument_class || (superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument)
+              superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument
             end
           end
         end
 
+        module ArgumentObjectLoader
+          # Look up the corresponding object for a provided ID.
+          # By default, it uses Relay-style {Schema.object_from_id},
+          # override this to find objects another way.
+          #
+          # @param type [Class, Module] A GraphQL type definition
+          # @param id [String] A client-provided to look up
+          # @param context [GraphQL::Query::Context] the current context
+          def object_from_id(type, id, context)
+            context.schema.object_from_id(id, context)
+          end
+
+          def load_application_object(argument, lookup_as_type, id, context)
+            # See if any object can be found for this ID
+            if id.nil?
+              return nil
+            end
+            loaded_application_object = object_from_id(lookup_as_type, id, context)
+            context.schema.after_lazy(loaded_application_object) do |application_object|
+              if application_object.nil?
+                err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+                load_application_object_failed(err)
+              end
+              # Double-check that the located object is actually of this type
+              # (Don't want to allow arbitrary access to objects this way)
+              resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+              context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
+                possible_object_types = context.warden.possible_types(lookup_as_type)
+                if !possible_object_types.include?(application_object_type)
+                  err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+                  load_application_object_failed(err)
+                else
+                  # This object was loaded successfully
+                  # and resolved to the right type,
+                  # now apply the `.authorized?` class method if there is one
+                  if (class_based_type = application_object_type.type_class)
+                    context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
+                      if authed
+                        application_object
+                      else
+                        raise GraphQL::UnauthorizedError.new(
+                          object: application_object,
+                          type: class_based_type,
+                          context: context,
+                        )
+                      end
+                    end
+                  else
+                    application_object
+                  end
+                end
+              end
+            end
+          end
+
+          def load_application_object_failed(err)
+            raise err
+          end
+        end
+
+        NO_ARGUMENTS = {}.freeze
         def own_arguments
-          @own_arguments ||= {}
+          @own_arguments || NO_ARGUMENTS
         end
       end
     end

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

@@ -0,0 +1,20 @@
+# 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
+          elsif defined?(@ast_node)
+            @ast_node
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDeprecationReason
+        # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
+        def deprecation_reason
+          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
+          dir && dir.arguments[:reason]
+        end
+
+        # Set the deprecation reason for this member, or remove it by assigning `nil`
+        # @param text [String, nil]
+        def deprecation_reason=(text)
+          if text.nil?
+            remove_directive(GraphQL::Schema::Directive::Deprecated)
+          else
+            directive(GraphQL::Schema::Directive::Deprecated, reason: text)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module HasDirectives
+        # Create an instance of `dir_class` for `self`, using `options`.
+        #
+        # It removes a previously-attached instance of `dir_class`, if there is one.
+        #
+        # @return [void]
+        def directive(dir_class, **options)
+          @own_directives ||= []
+          remove_directive(dir_class)
+          @own_directives << dir_class.new(self, **options)
+          nil
+        end
+
+        # Remove an attached instance of `dir_class`, if there is one
+        # @param dir_class [Class<GraphQL::Schema::Directive>]
+        # @return [viod]
+        def remove_directive(dir_class)
+          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          nil
+        end
+
+        NO_DIRECTIVES = [].freeze
+
+        def directives
+          case self
+          when Class
+            inherited_directives = if superclass.respond_to?(:directives)
+              superclass.directives
+            else
+              NO_DIRECTIVES
+            end
+            if inherited_directives.any? && @own_directives
+              dirs = []
+              merge_directives(dirs, inherited_directives)
+              merge_directives(dirs, @own_directives)
+              dirs
+            elsif @own_directives
+              @own_directives
+            elsif inherited_directives.any?
+              inherited_directives
+            else
+              NO_DIRECTIVES
+            end
+          when Module
+            dirs = nil
+            self.ancestors.reverse_each do |ancestor|
+              if ancestor.respond_to?(:own_directives) &&
+                  (anc_dirs = ancestor.own_directives).any?
+                dirs ||= []
+                merge_directives(dirs, anc_dirs)
+              end
+            end
+            if own_directives
+              dirs ||= []
+              merge_directives(dirs, own_directives)
+            end
+            dirs || NO_DIRECTIVES
+          when HasDirectives
+            @own_directives || NO_DIRECTIVES
+          else
+            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
+          end
+        end
+
+        protected
+
+        def own_directives
+          @own_directives
+        end
+
+        private
+
+        # Modify `target` by adding items from `dirs` such that:
+        # - Any name conflict is overriden by the incoming member of `dirs`
+        # - Any other member of `dirs` is appended
+        # @param target [Array<GraphQL::Schema::Directive>]
+        # @param dirs [Array<GraphQL::Schema::Directive>]
+        # @return [void]
+        def merge_directives(target, dirs)
+          dirs.each do |dir|
+            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+              target.slice!(idx)
+              target.insert(idx, dir)
+            else
+              target << dir
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end