graphql 1.9.21 → 1.10.0.pre1

data/lib/graphql/execution/execute.rb

@@ -20,7 +20,7 @@ module GraphQL
 
       def execute(ast_operation, root_type, query)
         result = resolve_root_selection(query)
-        lazy_resolve_root_selection(result, **{query: query})
+        lazy_resolve_root_selection(result, {query: query})
         GraphQL::Execution::Flatten.call(query.context)
       end
 

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

@@ -11,7 +11,7 @@ module GraphQL
         # @return [GraphQL::Query]
         attr_reader :query
 
-        # @return [Class<GraphQL::Schema>]
+        # @return [Class]
         attr_reader :schema
 
         # @return [GraphQL::Query::Context]
@@ -43,22 +43,19 @@ module GraphQL
         # might be stored up in lazies.
         # @return [void]
         def run_eager
-
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           legacy_root_type = schema.root_type_for_operation(root_op_type)
           root_type = legacy_root_type.metadata[:type_class] || raise("Invariant: type must be class-based: #{legacy_root_type}")
-          path = []
-          @interpreter_context[:current_object] = query.root_value
-          @interpreter_context[:current_path] = path
           object_proxy = root_type.authorized_new(query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
             # Root .authorized? returned false.
-            write_in_response(path, nil)
+            write_in_response([], nil)
             nil
           else
-            evaluate_selections(path, context.scoped_context, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
+            path = []
+            evaluate_selections(path, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
             nil
           end
         end
@@ -118,9 +115,7 @@ module GraphQL
           end
         end
 
-        def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
-          @interpreter_context[:current_object] = owner_object
-          @interpreter_context[:current_path] = path
+        def evaluate_selections(path, owner_object, owner_type, selections, root_operation_type: nil)
           selections_by_name = {}
           gather_selections(owner_object, owner_type, selections, selections_by_name)
           selections_by_name.each do |result_name, field_ast_nodes_or_ast_node|
@@ -163,7 +158,6 @@ module GraphQL
             @interpreter_context[:current_path] = next_path
             @interpreter_context[:current_field] = field_defn
 
-            context.scoped_context = scoped_context
             object = owner_object
 
             if is_introspection
@@ -201,8 +195,6 @@ module GraphQL
               end
             end
 
-            @interpreter_context[:current_arguments] = kwarg_arguments
-
             # Optimize for the case that field is selected only once
             if field_ast_nodes.nil? || field_ast_nodes.size == 1
               next_selections = ast_node.selections
@@ -214,15 +206,13 @@ module GraphQL
             field_result = resolve_with_directives(object, ast_node) do
               # Actually call the field resolver and capture the result
               app_result = begin
-                query.with_error_handling do
-                  query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, query: query, object: object, arguments: kwarg_arguments}) do
-                    field_defn.resolve(object, kwarg_arguments, context)
-                  end
+                query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, query: query, object: object, arguments: kwarg_arguments}) do
+                  field_defn.resolve(object, kwarg_arguments, context)
                 end
               rescue GraphQL::ExecutionError => err
                 err
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, owner_object: object, arguments: kwarg_arguments) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
@@ -296,7 +286,7 @@ module GraphQL
             r
           when "UNION", "INTERFACE"
             resolved_type_or_lazy = query.resolve_type(type, value)
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
+            after_lazy(resolved_type_or_lazy, owner: type, path: path, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
@@ -316,12 +306,12 @@ module GraphQL
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
+            after_lazy(object_proxy, owner: type, path: path, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
               continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
                 write_in_response(path, response_hash)
-                evaluate_selections(path, context.scoped_context, continue_value, type, next_selections)
+                evaluate_selections(path, continue_value, type, next_selections)
                 response_hash
               end
             end
@@ -330,7 +320,6 @@ module GraphQL
             write_in_response(path, response_list)
             inner_type = type.of_type
             idx = 0
-            scoped_context = context.scoped_context
             value.each do |inner_value|
               next_path = path.dup
               next_path << idx
@@ -338,7 +327,7 @@ module GraphQL
               idx += 1
               set_type_at_path(next_path, inner_type)
               # This will update `response_list` with the lazy
-              after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
+              after_lazy(inner_value, owner: inner_type, path: next_path, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
                 # reset `is_non_null` here and below, because the inner type will have its own nullability constraint
                 continue_value = continue_value(next_path, inner_inner_value, field, false, ast_node)
                 if HALT != continue_value
@@ -404,30 +393,23 @@ module GraphQL
         # @param field [GraphQL::Schema::Field]
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false)
-          @interpreter_context[:current_object] = owner_object
-          @interpreter_context[:current_arguments] = arguments
+        def after_lazy(lazy_obj, owner:, field:, path:, owner_object:, arguments:, eager: false)
           @interpreter_context[:current_path] = path
           @interpreter_context[:current_field] = field
           if schema.lazy?(lazy_obj)
             lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
               @interpreter_context[:current_path] = path
               @interpreter_context[:current_field] = field
-              @interpreter_context[:current_object] = owner_object
-              @interpreter_context[:current_arguments] = arguments
-              context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
-                query.with_error_handling do
-                  query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments}) do
-                    schema.sync_lazy(lazy_obj)
-                  end
+                query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments}) do
+                  schema.sync_lazy(lazy_obj)
                 end
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
                   yield(err)
               end
