graphql 1.10.14 → 1.11.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1d76918804bdeeba0c80bbcfcdde70d04132110aee8e4520dcba8480da390fc
-  data.tar.gz: c0e1954ae3f6d18bf03fc33807b94d482b83b4e4a6f8a392452e2f6e8297f241
+  metadata.gz: c5bf42de25927dab863bd600879d33d204c54bdf124b2b4cc5b27c4c16d4f28b
+  data.tar.gz: 58b21a4dd5ba80ec0f6c3362013a6adb07c2f1af243e5a851d4c3f08554fe09d
 SHA512:
-  metadata.gz: 3e945033f8657c252fcd99a18d4be5c9d267535753e88a94f3b589c968ca186e90f3368768ff2f3f7c7e1eff7a210bf57694bde763255ee0a91f1e46534b0b4d
-  data.tar.gz: de56338439eeb22b8484033c5acfb4ac027edee60ac30218c8a7516c5bc6d4bfa07b8be54ebd42a63fca5decdfbbcf85e4b96832bb8d7fcd304dc2fb98bc7625
+  metadata.gz: f199d24a190910e44b189340b6a3d2a3c121ab56ba10ec6cf44d8801107db8d73541f24788b00b13ee7dd357f7bfe6ecff7001f053fe417c777bca59db5851db
+  data.tar.gz: fd0955c7f67b20370ea376d6a286fdf0ac7272ac5b243d6c309d2159a780cd0b8f92fd0e06ca312a69a16b7c8ad0ebd7bb4587feac9dc77b27da507c9a44cd8f

data/lib/generators/graphql/core.rb

@@ -41,6 +41,14 @@ module Graphql
         end
       end
 
+      def module_namespacing_when_supported
+        if defined?(module_namespacing)
+          module_namespacing { yield }
+        else
+          yield
+        end
+      end
+
       private
 
       def schema_name

data/lib/generators/graphql/templates/base_argument.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseArgument < GraphQL::Schema::Argument
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_enum.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseEnum < GraphQL::Schema::Enum
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_field.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseField < GraphQL::Schema::Field
     argument_class Types::BaseArgument
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_input_object.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject
     argument_class Types::BaseArgument
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_interface.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   module BaseInterface
     include GraphQL::Schema::Interface
@@ -5,3 +6,4 @@ module Types
     field_class Types::BaseField
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_mutation.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Mutations
   class BaseMutation < GraphQL::Schema::RelayClassicMutation
     argument_class Types::BaseArgument
@@ -6,3 +7,4 @@ module Mutations
     object_class Types::BaseObject
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_object.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseObject < GraphQL::Schema::Object
     field_class Types::BaseField
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_scalar.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseScalar < GraphQL::Schema::Scalar
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/base_union.erb

@@ -1,4 +1,6 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseUnion < GraphQL::Schema::Union
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/enum.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseEnum
 <% prepared_values.each do |v| %>    value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
   # If accessing from outside this domain, nullify the session
   # This allows for outside API access while preventing CSRF attacks,
@@ -5,7 +6,7 @@ class GraphqlController < ApplicationController
   # protect_from_forgery with: :null_session
 
   def execute
