graphql 2.4.5 → 2.5.0

data/lib/graphql/dataloader.rb

@@ -4,6 +4,8 @@ require "graphql/dataloader/null_dataloader"
 require "graphql/dataloader/request"
 require "graphql/dataloader/request_all"
 require "graphql/dataloader/source"
+require "graphql/dataloader/active_record_association_source"
+require "graphql/dataloader/active_record_source"
 
 module GraphQL
   # This plugin supports Fiber-based concurrency, along with {GraphQL::Dataloader::Source}.
@@ -129,8 +131,11 @@ module GraphQL
     # Dataloader will resume the fiber after the requested data has been loaded (by another Fiber).
     #
     # @return [void]
-    def yield
+    def yield(source = Fiber[:__graphql_current_dataloader_source])
+      trace = Fiber[:__graphql_current_multiplex]&.current_trace
+      trace&.dataloader_fiber_yield(source)
       Fiber.yield
+      trace&.dataloader_fiber_resume(source)
       nil
     end
 
@@ -184,6 +189,7 @@ module GraphQL
     end
 
     def run
+      trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
       next_job_fibers = []
@@ -191,10 +197,11 @@ module GraphQL
       next_source_fibers = []
       first_pass = true
       manager = spawn_fiber do
+        trace&.begin_dataloader(self)
         while first_pass || !job_fibers.empty?
           first_pass = false
 
-          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber)))
+          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
             if f.alive?
               finished = run_fiber(f)
               if !finished
@@ -205,7 +212,7 @@ module GraphQL
           join_queues(job_fibers, next_job_fibers)
 
           while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
-            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber))
+            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
               if f.alive?
                 finished = run_fiber(f)
                 if !finished
@@ -216,6 +223,8 @@ module GraphQL
             join_queues(source_fibers, next_source_fibers)
           end
         end
+
+        trace&.end_dataloader(self)
       end
 
       run_fiber(manager)
@@ -230,6 +239,7 @@ module GraphQL
       if !source_fibers.empty?
         raise "Invariant: source fibers should have exited but #{source_fibers.size} remained"
       end
+
     rescue UncaughtThrowError => e
       throw e.tag, e.value
     end
@@ -247,6 +257,22 @@ module GraphQL
       }
     end
 
+    # Pre-warm the Dataloader cache with ActiveRecord objects which were loaded elsewhere.
+    # These will be used by {Dataloader::ActiveRecordSource}, {Dataloader::ActiveRecordAssociationSource} and their helper
+    # methods, `dataload_record` and `dataload_association`.
+    # @param records [Array<ActiveRecord::Base>] Already-loaded records to warm the cache with
+    # @param index_by [Symbol] The attribute to use as the cache key. (Should match `find_by:` when using {ActiveRecordSource})
+    # @return [void]
+    def merge_records(records, index_by: :id)
+      records_by_class = Hash.new { |h, k| h[k] = {} }
+      records.each do |r|
+        records_by_class[r.class][r.public_send(index_by)] = r
+      end
+      records_by_class.each do |r_class, records|
+        with(ActiveRecordSource, r_class).merge(records)
+      end
+    end
+
     private
 
     def calculate_fiber_limit
@@ -266,17 +292,19 @@ module GraphQL
       new_queue.clear
     end
 
-    def spawn_job_fiber
+    def spawn_job_fiber(trace)
       if !@pending_jobs.empty?
         spawn_fiber do
+          trace&.dataloader_spawn_execution_fiber(@pending_jobs)
           while job = @pending_jobs.shift
             job.call
           end
+          trace&.dataloader_fiber_exit
         end
       end
     end
 
-    def spawn_source_fiber
+    def spawn_source_fiber(trace)
       pending_sources = nil
       @source_cache.each_value do |source_by_batch_params|
         source_by_batch_params.each_value do |source|
@@ -289,10 +317,14 @@ module GraphQL
 
       if pending_sources
         spawn_fiber do
+          trace&.dataloader_spawn_source_fiber(pending_sources)
           pending_sources.each do |source|
             Fiber[:__graphql_current_dataloader_source] = source
+            trace&.begin_dataloader_source(source)
             source.run_pending_keys
+            trace&.end_dataloader_source(source)
           end
+          trace&.dataloader_fiber_exit
         end
       end
     end

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

@@ -5,7 +5,10 @@ module GraphQL
     class Interpreter
       class Runtime
         module GraphQLResult
