graphql 2.0.26 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b25908e65f82d9c17e76e1f38b874e882c124b7102dc7ae2cb3caf4e819aa370
-  data.tar.gz: d3933abea4a559db3767c6a1ea3f37401432a7fd67842df6c9bd3e28e4034a8d
+  metadata.gz: 785d064bf9279c1c66291e629607bbfe14f33ea0a8ad3e22549d253116159f81
+  data.tar.gz: a66884908e066f99293c3171aa1856977ba01fde58dca3a65a978ef025de8f32
 SHA512:
-  metadata.gz: a8a85cb8ee54143b1ed00b6aa030479a1b48e164142e93e6b1e95f0f8cb44da36fcd1f3b53470f8edb783f43d469fd4e2dafa505217440832eb0d92165107239
-  data.tar.gz: dc61c951d84cc9199910145230cf55691d4fdb3a8f243b0e9f5dd9ee78c498a739de3d0bb72a65ade0cab07a9310a072dc7855ad5943425e778bd9b79f182e67
+  metadata.gz: f27e18f66f871cde5a6aedfea89621e57014c02062736b55aa86ebc4f64bdec83de93dca83c4aaede60c321113f4099efeab362cc3d4a2047d725e5ec2e7d73b
+  data.tar.gz: 4071a8921d60279b5ffc3ba11bb653e07596a9a97c0bab783c6a183558ff632996431d365052c27ea571b0b0c3a6a267f3cc10d1d4eff202eec513fc469f094e

data/lib/generators/graphql/relay.rb

@@ -6,7 +6,24 @@ module Graphql
         # Add Node, `node(id:)`, and `nodes(ids:)`
         template("node_type.erb", "#{options[:directory]}/types/node_type.rb")
         in_root do
-          fields = "    # Add `node(id: ID!) and `nodes(ids: [ID!]!)`\n    include GraphQL::Types::Relay::HasNodeField\n    include GraphQL::Types::Relay::HasNodesField\n\n"
+          fields = <<-RUBY
+    field :node, Types::NodeType, null: true, description: "Fetches an object given its ID." do
+      argument :id, ID, required: true, description: "ID of the object."
+    end
+
+    def node(id:)
+      context.schema.object_from_id(id, context)
+    end
+
+    field :nodes, [Types::NodeType, null: true], null: true, description: "Fetches a list of objects given a list of IDs." do
+      argument :ids, [ID], required: true, description: "IDs of the objects."
+    end
+
+    def nodes(ids:)
+      ids.map { |id| context.schema.object_from_id(id, context) }
+    end
+
+    RUBY
           inject_into_file "#{options[:directory]}/types/query_type.rb", fields, after: /class .*QueryType\s*<\s*[^\s]+?\n/m, force: false
         end
 

data/lib/graphql/execution/interpreter/runtime.rb

@@ -15,10 +15,11 @@ module GraphQL
             @current_arguments = nil
             @current_result_name = nil
             @current_result = nil
+            @was_authorized_by_scope_items = nil
           end
 
           attr_accessor :current_result, :current_result_name,
-            :current_arguments, :current_field, :current_object
+            :current_arguments, :current_field, :current_object, :was_authorized_by_scope_items
         end
 
         module GraphQLResult
@@ -244,6 +245,7 @@ module GraphQL
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
+
           st = get_current_runtime_state
           st.current_object = query.root_value
           st.current_result = @response
@@ -426,12 +428,6 @@ module GraphQL
             end
           end
 
-          return_type = field_defn.type
-
-          # This seems janky, but we need to know
-          # the field's return type at this path in order
-          # to propagate `null`
-          return_type_non_null = return_type.non_null?
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           st = get_current_runtime_state
           st.current_field = field_defn
@@ -441,26 +437,27 @@ module GraphQL
           if is_introspection
             owner_object = field_defn.owner.wrap(owner_object, context)
           end