-              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
+              after_lazy(inner_obj, owner: owner, field: field, path: path, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
                 yield(really_inner_obj)
               end
             end
@@ -518,11 +500,7 @@ module GraphQL
             args = arguments(nil, arg_type, ast_value)
             # We're not tracking defaults_used, but for our purposes
             # we compare the value to the default value.
-
-            input_obj = query.with_error_handling do
-              arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
-            end
-            return true, input_obj
+            return true, arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
           else
             flat_value = flatten_ast_value(ast_value)
             return true, arg_type.coerce_input(flat_value, context)

data/lib/graphql/execution/multiplex.rb

@@ -44,9 +44,9 @@ module GraphQL
       end
 
       class << self
-        def run_all(schema, query_options, **kwargs)
-          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
-          run_queries(schema, queries, **kwargs)
+        def run_all(schema, query_options, *args)
+          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, opts) }
+          run_queries(schema, queries, *args)
         end
 
         # @param schema [GraphQL::Schema]

data/lib/graphql/field.rb

@@ -196,6 +196,10 @@ module GraphQL
 
     attr_accessor :ast_node
 
+    # Future-compatible alias
+    # @see {GraphQL::SchemaMember}
+    alias :graphql_definition :itself
+
     # @return [Boolean]
     def connection?
       @connection
@@ -315,6 +319,10 @@ module GraphQL
       }
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
     private
 
     def build_default_resolver

data/lib/graphql/filter.rb

@@ -33,7 +33,7 @@ module GraphQL
       end
 
       def self.build(onlies)
-        case onlies
+        case onlies.size
         when 0
           nil
         when 1

data/lib/graphql/function.rb

@@ -43,7 +43,7 @@ module GraphQL
 
     # @return [Object] This function's resolver
     def call(obj, args, ctx)
-      raise GraphQL::RequiredImplementationMissingError
+      raise NotImplementedError
     end
 
     # @return [String, nil]

data/lib/graphql/input_object_type.rb

@@ -99,8 +99,7 @@ module GraphQL
         end
       end
 
-      result = arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
-      result.prepare
+      arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
     end
 
     # @api private

data/lib/graphql/introspection/entry_points.rb

@@ -15,9 +15,8 @@ module GraphQL
       end
 
       def __type(name:)
-        return unless context.warden.reachable_type?(name)
-
         type = context.warden.get_type(name)
+
         if type && context.interpreter?
           type = type.metadata[:type_class] || raise("Invariant: interpreter requires class-based type for #{name}")
         end

data/lib/graphql/introspection/input_value_type.rb

@@ -18,20 +18,38 @@ module GraphQL
             'null'
           else
             coerced_default_value = @object.type.coerce_result(value, @context)
-            if @object.type.unwrap.is_a?(GraphQL::EnumType)
-              if @object.type.list? 
-                "[#{coerced_default_value.join(", ")}]"
-              else
-                coerced_default_value
-              end
-            else
-              GraphQL::Language.serialize(coerced_default_value)
-            end
+            serialize_default_value(coerced_default_value, @object.type)
           end
         else
           nil
         end
       end
+
+
+      private
+
+      # Recursively serialize, taking care not to add quotes to enum values
+      def serialize_default_value(value, type)
+        if value.nil?
+          'null'
+        elsif type.kind.list?
+          inner_type = type.of_type
+          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+        elsif type.kind.non_null?
+          serialize_default_value(value, type.of_type)
+        elsif type.kind.enum?
+          value
+        elsif type.kind.input_object?
+          "{" +
+            value.map do |k, v|
+              arg_defn = type.arguments[k]
+              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+            end.join(", ") +
+            "}"
+        else
+          GraphQL::Language.serialize(value)
+        end
+      end
     end
   end
 end