-          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager)
+          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager, ast_node, graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+            @ast_node = ast_node
+            @graphql_arguments = graphql_arguments
+            @graphql_field = graphql_field
             @graphql_parent = parent_result
             @graphql_application_value = application_value
             @graphql_result_type = result_type
@@ -31,14 +34,14 @@ module GraphQL
 
           attr_accessor :graphql_dead
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
-            :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager
+            :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
 
           # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
 
         class GraphQLResultHash
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = {}
           end
@@ -126,7 +129,7 @@ module GraphQL
         class GraphQLResultArray
           include GraphQLResult
 
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = []
           end
@@ -168,6 +171,10 @@ module GraphQL
           def values
             (@graphql_metadata || @graphql_result_data)
           end
+
+          def [](idx)
+            (@graphql_metadata || @graphql_result_data)[idx]
+          end
         end
       end
     end

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

@@ -74,7 +74,7 @@ module GraphQL
           runtime_object = root_type.wrap(query.root_value, context)
           runtime_object = schema.sync_lazy(runtime_object)
           is_eager = root_op_type == "mutation"
-          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager)
+          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager, root_operation, nil, nil)
           st = get_current_runtime_state
           st.current_result = @response
 
@@ -85,7 +85,7 @@ module GraphQL
             call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
               each_gathered_selections(@response) do |selections, is_selection_array|
                 if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager)
+                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager, root_operation, nil, nil)
                   final_response = @response
                 else
                   selection_response = @response
@@ -218,8 +218,10 @@ module GraphQL
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
                   finished_jobs += 1
-                  if target_result && finished_jobs == enqueued_jobs
-                    selections_result.merge_into(target_result)
+                  if finished_jobs == enqueued_jobs
+                    if target_result
+                      selections_result.merge_into(target_result)
+                    end
                   end
                   @dataloader.clear_cache
                 }
@@ -229,8 +231,10 @@ module GraphQL
                     result_name, field_ast_nodes_or_ast_node, selections_result
                   )
                   finished_jobs += 1
-                  if target_result && finished_jobs == enqueued_jobs
-                    selections_result.merge_into(target_result)
+                  if finished_jobs == enqueued_jobs
+                    if target_result
+                      selections_result.merge_into(target_result)
+                    end
                   end
                 }
               end
@@ -371,6 +375,7 @@ module GraphQL
             end
             # Actually call the field resolver and capture the result
             app_result = begin
+              @current_trace.begin_execute_field(field_defn, object, kwarg_arguments, query)
               @current_trace.execute_field(field: field_defn, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments) do
                 field_defn.resolve(object, kwarg_arguments, context)
               end
@@ -383,6 +388,7 @@ module GraphQL
                 ex_err
               end
             end
+            @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
               owner_type = selection_result.graphql_result_type
               return_type = field_defn.type
@@ -391,6 +397,8 @@ module GraphQL
                 was_scoped = runtime_state.was_authorized_by_scope_items
                 runtime_state.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, runtime_state)
+              else
+                nil
               end
             end
           end
@@ -465,7 +473,7 @@ module GraphQL
                 # When this comes from a list item, use the parent object:
                 parent_type = selection_result.is_a?(GraphQLResultArray) ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
-                err = parent_type::InvalidNullError.new(parent_type, field, value)
+                err = parent_type::InvalidNullError.new(parent_type, field, ast_node)
                 schema.type_error(err, context)
               end
             else
@@ -574,12 +582,22 @@ module GraphQL
             r = begin
               current_type.coerce_result(value, context)
             rescue StandardError => err
-              schema.handle_or_reraise(context, err)
+              query.handle_or_reraise(err)
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy = resolve_type(current_type, value)
+            resolved_type_or_lazy = begin
+                                      resolve_type(current_type, value)
+                                    rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+                                      return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+                                    rescue StandardError => err
+                                      begin
+                                        query.handle_or_reraise(err)
+                                      rescue GraphQL::ExecutionError => ex_err
+                                        return continue_value(ex_err, field, is_non_null, ast_node, result_name, selection_result)
+                                      end
+                                    end
             after_lazy(resolved_type_or_lazy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_type_result, runtime_state|
               if resolved_type_result.is_a?(Array) && resolved_type_result.length == 2
                 resolved_type, resolved_value = resolved_type_result
@@ -609,11 +627,11 @@ module GraphQL
             after_lazy(object_proxy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_object, runtime_state|
               continue_value = continue_value(inner_object, field, is_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
-                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false)
+                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
                 each_gathered_selections(response_hash) do |selections, is_selection_array|
                   if is_selection_array
-                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false)
+                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false, ast_node, arguments, field)
                     final_result = response_hash
                   else
                     this_result = response_hash
