graphql 2.0.32 → 2.1.0

data/lib/graphql/language/visitor.rb

@@ -31,11 +31,6 @@ module GraphQL
     #   visitor.count
     #   # => 3
     class Visitor
-      # If any hook returns this value, the {Visitor} stops visiting this
-      # node right away
-      # @deprecated Use `super` to continue the visit; or don't call it to halt.
-      SKIP = :_skip
-
       class DeleteNode; end
 
       # When this is returned from a visitor method,
@@ -44,25 +39,13 @@ module GraphQL
 
       def initialize(document)
         @document = document
-        @visitors = {}
         @result = nil
       end
 
       # @return [GraphQL::Language::Nodes::Document] The document with any modifications applied
       attr_reader :result
 
-      # Get a {NodeVisitor} for `node_class`
-      # @param node_class [Class] The node class that you want to listen to
-      # @return [NodeVisitor]
-      #
-      # @example Run a hook whenever you enter a new Field
-      #   visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) { p "Here's a field" }
-      # @deprecated see `on_` methods, like {#on_field}
-      def [](node_class)
-        @visitors[node_class] ||= NodeVisitor.new
-      end
-
-      # Visit `document` and all children, applying hooks as you go
+      # Visit `document` and all children
       # @return [void]
       def visit
         # `@document` may be any kind of node:
@@ -76,6 +59,61 @@ module GraphQL
         end
       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"
+
+        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.
+          #
+          # @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
+              new_node = node
+              #{
+                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
+              }
+
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
+              end
+            end
+          end
+
+          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|
@@ -176,68 +214,6 @@ module GraphQL
         new_node
       end
 
-      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
-
-      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"
-
-        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
-          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
-
-
-
       [
         Language::Nodes::Argument,
         Language::Nodes::Directive,
@@ -278,8 +254,6 @@ module GraphQL
         make_visit_methods(ast_node_class)
       end
 
-      # rubocop:enable Development/NoEvalCop
-
       private
 
       def apply_modifications(node, parent, new_node_and_new_parent)
@@ -308,46 +282,6 @@ module GraphQL
           new_node_and_new_parent
         end
       end
-
-      def begin_visit(node, parent)
-        node_visitor = self[node.class]
-        self.class.apply_hooks(node_visitor.enter, node, parent)
-      end
-
-      # Should global `leave` visitors come first or last?
-      def end_visit(node, parent)
-        node_visitor = self[node.class]
-        self.class.apply_hooks(node_visitor.leave, node, parent)
-      end
-
-      # If one of the visitors returns SKIP, stop visiting this node
-      def self.apply_hooks(hooks, node, parent)
-        hooks.each do |proc|
-          return false if proc.call(node, parent) == SKIP
-        end
-        true
-      end
-
-      # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}
-      #
-      # Access {NodeVisitor}s via {GraphQL::Language::Visitor#[]}
-      class NodeVisitor
-        # @return [Array<Proc>] Hooks to call when entering a node of this type
-        attr_reader :enter
-        # @return [Array<Proc>] Hooks to call when leaving a node of this type
-        attr_reader :leave
-
-        def initialize
-          @enter = []
-          @leave = []
-        end
-
-        # Shorthand to add a hook to the {#enter} array
-        # @param hook [Proc] A hook to add
-        def <<(hook)
-          enter << hook
-        end
-      end
     end
   end
 end

data/lib/graphql/pagination/connection.rb

@@ -19,7 +19,14 @@ module GraphQL
       attr_reader :items
 
       # @return [GraphQL::Query::Context]
-      attr_accessor :context
+      attr_reader :context
+
+      def context=(new_ctx)
+        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        query_runtime_state = current_runtime_state[new_ctx.query]
+        @was_authorized_by_scope_items = query_runtime_state.was_authorized_by_scope_items
+        @context = new_ctx
+      end
 
       # @return [Object] the object this collection belongs to
       attr_accessor :parent
@@ -83,6 +90,17 @@ module GraphQL
         else
           default_page_size
         end
+        @was_authorized_by_scope_items = if @context
+          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          query_runtime_state = current_runtime_state[@context.query]
+          query_runtime_state.was_authorized_by_scope_items
+        else
+          nil
+        end
+      end
+
+      def was_authorized_by_scope_items?
+        @was_authorized_by_scope_items
       end
 
       def max_page_size=(new_value)
@@ -247,6 +265,10 @@ module GraphQL
         def cursor
           @cursor ||= @connection.cursor_for(@node)
         end
+
+        def was_authorized_by_scope_items?
+          @connection.was_authorized_by_scope_items?
+        end
       end
     end
   end

data/lib/graphql/query.rb

@@ -95,15 +95,10 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
-    # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
-      if only || except
-        merge_filters(except: except, only: only)
-      end
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
       @subscription_topic = subscription_topic
@@ -129,7 +124,6 @@ module GraphQL
         raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end
 
-
       @analysis_errors = []
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
@@ -354,17 +348,6 @@ module GraphQL
       with_prepared_ast { @query }
     end
 
-    # @return [void]
-    def merge_filters(only: nil, except: nil)
-      if @prepared_ast
-        raise "Can't add filters after preparing the query"
-      else
-        @filter ||= @schema.default_filter
-        @filter = @filter.merge(only: only, except: except)
-      end
-      nil
-    end
-
     def subscription?
       with_prepared_ast { @subscription }
     end
@@ -400,7 +383,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden ||= @schema.warden_class.new(@filter, schema: @schema, context: @context)
+      @warden ||= @schema.warden_class.new(schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string

data/lib/graphql/rake_task.rb

@@ -9,8 +9,7 @@ module GraphQL
   # By default, schemas are looked up by name as constants using `schema_name:`.
   # You can provide a `load_schema` function to return your schema another way.
   #
-  # `load_context:`, `only:` and `except:` are supported so that
-  # you can keep an eye on how filters affect your schema.
+  # Use `load_context:` and `visible?` to dump schemas under certain visibility constraints.
   #
   # @example Dump a Schema to .graphql + .json files
   #   require "graphql/rake_task"
@@ -36,8 +35,6 @@ module GraphQL
       schema_name: nil,
       load_schema: ->(task) { Object.const_get(task.schema_name) },
       load_context: ->(task) { {} },
-      only: nil,
-      except: nil,
       directory: ".",
       idl_outfile: "schema.graphql",
       json_outfile: "schema.json",
@@ -68,12 +65,6 @@ module GraphQL
     # @return [<#call(task)>] A callable for loading the query context
     attr_accessor :load_context
 
-    # @return [<#call(member, ctx)>, nil] A filter for this task
-    attr_accessor :only
-
-    # @return [<#call(member, ctx)>, nil] A filter for this task
-    attr_accessor :except
-
     # @return [String] target for IDL task
     attr_accessor :idl_outfile
 
@@ -117,10 +108,10 @@ module GraphQL
           include_is_repeatable: include_is_repeatable,
           include_specified_by_url: include_specified_by_url,
           include_schema_description: include_schema_description,
-          only: @only, except: @except, context: context
+          context: context
         )
       when :to_definition
-        schema.to_definition(only: @only, except: @except, context: context)
+        schema.to_definition(context: context)
       else
         raise ArgumentError, "Unexpected schema dump method: #{method_name.inspect}"
       end

data/lib/graphql/schema/argument.rb

@@ -53,7 +53,6 @@ module GraphQL
       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: NOT_CONFIGURED, 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)