-    variables = ensure_hash(params[:variables])
+    variables = prepare_variables(params[:variables])
     query = params[:query]
     operation_name = params[:operationName]
     context = {
@@ -21,21 +22,23 @@ class GraphqlController < ApplicationController
 
   private
 
-  # Handle form data, JSON body, or a blank value
-  def ensure_hash(ambiguous_param)
-    case ambiguous_param
+  # Handle variables in form data, JSON body, or a blank value
+  def prepare_variables(variables_param)
+    case variables_param
     when String
-      if ambiguous_param.present?
-        ensure_hash(JSON.parse(ambiguous_param))
+      if variables_param.present?
+        JSON.parse(variables_param) || {}
       else
         {}
       end
-    when Hash, ActionController::Parameters
-      ambiguous_param
+    when Hash
+      variables_param
+    when ActionController::Parameters
+      variables_param.to_unsafe_hash # GraphQL-Ruby will validate name and type of incoming variables.
     when nil
       {}
     else
-      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+      raise ArgumentError, "Unexpected parameter: #{variables_param}"
     end
   end
 
@@ -46,3 +49,4 @@ class GraphqlController < ApplicationController
     render json: { errors: [{ message: e.message, backtrace: e.backtrace }], data: {} }, status: 500
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/interface.erb

@@ -1,6 +1,8 @@
+<% module_namespacing_when_supported do -%>
 module Types
   module <%= type_ruby_name.split('::')[-1] %>
     include Types::BaseInterface
 <% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/loader.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader
     # Define `initialize` to store grouping arguments, eg
@@ -15,3 +16,4 @@ module Loaders
     end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/mutation.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Mutations
   class <%= mutation_name %> < BaseMutation
     # TODO: define return fields
@@ -12,3 +13,4 @@ module Mutations
     # end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/mutation_type.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class MutationType < Types::BaseObject
     # TODO: remove me
@@ -8,3 +9,4 @@ module Types
     end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/object.erb

@@ -1,6 +1,8 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
 <% if options.node %>    implements GraphQL::Relay::Node.interface
 <% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/query_type.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject
     # Add root-level fields here.
@@ -13,3 +14,4 @@ module Types
     field :node, field: GraphQL::Relay::Node.field
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/templates/scalar.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
     def self.coerce_input(input_value, context)
@@ -11,3 +12,4 @@ module Types
     end
   end
 end
+<% end -%>

data/lib/generators/graphql/templates/schema.erb

@@ -1,3 +1,4 @@
+<% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
 
@@ -38,3 +39,4 @@ class <%= schema_name %> < GraphQL::Schema
   # GraphQL::Batch setup:
   use GraphQL::Batch
 <% end %>end
+<% end -%>

data/lib/generators/graphql/templates/union.erb

@@ -1,5 +1,7 @@
+<% module_namespacing_when_supported do -%>
 module Types
   class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
 <% if possible_types.any? %>    possible_types [<%= normalized_possible_types.join(", ") %>]
 <% end %>  end
 end
+<% end -%>

data/lib/graphql.rb

@@ -91,13 +91,13 @@ require "graphql/analysis"
 require "graphql/tracing"
 require "graphql/dig"
 require "graphql/execution"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
 require "graphql/schema"
 require "graphql/query"
 require "graphql/directive"
 require "graphql/execution"
-require "graphql/runtime_type_error"
-require "graphql/unresolved_type_error"
-require "graphql/invalid_null_error"
 require "graphql/types"
 require "graphql/relay"
 require "graphql/boolean_type"

data/lib/graphql/execution/interpreter.rb

@@ -26,7 +26,7 @@ module GraphQL
         schema_class.query_execution_strategy(GraphQL::Execution::Interpreter)
         schema_class.mutation_execution_strategy(GraphQL::Execution::Interpreter)
         schema_class.subscription_execution_strategy(GraphQL::Execution::Interpreter)
-
+        schema_class.add_subscription_extension_if_necessary
         GraphQL::Schema::Object.include(HandlesRawValue)
       end
 

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

@@ -170,13 +170,13 @@ module GraphQL
             begin
               kwarg_arguments = arguments(object, field_defn, ast_node)
             rescue GraphQL::ExecutionError => e
-              continue_value(next_path, e, field_defn, return_type.non_null?, ast_node)
+              continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
               next
             end
 
             after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
               if resolved_arguments.is_a? GraphQL::ExecutionError
-                continue_value(next_path, resolved_arguments, field_defn, return_type.non_null?, ast_node)
+                continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
                 next
               end
 
@@ -228,12 +228,12 @@ module GraphQL
                   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|
-                  continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
+                  continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node)
                   if RawValue === continue_value
                     # Write raw value directly to the response without resolving nested objects
                     write_in_response(next_path, continue_value.resolve)
                   elsif HALT != continue_value