-
+          return_type = field_defn.type
           total_args_count = field_defn.arguments(context).size
           if total_args_count == 0
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
             if field_defn.extras.size == 0
               evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
+                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type.non_null?
               )
             else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type)
             end
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type)
             end
           end
         end
 
-        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
+            return_type_non_null = return_type.non_null?
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
               continue_value(resolved_arguments, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
@@ -553,7 +550,10 @@ module GraphQL
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
               continue_value = continue_value(inner_result, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
-                continue_field(continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result)
+                st = get_current_runtime_state
+                was_scoped = st.was_authorized_by_scope_items
+                st.was_authorized_by_scope_items = nil
+                continue_field(continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result, was_scoped)
               end
             end
           end
@@ -733,7 +733,7 @@ module GraphQL
         # Location information from `path` and `ast_node`.
         #
         # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
-        def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
+        def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped) # rubocop:disable Metrics/ParameterLists
           if current_type.non_null?
             current_type = current_type.of_type
             is_non_null = true
@@ -767,12 +767,12 @@ module GraphQL
                 set_result(selection_result, result_name, nil, false, is_non_null)
                 nil
               else
-                continue_field(resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result)
+                continue_field(resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped)
               end
             end
           when "OBJECT"
             object_proxy = begin
-              current_type.wrap(value, context)
+              was_scoped ? current_type.wrap_scoped(value, context) : current_type.wrap(value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
@@ -804,7 +804,6 @@ module GraphQL
                   st.current_object = continue_value
                   st.current_result_name = nil
                   st.current_result = this_result
-
                   # This is a less-frequent case; use a fast check since it's often not there.
                   if (directives = selections[:graphql_directives])
                     selections.delete(:graphql_directives)
@@ -839,10 +838,10 @@ module GraphQL
                 idx += 1
                 if use_dataloader_job
                   @dataloader.append_job do
-                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
+                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped)
                   end
                 else
-                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
+                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped)
                 end
               end
 
@@ -873,7 +872,7 @@ module GraphQL
           end
         end
 
-        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
+        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped) # rubocop:disable Metrics/ParameterLists
           st = get_current_runtime_state
           st.current_result_name = this_idx
           st.current_result = response_list