-        NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
         @null = required != true
@@ -89,8 +88,11 @@ module GraphQL
         end
 
         if definition_block
-          # `self` will still be self, it will also be the first argument to the block:
-          instance_exec(self, &definition_block)
+          if definition_block.arity == 1
+            instance_exec(self, &definition_block)
+          else
+            instance_eval(&definition_block)
+          end
         end
       end
 

data/lib/graphql/schema/build_from_definition.rb

@@ -453,18 +453,17 @@ module GraphQL
 
             # Don't do this for interfaces
             if default_resolve
-              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
+              owner.class_eval <<-RUBY, __FILE__, __LINE__
+                # frozen_string_literal: true
+                def #{resolve_method_name}(**args)
+                  field_instance = self.class.get_field("#{field_definition.name}")
+                  context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+                end
+              RUBY
             end
           end
         end
 
-        def define_field_resolve_method(owner, method_name, field_name)
-          owner.define_method(method_name) { |**args|
-            field_instance = self.class.get_field(field_name)
-            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
-          }
-        end
-
         def build_resolve_type(lookup_hash, directives, missing_type_handler)
           resolve_type_proc = nil
           resolve_type_proc = ->(ast_node) {

data/lib/graphql/schema/directive.rb

@@ -99,7 +99,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_exec do
+          subclass.class_eval do
             @default_graphql_name ||= nil
           end
         end

data/lib/graphql/schema/enum_value.rb

@@ -47,7 +47,7 @@ module GraphQL
         end
 
         if block_given?
-          instance_exec(self, &block)
+          instance_eval(&block)
         end
       end
 

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

@@ -10,7 +10,13 @@ module GraphQL
           else
             ret_type = @field.type.unwrap
             if ret_type.respond_to?(:scope_items)
-              ret_type.scope_items(value, context)
+              scoped_items = ret_type.scope_items(value, context)
+              if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
+                current_runtime_state = Thread.current[:__graphql_runtime_info]
+                query_runtime_state = current_runtime_state[context.query]
+                query_runtime_state.was_authorized_by_scope_items = true
+              end
+              scoped_items
             else
               value
             end

data/lib/graphql/schema/field.rb

@@ -233,7 +233,7 @@ module GraphQL
 
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-        NameValidator.validate!(@name)
+
         @description = description
         @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
 

data/lib/graphql/schema/input_object.rb

@@ -131,7 +131,12 @@ module GraphQL
             end
           end
           # Add a method access
-          define_accessor_method(argument_defn.keyword)
+          method_name = argument_defn.keyword
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
           argument_defn
         end
 
@@ -237,13 +242,6 @@ module GraphQL
 
           result
         end
-
-        private
-
-        def define_accessor_method(method_name)
-          define_method(method_name) { self[method_name] }
-          alias_method(method_name, method_name)
-        end
       end
 
       private

data/lib/graphql/schema/interface.rb

@@ -69,11 +69,7 @@ module GraphQL
             end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
-            backtrace_line = caller_locations(0, 10).find do |location|
-              location.base_label == "implements" &&
-                location.path.end_with?("schema/member/has_interfaces.rb")
-            end
-
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end

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

@@ -6,7 +6,7 @@ module GraphQL
       module HasDirectives
         def self.extended(child_cls)
           super
-          child_cls.module_exec { self.own_directives = nil }
+          child_cls.module_eval { self.own_directives = nil }
         end
 
         def inherited(child_cls)

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

@@ -180,7 +180,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_exec do
+          subclass.class_eval do
             @own_fields ||= nil
             @field_class ||= nil
           end

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

@@ -119,7 +119,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_exec do
+          subclass.class_eval do
             @own_interface_type_memberships ||= nil
           end
         end

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

@@ -15,6 +15,25 @@ module GraphQL
         def scope_items(items, context)
           items
         end
+
+        def reauthorize_scoped_objects(new_value = nil)
+          if new_value.nil?
+            if @reauthorize_scoped_objects != nil
+              @reauthorize_scoped_objects
+            else
+              find_inherited_value(:reauthorize_scoped_objects, nil)
+            end
+          else
+            @reauthorize_scoped_objects = new_value
+          end
+        end
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @reauthorize_scoped_objects = nil
+          end
+        end
       end
     end
   end

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

@@ -43,7 +43,7 @@ module GraphQL
         private
 
         def inherited(subclass)
-          subclass.class_exec do
+          subclass.class_eval do
             @to_non_null_type ||= nil
             @to_list_type ||= nil
           end

data/lib/graphql/schema/object.rb

@@ -30,6 +30,10 @@ module GraphQL
         # @see authorized_new to make instances
         protected :new
 
+        def wrap_scoped(object, context)
+          scoped_new(object, context)
+        end
+
         # This is called by the runtime to return an object to call methods on.
         def wrap(object, context)
           authorized_new(object, context)
@@ -91,6 +95,10 @@ module GraphQL
             end
           end
         end
+
+        def scoped_new(object, context)
+          self.new(object, context)
+        end
       end
 
       def initialize(object, context)

data/lib/graphql/schema/printer.rb

@@ -36,15 +36,11 @@ module GraphQL
 
       # @param schema [GraphQL::Schema]
       # @param context [Hash]
-      # @param only [<#call(member, ctx)>]
-      # @param except [<#call(member, ctx)>]
       # @param introspection [Boolean] Should include the introspection types in the string?
-      def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
+      def initialize(schema, context: nil, introspection: false)
         @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
           context: context,
-          only: only,
-          except: except,
           include_introspection_types: introspection,
         )
 