data/lib/graphql/introspection/schema_type.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module GraphQL
   module Introspection
     class SchemaType < Introspection::BaseObject
@@ -15,7 +14,7 @@ module GraphQL
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
       def types
-        types = @context.warden.reachable_types.sort_by(&:graphql_name)
+        types = @context.warden.types
         if context.interpreter?
           types.map { |t| t.metadata[:type_class] || raise("Invariant: can't introspect non-class-based type: #{t}") }
         else

data/lib/graphql/language/block_string.rb

@@ -32,10 +32,10 @@ module GraphQL
         end
 
         # Remove leading & trailing blank lines
-        while lines.size > 0 && lines[0].empty?
+        while lines.first.empty?
           lines.shift
         end
-        while lines.size > 0 && lines[-1].empty?
+        while lines.last.empty?
           lines.pop
         end
 

data/lib/graphql/language/document_from_schema_definition.rb

@@ -23,16 +23,10 @@ module GraphQL
         @include_built_in_scalars = include_built_in_scalars
         @include_built_in_directives = include_built_in_directives
 
-        filter = GraphQL::Filter.new(only: only, except: except)
-        if @schema.respond_to?(:visible?)
-          filter = filter.merge(only: @schema.method(:visible?))
-        end
-
-        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
         @warden = GraphQL::Schema::Warden.new(
-          filter,
+          GraphQL::Filter.new(only: only, except: except),
           schema: @schema,
-          context: schema_context,
+          context: context,
         )
       end
 
@@ -156,7 +150,7 @@ module GraphQL
 
       def build_directive_node(directive)
         GraphQL::Language::Nodes::DirectiveDefinition.new(
-          name: directive.name,
+          name: directive.graphql_name,
           arguments: build_argument_nodes(warden.arguments(directive)),
           locations: build_directive_location_nodes(directive.locations),
           description: directive.description,
@@ -213,7 +207,7 @@ module GraphQL
         when ListType
           default_value.to_a.map { |v| build_default_value(v, type.of_type) }
         else
-          raise GraphQL::RequiredImplementationMissingError, "Unexpected default value type #{type.inspect}"
+          raise NotImplementedError, "Unexpected default value type #{type.inspect}"
         end
       end
 
@@ -256,7 +250,7 @@ module GraphQL
         definitions = []
         definitions << build_schema_node if include_schema_node?
         definitions += build_directive_nodes(warden.directives)
-        definitions += build_type_definition_nodes(warden.reachable_types)
+        definitions += build_type_definition_nodes(warden.types)
         definitions
       end
 

data/lib/graphql/language/lexer.rb

@@ -314,7 +314,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:RCURLY, ts, te, meta, "}") 
+											emit(:RCURLY, ts, te, meta) 
 										end
 										
 									end
@@ -328,7 +328,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:LCURLY, ts, te, meta, "{") 
+											emit(:LCURLY, ts, te, meta) 
 										end
 										
 									end
@@ -342,7 +342,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:RPAREN, ts, te, meta, ")") 
+											emit(:RPAREN, ts, te, meta) 
 										end
 										
 									end
@@ -356,7 +356,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:LPAREN, ts, te, meta, "(")
+											emit(:LPAREN, ts, te, meta) 
 										end
 										
 									end
@@ -370,7 +370,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:RBRACKET, ts, te, meta, "]") 
+											emit(:RBRACKET, ts, te, meta) 
 										end
 										
 									end
@@ -384,7 +384,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:LBRACKET, ts, te, meta, "[") 
+											emit(:LBRACKET, ts, te, meta) 
 										end
 										
 									end
@@ -398,7 +398,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:COLON, ts, te, meta, ":") 
+											emit(:COLON, ts, te, meta) 
 										end
 										
 									end
@@ -440,7 +440,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:VAR_SIGN, ts, te, meta, "$") 
+											emit(:VAR_SIGN, ts, te, meta) 
 										end
 										
 									end
@@ -454,7 +454,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:DIR_SIGN, ts, te, meta, "@") 
+											emit(:DIR_SIGN, ts, te, meta) 
 										end
 										
 									end
@@ -468,7 +468,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:ELLIPSIS, ts, te, meta, "...") 
+											emit(:ELLIPSIS, ts, te, meta) 
 										end
 										
 									end
