graphql 2.0.16 → 2.0.17

data/lib/graphql/language/visitor.rb

@@ -65,7 +65,9 @@ module GraphQL
       # Visit `document` and all children, applying hooks as you go
       # @return [void]
       def visit
-        result = on_node_with_modifications(@document, nil)
+        # `@document` may be any kind of node:
+        visit_method = :"#{@document.visit_method}_with_modifications"
+        result = public_send(visit_method, @document, nil)
         @result = if result.is_a?(Array)
           result.first
         else
@@ -74,104 +76,210 @@ module GraphQL
         end
       end
 
-      # Call the user-defined handler for `node`.
-      def visit_node(node, parent)
-        public_send(node.visit_method, node, parent)
-      end
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
 
-      # The default implementation for visiting an AST node.
-      # It doesn't _do_ anything, but it continues to visiting the node's children.
-      # To customize this hook, override one of its make_visit_methodes (or the base method?)
-      # in your subclasses.
-      #
-      # For compatibility, it calls hook procs, too.
-      # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
-      # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-      # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
-      def on_abstract_node(node, parent)
-        if node.equal?(DELETE_NODE)
-          # This might be passed to `super(DELETE_NODE, ...)`
-          # by a user hook, don't want to keep visiting in that case.
-          nil
-        else
-          # Run hooks if there are any
-          new_node = node
-          no_hooks = !@visitors.key?(node.class)
-          if no_hooks || begin_visit(new_node, parent)
-            node.children.each do |child_node|
-              new_child_and_node = on_node_with_modifications(child_node, new_node)
-              # Reassign `node` in case the child hook makes a modification
-              if new_child_and_node.is_a?(Array)
-                new_node = new_child_and_node[1]
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # For compatibility, it calls hook procs, too.
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+          def #{node_method}(node, parent)
+            if node.equal?(DELETE_NODE)
+              # This might be passed to `super(DELETE_NODE, ...)`
+              # by a user hook, don't want to keep visiting in that case.
+              [node, parent]
+            else
+              # Run hooks if there are any
+              new_node = node
+              no_hooks = !@visitors.key?(node.class)
+              if no_hooks || begin_visit(new_node, parent)
+                #{
+                  if method_defined?(child_visit_method)
+                    "new_node = #{child_visit_method}(new_node)"
+                  elsif children_of_type
+                    children_of_type.map do |child_accessor, child_class|
+                      "node.#{child_accessor}.each do |child_node|
+                        new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
+                        # Reassign `node` in case the child hook makes a modification
+                        if new_child_and_node.is_a?(Array)
+                          new_node = new_child_and_node[1]
+                        end
+                      end"
+                    end.join("\n")
+                  else
+                    ""
+                  end
+                }
+              end
+              end_visit(new_node, parent) unless no_hooks
+
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
               end
             end
           end
-          end_visit(new_node, parent) unless no_hooks
 