@@ -882,7 +881,7 @@ module GraphQL
             after_lazy(inner_value, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
               continue_value = continue_value(inner_inner_value, owner_type, field, inner_type_non_null, ast_node, this_idx, response_list)
               if HALT != continue_value
-                continue_field(continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
+                continue_field(continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list, was_scoped)
               end
             end
           end
@@ -962,6 +961,8 @@ module GraphQL
         def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, trace: true, &block)
           if lazy?(lazy_obj)
             orig_result = result
+            st = get_current_runtime_state
+            was_authorized_by_scope_items = st.was_authorized_by_scope_items
             lazy = GraphQL::Execution::Lazy.new(field: field) do
               st = get_current_runtime_state
               st.current_object = owner_object
@@ -969,6 +970,7 @@ module GraphQL
               st.current_arguments = arguments
               st.current_result_name = result_name
               st.current_result = orig_result
+              st.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin

data/lib/graphql/language/document_from_schema_definition.rb

@@ -14,7 +14,7 @@ module GraphQL
     # @param include_built_in_directives [Boolean] Whether or not to include built in directives in the AST
     class DocumentFromSchemaDefinition
       def initialize(
-        schema, context: nil, only: nil, except: nil, include_introspection_types: false,
+        schema, context: nil, include_introspection_types: false,
         include_built_in_directives: false, include_built_in_scalars: false, always_include_schema: false
       )
         @schema = schema
@@ -26,21 +26,11 @@ module GraphQL
 
         schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
 
-        @warden = if only || except
-          filter = GraphQL::Filter
-            .new(only: only, except: except)
-            .merge(only: @schema.method(:visible?))
-          GraphQL::Schema::Warden.new(
-              filter,
-              schema: @schema,
-              context: schema_context,
-            )
-        else
-          @schema.warden_class.new(
-            schema: @schema,
-            context: schema_context,
-          )
-        end
+
+        @warden = @schema.warden_class.new(
+          schema: @schema,
+          context: schema_context,
+        )
 
         schema_context.warden = @warden
       end

data/lib/graphql/language/lexer.rb

@@ -4,7 +4,7 @@ require "strscan"
 
 module GraphQL
   module Language
-    module Lexer
+    class Lexer
       IDENTIFIER =    /[_A-Za-z][_0-9A-Za-z]*/
       NEWLINE =       /[\c\r\n]/
       BLANK   =       /[, \t]+/
@@ -87,60 +87,81 @@ module GraphQL
       # # catch-all for anything else. must be at the bottom for precedence.
       UNKNOWN_CHAR =         /./
 
-      def self.tokenize string
-        meta = {
-          line: 1,
-          col: 1,
-          tokens: [],
-          previous_token: nil,
-        }
+      def initialize(value)
+        @line = 1
+        @col = 1
+        @previous_token = nil
 
+        @scan = scanner value
+      end
+
+      class BadEncoding < Lexer # :nodoc:
+        def scanner(value)
+          [emit(:BAD_UNICODE_ESCAPE, 0, 0, value)]
+        end
+
+        def next_token
+          @scan.pop
+        end
+      end
+
+      def self.tokenize(string)
         value = string.dup.force_encoding(Encoding::UTF_8)
 
-        unless value.valid_encoding?
-          emit(:BAD_UNICODE_ESCAPE, 0, 0, meta, value)
-          return meta[:tokens]
+        scanner = if value.valid_encoding?
+          new value
+        else
+          BadEncoding.new value
         end
 
-        scan = StringScanner.new value
-
-        while !scan.eos?
-          pos = scan.pos
-
-          case
-          when str = scan.scan(FLOAT)         then emit(:FLOAT, pos, scan.pos, meta, str)
-          when str = scan.scan(INT)           then emit(:INT, pos, scan.pos, meta, str)
-          when str = scan.scan(LIT)           then emit(LIT_NAME_LUT[str], pos, scan.pos, meta, -str)
-          when str = scan.scan(IDENTIFIER)    then emit(:IDENTIFIER, pos, scan.pos, meta, str)
-          when str = scan.scan(BLOCK_STRING)  then emit_block(pos, scan.pos, meta, str.gsub(/^#{BLOCK_QUOTE}|#{BLOCK_QUOTE}$/, ''))
-          when str = scan.scan(QUOTED_STRING) then emit_string(pos, scan.pos, meta, str.gsub(/^"|"$/, ''))
-          when str = scan.scan(COMMENT)       then record_comment(pos, scan.pos, meta, str)
-          when str = scan.scan(NEWLINE)
-            meta[:line] += 1
-            meta[:col] = 1
-          when scan.scan(BLANK)
-            meta[:col] += scan.pos - pos
-          when str = scan.scan(UNKNOWN_CHAR) then emit(:UNKNOWN_CHAR, pos, scan.pos, meta, str)
-          else
-            # This should never happen since `UNKNOWN_CHAR` ensures we make progress
-            raise "Unknown string?"
-          end
+        toks = []
+
+        while tok = scanner.next_token
+          toks << tok
         end
 
-        meta[:tokens]
+        toks
+      end
+
+      def next_token
+        return if @scan.eos?
+
+        pos = @scan.pos
+
+        case
+        when str = @scan.scan(FLOAT)         then emit(:FLOAT, pos, @scan.pos, str)
+        when str = @scan.scan(INT)           then emit(:INT, pos, @scan.pos, str)
+        when str = @scan.scan(LIT)           then emit(LIT_NAME_LUT[str], pos, @scan.pos, -str)
+        when str = @scan.scan(IDENTIFIER)    then emit(:IDENTIFIER, pos, @scan.pos, str)
+        when str = @scan.scan(BLOCK_STRING)  then emit_block(pos, @scan.pos, str.gsub(/\A#{BLOCK_QUOTE}|#{BLOCK_QUOTE}\z/, ''))
+        when str = @scan.scan(QUOTED_STRING) then emit_string(pos, @scan.pos, str.gsub(/^"|"$/, ''))
+        when str = @scan.scan(COMMENT)       then record_comment(pos, @scan.pos, str)
+        when str = @scan.scan(NEWLINE)
+          @line += 1
+          @col = 1
+          next_token
+        when @scan.scan(BLANK)
+          @col += @scan.pos - pos
+          next_token
+        when str = @scan.scan(UNKNOWN_CHAR) then emit(:UNKNOWN_CHAR, pos, @scan.pos, str)
+        else
+          # This should never happen since `UNKNOWN_CHAR` ensures we make progress
+          raise "Unknown string?"
+        end
       end
 
-      def self.emit(token_name, ts, te, meta, token_value)
-        meta[:tokens] << token = [
+      def emit(token_name, ts, te, token_value)
+        token = [
           token_name,
-          meta[:line],
-          meta[:col],
+          @line,
+          @col,
           token_value,
-          meta[:previous_token],
+          @previous_token,
         ]
-        meta[:previous_token] = token
+        @previous_token = token
         # Bump the column counter for the next token
-        meta[:col] += te - ts
+        @col += te - ts
+        token
       end
 
       # Replace any escaped unicode or whitespace with the _actual_ characters
@@ -169,18 +190,19 @@ module GraphQL
         nil
       end
 
-      def self.record_comment(ts, te, meta, str)
+      def record_comment(ts, te, str)
         token = [
           :COMMENT,
-          meta[:line],
-          meta[:col],
+          @line,
+          @col,
           str,
-          meta[:previous_token],
+          @previous_token,
         ]
 
-        meta[:previous_token] = token
+        @previous_token = token
 
-        meta[:col] += te - ts
+        @col += te - ts
+        next_token
       end
 
       ESCAPES = /\\["\\\/bfnrt]/
@@ -197,26 +219,34 @@ module GraphQL
       UTF_8 = /\\u(?:([\dAa-f]{4})|\{([\da-f]{4,})\})(?:\\u([\dAa-f]{4}))?/i
       VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
 
-      def self.emit_block(ts, te, meta, value)
+      def emit_block(ts, te, value)
         line_incr = value.count("\n")
         value = GraphQL::Language::BlockString.trim_whitespace(value)
-        emit_string(ts, te, meta, value)
-        meta[:line] += line_incr
+        tok = emit_string(ts, te, value)
+        @line += line_incr
+        tok
       end
 
-      def self.emit_string(ts, te, meta, value)
+      def emit_string(ts, te, value)
         if !value.valid_encoding? || !value.match?(VALID_STRING)
-          emit(:BAD_UNICODE_ESCAPE, ts, te, meta, value)
+          emit(:BAD_UNICODE_ESCAPE, ts, te, value)
         else
-          replace_escaped_characters_in_place(value)
+          self.class.replace_escaped_characters_in_place(value)
 
           if !value.valid_encoding?
-            emit(:BAD_UNICODE_ESCAPE, ts, te, meta, value)
+            emit(:BAD_UNICODE_ESCAPE, ts, te, value)
           else
-            emit(:STRING, ts, te, meta, value)
+            emit(:STRING, ts, te, value)
           end
         end
       end
+
+      private
+
+      def scanner(value)
+        StringScanner.new value
+      end
+
     end
   end
 end

data/lib/graphql/language/nodes.rb

@@ -535,7 +535,7 @@ module GraphQL
       # @example Creating a custom string from a document
       #  class VariableScrubber < GraphQL::Language::Printer
       #    def print_argument(arg)
-      #      "#{arg.name}: <HIDDEN>"
+      #      print_string("#{arg.name}: <HIDDEN>")
       #    end
       #  end
       #