@@ -482,7 +482,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:EQUALS, ts, te, meta, "=") 
+											emit(:EQUALS, ts, te, meta) 
 										end
 										
 									end
@@ -496,7 +496,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:BANG, ts, te, meta, "!") 
+											emit(:BANG, ts, te, meta) 
 										end
 										
 									end
@@ -510,7 +510,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:PIPE, ts, te, meta, "|") 
+											emit(:PIPE, ts, te, meta) 
 										end
 										
 									end
@@ -524,7 +524,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit(:AMP, ts, te, meta, "&") 
+											emit(:AMP, ts, te, meta) 
 										end
 										
 									end
@@ -738,7 +738,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:ON, ts, te, meta, "on") 
+												emit(:ON, ts, te, meta) 
 											end
 											
 										end
@@ -746,7 +746,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:FRAGMENT, ts, te, meta, "fragment") 
+												emit(:FRAGMENT, ts, te, meta) 
 											end
 											
 										end
@@ -754,7 +754,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:TRUE, ts, te, meta, "true") 
+												emit(:TRUE, ts, te, meta) 
 											end
 											
 										end
@@ -762,7 +762,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:FALSE, ts, te, meta, "false") 
+												emit(:FALSE, ts, te, meta) 
 											end
 											
 										end
@@ -770,7 +770,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:NULL, ts, te, meta, "null") 
+												emit(:NULL, ts, te, meta) 
 											end
 											
 										end
@@ -778,7 +778,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:QUERY, ts, te, meta, "query") 
+												emit(:QUERY, ts, te, meta) 
 											end
 											
 										end
@@ -786,7 +786,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:MUTATION, ts, te, meta, "mutation") 
+												emit(:MUTATION, ts, te, meta) 
 											end
 											
 										end
@@ -794,7 +794,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit(:SUBSCRIPTION, ts, te, meta, "subscription") 
+												emit(:SUBSCRIPTION, ts, te, meta) 
 											end
 											
 										end
@@ -1371,11 +1371,11 @@ end
 
 def self.record_comment(ts, te, meta)
 token = GraphQL::Language::Token.new(
-:COMMENT,
-meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
-meta[:line],
-meta[:col],
-meta[:previous_token],
+name: :COMMENT,
+value: meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+line: meta[:line],
+col: meta[:col],
+prev_token: meta[:previous_token],
 )
 
 meta[:previous_token] = token
@@ -1383,14 +1383,13 @@ meta[:previous_token] = token
 meta[:col] += te - ts
 end
 
-def self.emit(token_name, ts, te, meta, token_value = nil)
-token_value ||= meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+def self.emit(token_name, ts, te, meta)
 meta[:tokens] << token = GraphQL::Language::Token.new(
-token_name,
-token_value,
-meta[:line],
-meta[:col],
-meta[:previous_token],
+name: token_name,
+value: meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+line: meta[:line],
+col: meta[:col],
+prev_token: meta[:previous_token],
 )
 meta[:previous_token] = token
 # Bump the column counter for the next token
@@ -1429,30 +1428,30 @@ end
 # (It's faster: https://bugs.ruby-lang.org/issues/8110)
 if !value.valid_encoding? || value !~ VALID_STRING
 meta[:tokens] << token = GraphQL::Language::Token.new(
-:BAD_UNICODE_ESCAPE,
-value,
-meta[:line],
-meta[:col],
-meta[:previous_token],
+name: :BAD_UNICODE_ESCAPE,
+value: value,
+line: meta[:line],
+col: meta[:col],
+prev_token: meta[:previous_token],
 )
 else
 replace_escaped_characters_in_place(value)
 
 if !value.valid_encoding?
 	meta[:tokens] << token = GraphQL::Language::Token.new(
-	:BAD_UNICODE_ESCAPE,
-	value,
-	meta[:line],
-	meta[:col],
-	meta[:previous_token],
+	name: :BAD_UNICODE_ESCAPE,
+	value: value,
+	line: meta[:line],
+	col: meta[:col],
+	prev_token: meta[:previous_token],
 	)
 	else
 	meta[:tokens] << token = GraphQL::Language::Token.new(
-	:STRING,
-	value,
-	meta[:line],
-	meta[:col],
-	meta[:previous_token],
+	name: :STRING,
+	value: value,
+	line: meta[:line],
+	col: meta[:col],
+	prev_token: meta[:previous_token],
 	)
 	end
 end