@@ -634,35 +652,43 @@ module GraphQL
             # This is true for objects, unions, and interfaces
             use_dataloader_job = !inner_type.unwrap.kind.input?
             inner_type_non_null = inner_type.non_null?
-            response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false)
+            response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
             set_result(selection_result, result_name, response_list, true, is_non_null)
             idx = nil
             list_value = begin
-              value.each do |inner_value|
-                idx ||= 0
-                this_idx = idx
-                idx += 1
-                if use_dataloader_job
-                  @dataloader.append_job do
+              begin
+                value.each do |inner_value|
+                  idx ||= 0
+                  this_idx = idx
+                  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, owner_type, was_scoped, runtime_state)
+                    end
+                  else
                     resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
                   end
-                else
-                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
                 end
-              end
 
-              response_list
-            rescue NoMethodError => err
-              # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
-              if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
-                # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
-                raise ListResultFailedError.new(value: value, field: field, path: current_path)
-              else
-                # This was some other NoMethodError -- let it bubble to reveal the real error.
-                raise
+                response_list
+              rescue NoMethodError => err
+                # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
+                if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
+                  # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
+                  raise ListResultFailedError.new(value: value, field: field, path: current_path)
+                else
+                  # This was some other NoMethodError -- let it bubble to reveal the real error.
+                  raise
+                end
+              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+                ex_err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
-            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
-              ex_err
             rescue StandardError => err
               begin
                 query.handle_or_reraise(err)
@@ -773,8 +799,10 @@ module GraphQL
               runtime_state.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
+              result = nil
               inner_obj = begin
-                if trace
+                result = if trace
+                  @current_trace.begin_execute_field(field, owner_object, arguments, query)
                   @current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
                   end
@@ -789,6 +817,10 @@ module GraphQL
                 rescue GraphQL::ExecutionError => ex_err
                   ex_err
                 end
+              ensure
+                if trace
+                  @current_trace.end_execute_field(field, owner_object, arguments, query, result)
+                end
               end
               yield(inner_obj, runtime_state)
             end
@@ -832,14 +864,19 @@ module GraphQL
         end
 
         def resolve_type(type, value)
+          @current_trace.begin_resolve_type(type, value, context)
           resolved_type, resolved_value = @current_trace.resolve_type(query: query, type: type, object: value) do
             query.resolve_type(type, value)
           end
+          @current_trace.end_resolve_type(type, value, context, resolved_type)
 
           if lazy?(resolved_type)
             GraphQL::Execution::Lazy.new do
+              @current_trace.begin_resolve_type(type, value, context)
               @current_trace.resolve_type_lazy(query: query, type: type, object: value) do
-                schema.sync_lazy(resolved_type)
+                rt = schema.sync_lazy(resolved_type)
+                @current_trace.end_resolve_type(type, value, context, rt)
+                rt
               end
             end
           else

data/lib/graphql/execution/interpreter.rb

@@ -23,7 +23,7 @@ module GraphQL
         # @return [Array<GraphQL::Query::Result>] One result per query
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
           queries = query_options.map do |opts|
-            case opts
+            query = case opts
             when Hash
               schema.query_class.new(schema, nil, **opts)
             when GraphQL::Query
@@ -31,11 +31,15 @@ module GraphQL
             else
               raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
             end
+            query
           end
 
+          return GraphQL::EmptyObjects::EMPTY_ARRAY if queries.empty?
+
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          trace = multiplex.current_trace
           Fiber[:__graphql_current_multiplex] = multiplex
-          multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
+          trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
@@ -44,7 +48,10 @@ module GraphQL
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
             end
 
+            trace.begin_analyze_multiplex(multiplex, multiplex_analyzers)
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            trace.end_analyze_multiplex(multiplex, multiplex_analyzers)
+
             begin
               # Since this is basically the batching context,
               # share it for a whole multiplex
@@ -53,7 +60,9 @@ module GraphQL
               results = []
               queries.each_with_index do |query, idx|
                 if query.subscription? && !query.subscription_update?
-                  query.context.namespace(:subscriptions)[:events] = []
+                  subs_namespace = query.context.namespace(:subscriptions)
+                  subs_namespace[:events] = []
+                  subs_namespace[:subscriptions] = {}
                 end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation

data/lib/graphql/execution/multiplex.rb