-                    continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
+                    continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
                   end
                 end
               end
@@ -251,10 +251,10 @@ module GraphQL
         end
 
         HALT = Object.new
-        def continue_value(path, value, field, is_non_null, ast_node)
+        def continue_value(path, value, parent_type, field, is_non_null, ast_node)
           if value.nil?
             if is_non_null
-              err = field.owner::InvalidNullError.new(field.owner, field, value)
+              err = parent_type::InvalidNullError.new(parent_type, field, value)
               write_invalid_null_in_response(path, err)
             else
               write_in_response(path, nil)
@@ -281,7 +281,7 @@ module GraphQL
               err
             end
 
-            continue_value(path, next_value, field, is_non_null, ast_node)
+            continue_value(path, next_value, parent_type, field, is_non_null, ast_node)
           elsif GraphQL::Execution::Execute::SKIP == value
             HALT
           else
@@ -297,49 +297,49 @@ 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(path, value, field, type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
-          case type.kind.name
+        def continue_field(path, value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments) # rubocop:disable Metrics/ParameterLists
+          case current_type.kind.name
           when "SCALAR", "ENUM"
-            r = type.coerce_result(value, context)
+            r = current_type.coerce_result(value, context)
             write_in_response(path, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy, resolved_value = resolve_type(type, value, path)
+            resolved_type_or_lazy, resolved_value = resolve_type(current_type, value, path)
             resolved_value ||= value
 
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
-              possible_types = query.possible_types(type)
+            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
+              possible_types = query.possible_types(current_type)
 
               if !possible_types.include?(resolved_type)
-                parent_type = field.owner
-                err_class = type::UnresolvedTypeError
+                parent_type = field.owner_type
+                err_class = current_type::UnresolvedTypeError
                 type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 write_in_response(path, nil)
                 nil
               else
-                continue_field(path, resolved_value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
+                continue_field(path, resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
           when "OBJECT"
             object_proxy = begin
-              authorized_new(type, value, context, path)
+              authorized_new(current_type, value, context, path)
             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, trace: false) do |inner_object|
-              continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
+            after_lazy(object_proxy, owner: current_type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
+              continue_value = continue_value(path, inner_object, owner_type, 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, context.scoped_context, continue_value, current_type, next_selections)
                 response_hash
               end
             end
           when "LIST"
             response_list = []
             write_in_response(path, response_list)
-            inner_type = type.of_type
+            inner_type = current_type.of_type
             idx = 0
             scoped_context = context.scoped_context
             begin
@@ -351,9 +351,9 @@ module GraphQL
                 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|
-                  continue_value = continue_value(next_path, inner_inner_value, field, inner_type.non_null?, ast_node)
+                  continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node)
                   if HALT != continue_value
-                    continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
+                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
                   end
                 end
               end
@@ -370,12 +370,12 @@ module GraphQL
 
             response_list
           when "NON_NULL"
-            inner_type = type.of_type
+            inner_type = current_type.of_type
             # Don't `set_type_at_path` because we want the static type,
             # we're going to use that to determine whether a `nil` should be propagated or not.
-            continue_field(path, value, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
+            continue_field(path, value, owner_type, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
           else
-            raise "Invariant: Unhandled type kind #{type.kind} (#{type})"
+            raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
         end
 

data/lib/graphql/execution/multiplex.rb

@@ -34,8 +34,7 @@ module GraphQL
         @schema = schema
         @queries = queries
         @context = context
-        # TODO remove support for global tracers
-        @tracers = schema.tracers + GraphQL::Tracing.tracers + (context[:tracers] || [])
+        @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
           @tracers << GraphQL::Backtrace::Tracer

data/lib/graphql/introspection/schema_type.rb

@@ -9,9 +9,9 @@ module GraphQL
                   "query, mutation, and subscription operations."
 
       field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
-      field :queryType, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
-      field :mutationType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
-      field :subscriptionType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
+      field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
+      field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
+      field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
       def types