@@ -61,7 +57,12 @@ module GraphQL
             false
           end
         end
-        schema = Class.new(GraphQL::Schema) { query(query_root) }
+        schema = Class.new(GraphQL::Schema) {
+          query(query_root)
+          def self.visible?(member, _ctx)
+            member.graphql_name != "Root"
+          end
+        }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
@@ -94,7 +95,7 @@ module GraphQL
 
       class IntrospectionPrinter < GraphQL::Language::Printer
         def print_schema_definition(schema)
-          "schema {\n  query: Root\n}"
+          print_string("schema {\n  query: Root\n}")
         end
       end
     end

data/lib/graphql/schema/subscription.rb

@@ -28,14 +28,19 @@ module GraphQL
       def resolve_with_support(**args)
         result = nil
         unsubscribed = true
-        catch :graphql_subscription_unsubscribed do
+        unsubscribed_result = catch :graphql_subscription_unsubscribed do
           result = super
           unsubscribed = false
         end
 
 
         if unsubscribed
-          context.skip
+          if unsubscribed_result
+            context.namespace(:subscriptions)[:final_update] = true
+            unsubscribed_result
+          else
+            context.skip
+          end
         else
           result
         end
@@ -94,9 +99,11 @@ module GraphQL
       end
 
       # Call this to halt execution and remove this subscription from the system
-      def unsubscribe
+      # @param update_value [Object] if present, deliver this update before unsubscribing
+      # @return [void]
+      def unsubscribe(update_value = nil)
         context.namespace(:subscriptions)[:unsubscribed] = true
-        throw :graphql_subscription_unsubscribed
+        throw :graphql_subscription_unsubscribed, update_value
       end
 
       READING_SCOPE = ::Object.new