@@ -32,14 +32,10 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @current_trace = @context[:trace] || schema.new_trace(multiplex: self)
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
-        # Support `context: {backtrace: true}`
-        if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-          @tracers << GraphQL::Backtrace::Tracer
-        end
         @max_complexity = max_complexity
+        @current_trace = context[:trace] ||= schema.new_trace(multiplex: self)
       end
     end
   end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -7,7 +7,7 @@ module GraphQL
                   "a __DirectiveLocation describes one such possible adjacencies."
 
       GraphQL::Schema::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location, value_method: false)
       end
       introspection true
     end

data/lib/graphql/invalid_name_error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  class InvalidNameError < GraphQL::ExecutionError
+  class InvalidNameError < GraphQL::Error
     attr_reader :name, :valid_regex
     def initialize(name, valid_regex)
       @name = name

data/lib/graphql/invalid_null_error.rb

@@ -2,33 +2,23 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::RuntimeTypeError
+  class InvalidNullError < GraphQL::Error
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
     # @return [GraphQL::Field] The field which failed to return a value
     attr_reader :field
 
-    # @return [nil, GraphQL::ExecutionError] The invalid value for this field
-    attr_reader :value
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
+    attr_reader :ast_node
 
-    def initialize(parent_type, field, value)
+    def initialize(parent_type, field, ast_node)
       @parent_type = parent_type
       @field = field
-      @value = value
+      @ast_node = ast_node
       super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end
 
-    # @return [Hash] An entry for the response's "errors" key
-    def to_h
-      { "message" => message }
-    end
-
-    # @deprecated always false
-    def parent_error?
-      false
-    end
-
     class << self
       attr_accessor :parent_class
 

data/lib/graphql/language/lexer.rb

@@ -13,17 +13,21 @@ module GraphQL
         @pos = nil
         @max_tokens = max_tokens || Float::INFINITY
         @tokens_count = 0
+        @finished = false
       end
 
-      def eos?
-        @scanner.eos?
+      def finished?
+        @finished
       end
 
       attr_reader :pos, :tokens_count
 
       def advance
         @scanner.skip(IGNORE_REGEXP)
-        return false if @scanner.eos?
+        if @scanner.eos?
+          @finished = true
+          return false
+        end
         @tokens_count += 1
         if @tokens_count > @max_tokens
           raise_parse_error("This query is too large to execute.")

data/lib/graphql/language/nodes.rb

@@ -141,6 +141,8 @@ module GraphQL
         end
 
         class << self
+          # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
           # Add a default `#visit_method` and `#children_method_name` using the class name
           def inherited(child_class)
             super
@@ -343,6 +345,7 @@ module GraphQL
               RUBY
             end
           end
+          # rubocop:enable Development/NoEvalCop
         end
       end
 

data/lib/graphql/language/parser.rb

@@ -110,7 +110,7 @@ module GraphQL
           # Only ignored characters is not a valid document
           raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @graphql_str)
         end
-        while !@lexer.eos?
+        while !@lexer.finished?
           defns << definition
         end
         Document.new(pos: 0, definitions: defns, filename: @filename, source: self)
@@ -161,7 +161,7 @@ module GraphQL
               expect_token(:VAR_SIGN)
               var_name = parse_name
               expect_token(:COLON)
-              var_type = self.type
+              var_type = self.type || raise_parse_error("Missing type definition for variable: $#{var_name}")
               default_value = if at?(:EQUALS)
                 advance_token
                 value
@@ -488,26 +488,33 @@ module GraphQL
       end
 
       def type
-        type = case token_name
+        parsed_type = case token_name
         when :IDENTIFIER
           parse_type_name
         when :LBRACKET
           list_type
+        else
+          nil
         end
 
-        if at?(:BANG)
-          type = Nodes::NonNullType.new(pos: pos, of_type: type, source: self)
+        if at?(:BANG) && parsed_type
+          parsed_type = Nodes::NonNullType.new(pos: pos, of_type: parsed_type, source: self)
           expect_token(:BANG)
         end
-        type
+        parsed_type
       end
 
       def list_type
         loc = pos
         expect_token(:LBRACKET)
-        type = Nodes::ListType.new(pos: loc, of_type: self.type, source: self)
+        inner_type = self.type
+        parsed_list_type = if inner_type
+          Nodes::ListType.new(pos: loc, of_type: inner_type, source: self)
+        else
+          nil
+        end
         expect_token(:RBRACKET)
-        type
+        parsed_list_type
       end
 
       def parse_operation_type