-          if new_node.equal?(node)
-            nil
+          def #{node_method}_with_modifications(node, parent)
+            new_node_and_new_parent = #{node_method}(node, parent)
+            apply_modifications(node, parent, new_node_and_new_parent)
+          end
+        RUBY
+      end
+
+      def on_document_children(document_node)
+        new_node = document_node
+        document_node.children.each do |child_node|
+          visit_method = :"#{child_node.visit_method}_with_modifications"
+          new_child_and_node = public_send(visit_method, child_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node
+      end
+
+      def on_field_children(new_node)
+        new_node.arguments.each do |arg_node| # rubocop:disable Development/ContextIsPassedCop
+          new_child_and_node = on_argument_with_modifications(arg_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      def visit_directives(new_node)
+        new_node.directives.each do |dir_node|
+          new_child_and_node = on_directive_with_modifications(dir_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node
+      end
+
+      def visit_selections(new_node)
+        new_node.selections.each do |selection|
+          new_child_and_node = case selection
+          when GraphQL::Language::Nodes::Field
+            on_field_with_modifications(selection, new_node)
+          when GraphQL::Language::Nodes::InlineFragment
+            on_inline_fragment_with_modifications(selection, new_node)
+          when GraphQL::Language::Nodes::FragmentSpread
+            on_fragment_spread_with_modifications(selection, new_node)
           else
-            [new_node, parent]
+            raise ArgumentError, "Invariant: unexpected field selection #{selection.class} (#{selection.inspect})"
+          end
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
           end
         end
+        new_node
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_method(node_method)
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{node_method}(node, parent)
-            child_mod = on_abstract_node(node, parent)
-            # If visiting the children returned changes, continue passing those.
-            child_mod || [node, parent]
+      def on_fragment_definition_children(new_node)
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      alias :on_inline_fragment_children :on_fragment_definition_children
+
+      def on_operation_definition_children(new_node)
+        new_node.variables.each do |arg_node|
+          new_child_and_node = on_variable_definition_with_modifications(arg_node, new_node)
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
           end
-        RUBY
+        end
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      def on_argument_children(new_node)
+        new_node.children.each do |value_node|
+          new_child_and_node = case value_node
+          when Language::Nodes::VariableIdentifier
+            on_variable_identifier_with_modifications(value_node, new_node)
+          when Language::Nodes::InputObject
+            on_input_object_with_modifications(value_node, new_node)
+          when Language::Nodes::Enum
+            on_enum_with_modifications(value_node, new_node)
+          when Language::Nodes::NullValue
+            on_null_value_with_modifications(value_node, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected argument value node #{value_node.class} (#{value_node.inspect})"
+          end
+          # Reassign `node` in case the child hook makes a modification
+          if new_child_and_node.is_a?(Array)
+            new_node = new_child_and_node[1]
+          end
+        end
+        new_node
       end
 
-      make_visit_method :on_argument
-      make_visit_method :on_directive
-      make_visit_method :on_directive_definition
-      make_visit_method :on_directive_location
-      make_visit_method :on_document
-      make_visit_method :on_enum
-      make_visit_method :on_enum_type_definition
-      make_visit_method :on_enum_type_extension
-      make_visit_method :on_enum_value_definition
-      make_visit_method :on_field
-      make_visit_method :on_field_definition
-      make_visit_method :on_fragment_definition
-      make_visit_method :on_fragment_spread
-      make_visit_method :on_inline_fragment
-      make_visit_method :on_input_object
-      make_visit_method :on_input_object_type_definition
-      make_visit_method :on_input_object_type_extension
-      make_visit_method :on_input_value_definition
-      make_visit_method :on_interface_type_definition
-      make_visit_method :on_interface_type_extension
-      make_visit_method :on_list_type
-      make_visit_method :on_non_null_type
-      make_visit_method :on_null_value
-      make_visit_method :on_object_type_definition
-      make_visit_method :on_object_type_extension
-      make_visit_method :on_operation_definition
-      make_visit_method :on_scalar_type_definition
-      make_visit_method :on_scalar_type_extension
-      make_visit_method :on_schema_definition
-      make_visit_method :on_schema_extension
-      make_visit_method :on_type_name
-      make_visit_method :on_union_type_definition
-      make_visit_method :on_union_type_extension
-      make_visit_method :on_variable_definition
-      make_visit_method :on_variable_identifier
+      [
+        Language::Nodes::Argument,
+        Language::Nodes::Directive,
+        Language::Nodes::DirectiveDefinition,
+        Language::Nodes::DirectiveLocation,
+        Language::Nodes::Document,
+        Language::Nodes::Enum,
+        Language::Nodes::EnumTypeDefinition,
+        Language::Nodes::EnumTypeExtension,
+        Language::Nodes::EnumValueDefinition,
+        Language::Nodes::Field,
+        Language::Nodes::FieldDefinition,
+        Language::Nodes::FragmentDefinition,
+        Language::Nodes::FragmentSpread,
+        Language::Nodes::InlineFragment,
+        Language::Nodes::InputObject,
+        Language::Nodes::InputObjectTypeDefinition,
+        Language::Nodes::InputObjectTypeExtension,
+        Language::Nodes::InputValueDefinition,
+        Language::Nodes::InterfaceTypeDefinition,
+        Language::Nodes::InterfaceTypeExtension,
+        Language::Nodes::ListType,
+        Language::Nodes::NonNullType,
+        Language::Nodes::NullValue,
+        Language::Nodes::ObjectTypeDefinition,
+        Language::Nodes::ObjectTypeExtension,
+        Language::Nodes::OperationDefinition,
+        Language::Nodes::ScalarTypeDefinition,
+        Language::Nodes::ScalarTypeExtension,
+        Language::Nodes::SchemaDefinition,
+        Language::Nodes::SchemaExtension,
+        Language::Nodes::TypeName,
+        Language::Nodes::UnionTypeDefinition,
+        Language::Nodes::UnionTypeExtension,
+        Language::Nodes::VariableDefinition,
+        Language::Nodes::VariableIdentifier,
+      ].each do |ast_node_class|
+        make_visit_methods(ast_node_class)
+      end
 
       private
 
-      # Run the hooks for `node`, and if the hooks return a copy of `node`,
-      # copy `parent` so that it contains the copy of that node as a child,
-      # then return the copies
-      # If a non-array value is returned, consuming functions should ignore
-      # said value
-      def on_node_with_modifications(node, parent)
-        new_node_and_new_parent = visit_node(node, parent)
+      def apply_modifications(node, parent, new_node_and_new_parent)
         if new_node_and_new_parent.is_a?(Array)
           new_node = new_node_and_new_parent[0]
           new_parent = new_node_and_new_parent[1]

data/lib/graphql/schema/argument.rb

@@ -149,10 +149,6 @@ module GraphQL
         true
       end
 
-      def accessible?(context)
-        true
-      end
-
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end

data/lib/graphql/schema/directive.rb

@@ -8,6 +8,7 @@ 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::HasArguments::HasDirectiveArguments
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -21,9 +22,9 @@ module GraphQL
         # but downcase the first letter.
         def default_graphql_name
           @default_graphql_name ||= begin
-            camelized_name = super
+            camelized_name = super.dup
             camelized_name[0] = camelized_name[0].downcase
-            camelized_name
+            -camelized_name
           end
         end
 
@@ -93,6 +94,15 @@ module GraphQL
         def repeatable(new_value)
           @repeatable = new_value
         end
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @default_graphql_name ||= nil
+          end
+        end
       end
 
       # @return [GraphQL::Schema::Field, GraphQL::Schema::Argument, Class, Module]

data/lib/graphql/schema/enum.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
 module GraphQL
-  # Extend this class to define GraphQL enums in your schema.
-  #
-  # By default, GraphQL enum values are translated into Ruby strings.
-  # You can provide a custom value with the `value:` keyword.
-  #
-  # @example
-  #   # equivalent to
-  #   # enum PizzaTopping {
-  #   #   MUSHROOMS
-  #   #   ONIONS
-  #   #   PEPPERS
-  #   # }
-  #   class PizzaTopping < GraphQL::Enum
-  #     value :MUSHROOMS
-  #     value :ONIONS
-  #     value :PEPPERS
-  #   end
   class Schema
+    # Extend this class to define GraphQL enums in your schema.
+    #
+    # By default, GraphQL enum values are translated into Ruby strings.
+    # You can provide a custom value with the `value:` keyword.
+    #
+    # @example
+    #   # equivalent to
+    #   # enum PizzaTopping {
+    #   #   MUSHROOMS
+    #   #   ONIONS
+    #   #   PEPPERS
+    #   # }
+    #   class PizzaTopping < GraphQL::Enum
+    #     value :MUSHROOMS
+    #     value :ONIONS
+    #     value :PEPPERS
+    #   end
     class Enum < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::ValidatesInput
 
@@ -34,6 +34,13 @@ module GraphQL
         end
       end
 
+      class MissingValuesError < GraphQL::Error
+        def initialize(enum_type)
+          @enum_type = enum_type
+          super("Enum types require at least one value, but #{enum_type.graphql_name} didn't provide any for this query. Make sure at least one value is defined and visible for this query.")
+        end
+      end
+
       class << self
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`

data/lib/graphql/schema/enum_value.rb

@@ -25,16 +25,19 @@ module GraphQL
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
 
+      UNDEFINED_VALUE = Object.new.freeze
+      private_constant :UNDEFINED_VALUE
+
       attr_reader :graphql_name
 
       # @return [Class] The enum type that owns this value
       attr_reader :owner
 
-      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, directives: nil, description: nil, value: nil, deprecation_reason: nil, &block)
+      def initialize(graphql_name, desc = nil, owner:, ast_node: nil, directives: nil, description: nil, value: UNDEFINED_VALUE, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
         GraphQL::NameValidator.validate!(@graphql_name)
         @description = desc || description
-        @value = value.nil? ? @graphql_name : value
+        @value = value === UNDEFINED_VALUE ? @graphql_name : value
         if deprecation_reason
           self.deprecation_reason = deprecation_reason
         end
@@ -70,7 +73,6 @@ module GraphQL
       end
 
       def visible?(_ctx); true; end
-      def accessible?(_ctx); true; end
       def authorized?(_ctx); true; end
     end
   end

data/lib/graphql/schema/field.rb

@@ -6,6 +6,7 @@ module GraphQL
   class Schema
     class Field
       include GraphQL::Schema::Member::HasArguments
+      include GraphQL::Schema::Member::HasArguments::FieldConfigured
       include GraphQL::Schema::Member::HasAstNode
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasValidators
@@ -229,6 +230,7 @@ module GraphQL
         end
         @original_name = name
         name_s = -name.to_s
+
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
         if description != :not_given
@@ -589,14 +591,6 @@ module GraphQL
         end
       end
 
-      def accessible?(context)
-        if @resolver_class
-          @resolver_class.accessible?(context)
-        else
-          true
-        end
-      end
-
       def authorized?(object, args, context)
         if @resolver_class
           # The resolver _instance_ will check itself during `resolve()`
@@ -610,27 +604,29 @@ module GraphQL
             arg_values = args
             using_arg_values = false
           end
-          # Faster than `.any?`
-          arguments(context).each_value do |arg|
-            arg_key = arg.keyword
-            if arg_values.key?(arg_key)
-              arg_value = arg_values[arg_key]
-              if using_arg_values
-                if arg_value.default_used?
-                  # pass -- no auth required for default used
-                  next
-                else
-                  application_arg_value = arg_value.value
-                  if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
-                    application_arg_value.keyword_arguments
+          if args.size > 0
+            args = context.warden.arguments(self)
+            args.each do |arg|
+              arg_key = arg.keyword
+              if arg_values.key?(arg_key)
+                arg_value = arg_values[arg_key]
+                if using_arg_values
+                  if arg_value.default_used?
+                    # pass -- no auth required for default used
+                    next
+                  else
+                    application_arg_value = arg_value.value
+                    if application_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
+                      application_arg_value.keyword_arguments
+                    end
                   end
+                else
+                  application_arg_value = arg_value
                 end
-              else
-                application_arg_value = arg_value
-              end
 
-              if !arg.authorized?(object, application_arg_value, context)
-                return false
+                if !arg.authorized?(object, application_arg_value, context)
+                  return false
+                end
               end
             end
           end

data/lib/graphql/schema/interface.rb

@@ -28,16 +28,6 @@ module GraphQL
           true
         end
 
-        # The interface is accessible if any of its possible types are accessible
-        def accessible?(context)
-          context.schema.possible_types(self, context).each do |type|
-            if context.schema.accessible?(type, context)
-              return true
-            end
-          end
-          false
-        end
-
         def type_membership_class(membership_class = nil)
           if membership_class
             @type_membership_class = membership_class

data/lib/graphql/schema/late_bound_type.rb

@@ -9,6 +9,8 @@ module GraphQL
       alias :graphql_name :name
       def initialize(local_name)
         @name = local_name
+        @to_non_null_type = nil
+        @to_list_type = nil
       end
 
       def unwrap

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

@@ -22,14 +22,10 @@ module GraphQL
             GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
           else
-            overridden_graphql_name || default_graphql_name
+            @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?
@@ -60,8 +56,8 @@ module GraphQL
           def inherited(child_class)
             child_class.introspection(introspection)
             child_class.description(description)
-            if overridden_graphql_name
-              child_class.graphql_name(overridden_graphql_name)
+            if defined?(@graphql_name) && (self.name.nil? || graphql_name != default_graphql_name)
+              child_class.graphql_name(graphql_name)
             end
             super
           end
@@ -79,7 +75,7 @@ module GraphQL
         end
 
         def introspection?
-          introspection
+          !!@introspection
         end
 
         # The mutation this type was derived from, if it was derived from a mutation
@@ -102,21 +98,26 @@ module GraphQL
         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
+            -name.split("::").last.sub(/Type\Z/, "")          end
         end
 
         def visible?(context)
           true
         end
 
-        def accessible?(context)
+        def authorized?(object, context)
           true
         end
 
-        def authorized?(object, context)
-          true
+        protected
+
+        attr_writer :default_graphql_name
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.default_graphql_name = nil
         end
       end
     end