graphql 1.11.7 → 1.12.0

data/lib/graphql/execution/multiplex.rb

@@ -29,11 +29,13 @@ module GraphQL
 
       include Tracing::Traceable
 
-      attr_reader :context, :queries, :schema, :max_complexity
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader
       def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
+        @queries.each { |q| q.multiplex = self }
         @context = context
+        @context[:dataloader] = @dataloader = @schema.dataloader_class.new(context)
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
@@ -79,20 +81,30 @@ module GraphQL
           multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
           queries = multiplex.queries
           # Do as much eager evaluation of the query as possible
-          results = queries.map do |query|
-            begin_query(query, multiplex)
+          results = []
+          queries.each_with_index do |query, idx|
+            multiplex.dataloader.enqueue {
+              results[idx] = begin_query(query, multiplex)
+            }
           end
 
+          multiplex.dataloader.run
+
           # Then, work through lazy results in a breadth-first way
-          multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          multiplex.dataloader.enqueue {
+            multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          }
+          multiplex.dataloader.run
 
           # Then, find all errors and assign the result to the query object
-          results.each_with_index.map do |data_result, idx|
+          results.each_with_index do |data_result, idx|
             query = queries[idx]
             finish_query(data_result, query, multiplex)
             # Get the Query::Result, not the Hash
-            query.result
+            results[idx] = query.result
           end
+
+          results
         rescue Exception
           # TODO rescue at a higher level so it will catch errors in analysis, too
           # Assign values here so that the query's `@executed` becomes true
@@ -144,6 +156,8 @@ module GraphQL
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
+          warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+
           query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors
             if all_errors.any?

data/lib/graphql/function.rb

@@ -2,6 +2,10 @@
 module GraphQL
   # @api deprecated
   class Function
+    def self.inherited(subclass)
+      warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
+    end
+
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
     def arguments
       self.class.arguments

data/lib/graphql/input_object_type.rb

@@ -2,6 +2,8 @@
 module GraphQL
   # @api deprecated
   class InputObjectType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions(
       :arguments, :mutation,
       input_field: GraphQL::Define::AssignArgument,

data/lib/graphql/interface_type.rb

@@ -2,10 +2,12 @@
 module GraphQL
   # @api deprecated
   class InterfaceType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
 
     attr_accessor :fields, :orphan_types, :resolve_type_proc
-    attr_writer :type_membership_class  
+    attr_writer :type_membership_class
     ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
 
     def initialize

data/lib/graphql/language/document_from_schema_definition.rb

@@ -49,6 +49,8 @@ module GraphQL
           subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
           # This only supports directives from parsing,
           # use a custom printer to add to this list.
+          #
+          # `@schema.directives` is covered by `build_definition_nodes`
           directives: ast_directives(@schema),
         )
       end
@@ -59,7 +61,7 @@ module GraphQL
           interfaces: warden.interfaces(object_type).sort_by(&:graphql_name).map { |iface| build_type_name_node(iface) },
           fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
-          directives: ast_directives(object_type),
+          directives: directives(object_type),
         )
       end
 
@@ -69,7 +71,7 @@ module GraphQL
           arguments: build_argument_nodes(warden.arguments(field)),
           type: build_type_name_node(field.type),
           description: field.description,
-          directives: ast_directives(field),
+          directives: directives(field),
         )
       end
 
@@ -78,7 +80,7 @@ module GraphQL
           name: union_type.graphql_name,
           description: union_type.description,
           types: warden.possible_types(union_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
-          directives: ast_directives(union_type),
+          directives: directives(union_type),
         )
       end
 
@@ -87,7 +89,7 @@ module GraphQL
           name: interface_type.graphql_name,
           description: interface_type.description,
           fields: build_field_nodes(warden.fields(interface_type)),
-          directives: ast_directives(interface_type),
+          directives: directives(interface_type),
         )
       end
 
@@ -98,7 +100,7 @@ module GraphQL
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
-          directives: ast_directives(enum_type),
+          directives: directives(enum_type),
         )
       end
 
@@ -106,7 +108,7 @@ module GraphQL
         GraphQL::Language::Nodes::EnumValueDefinition.new(
           name: enum_value.graphql_name,
           description: enum_value.description,
-          directives: ast_directives(enum_value),
+          directives: directives(enum_value),
         )
       end
 
@@ -114,7 +116,7 @@ module GraphQL
         GraphQL::Language::Nodes::ScalarTypeDefinition.new(
           name: scalar_type.graphql_name,
           description: scalar_type.description,
-          directives: ast_directives(scalar_type),
+          directives: directives(scalar_type),
         )
       end
 
@@ -130,7 +132,7 @@ module GraphQL
           description: argument.description,
           type: build_type_name_node(argument.type),
           default_value: default_value,
-          directives: ast_directives(argument),
+          directives: directives(argument),
         )
 
         argument_node
@@ -141,7 +143,7 @@ module GraphQL
           name: input_object.graphql_name,
           fields: build_argument_nodes(warden.arguments(input_object)),
           description: input_object.description,
-          directives: ast_directives(input_object),
+          directives: directives(input_object),
         )
       end
 
@@ -155,7 +157,7 @@ module GraphQL
       end
 
       def build_directive_location_nodes(locations)
-        locations.map { |location| build_directive_location_node(location) }
+        locations.sort.map { |location| build_directive_location_node(location) }
       end
 
       def build_directive_location_node(location)
@@ -283,14 +285,37 @@ module GraphQL
         (schema.subscription.nil? || schema.subscription.graphql_name == 'Subscription')
       end
 
-      def ast_directives(member)
-        ast_directives = member.ast_node ? member.ast_node.directives : []
+      def directives(member)
+        definition_directives(member)
+      end
 
-        # If this schema was built from IDL, it will already have `@deprecated` in `ast_node.directives`
-        if member.respond_to?(:deprecation_reason) &&
-            (reason = member.deprecation_reason) &&
-            ast_directives.none? { |d| d.name == "deprecated" }
+      def definition_directives(member)
+        dirs = if !member.respond_to?(:directives) || member.directives.empty?
+          []
+        else
+          member.directives.map do |dir|
+            args = []
+            dir.arguments.argument_values.each_value do |arg_value|
+              arg_defn = arg_value.definition
+              if arg_defn.default_value? && arg_value.value == arg_defn.default_value
+                next
+              else
+                value_node = build_default_value(arg_value.value, arg_value.definition.type)
+                args << GraphQL::Language::Nodes::Argument.new(
+                  name: arg_value.definition.name,
+                  value: value_node,
+                )
+              end
+            end
+            GraphQL::Language::Nodes::Directive.new(
+              name: dir.class.graphql_name,
+              arguments: args
+            )
+          end
+        end
 
+        # This is just for printing legacy `.define { ... }` schemas, where `deprecation_reason` isn't added to `.directives`.
+        if !member.respond_to?(:directives) && member.respond_to?(:deprecation_reason) && (reason = member.deprecation_reason)
           arguments = []
 
           if reason != GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
@@ -300,15 +325,17 @@ module GraphQL
             )
           end
 
-          ast_directives += [
-            GraphQL::Language::Nodes::Directive.new(
-              name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-              arguments: arguments
-            )
-          ]
+          dirs << GraphQL::Language::Nodes::Directive.new(
+            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
+            arguments: arguments
+          )
         end
 
-        ast_directives
+        dirs
+      end
+
+      def ast_directives(member)
+        member.ast_node ? member.ast_node.directives : []
       end
 
       attr_reader :schema, :warden, :always_include_schema,

data/lib/graphql/object_type.rb

@@ -2,6 +2,8 @@
 module GraphQL
   # @api deprecated
   class ObjectType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
     accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
 

data/lib/graphql/pagination/connection.rb

@@ -53,10 +53,11 @@ module GraphQL
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, parent: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil)
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil)
         @items = items
         @parent = parent
         @context = context
+        @field = field
         @first_value = first
         @after_value = after
         @last_value = last
@@ -118,6 +119,9 @@ module GraphQL
       # @return [Class] A wrapper class for edges of this connection
       attr_accessor :edge_class
 
+      # @return [GraphQL::Schema::Field] The field this connection was returned by
+      attr_accessor :field
+
       # @return [Array<Object>] A slice of {items}, constrained by {@first_value}/{@after_value}/{@last_value}/{@before_value}
       def nodes
         raise PaginationImplementationMissingError, "Implement #{self.class}#nodes to paginate `@items`"

data/lib/graphql/pagination/connections.rb

@@ -6,20 +6,13 @@ module GraphQL
     #
     # Attach as a plugin.
     #
-    # @example Using new default connections
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
-    #   end
-    #
     # @example Adding a custom wrapper
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
     #     connections.add(MyApp::SearchResults, MyApp::SearchResultsConnection)
     #   end
     #
     # @example Removing default connection support for arrays (they can still be manually wrapped)
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
     #     connections.delete(Array)
     #   end
     #
@@ -29,14 +22,10 @@ module GraphQL
       end
 
       def self.use(schema_defn)
-        if schema_defn.is_a?(Class)
-          schema_defn.connections = self.new(schema: schema_defn)
-        else
-          # Unwrap a `.define` object
-          schema_defn = schema_defn.target
-          schema_defn.connections = self.new(schema: schema_defn)
-          schema_defn.class.connections = schema_defn.connections
+        if schema_defn.plugins.any? { |(plugin, args)| plugin == self }
+          warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
         end
+        schema_defn.connections = self.new(schema: schema_defn)
       end
 
       def initialize(schema:)
@@ -76,9 +65,9 @@ module GraphQL
 
       # Used by the runtime to wrap values in connection wrappers.
       # @api Private
-      def wrap(field, parent, items, arguments, context, wrappers: all_wrappers)
+      def wrap(field, parent, items, arguments, context)
         return items if GraphQL::Execution::Interpreter::RawValue === items
-
+        wrappers = context ? context.namespace(:connections)[:all_wrappers] : all_wrappers
         impl = wrapper_for(items, wrappers: wrappers)
 
         if impl.nil?
@@ -89,6 +78,7 @@ module GraphQL
           items,
           context: context,
           parent: parent,
+          field: field,
           max_page_size: field.max_page_size || context.schema.default_max_page_size,
           first: arguments[:first],
           after: arguments[:after],

data/lib/graphql/query.rb

@@ -153,6 +153,8 @@ module GraphQL
       @interpreter
     end
 
+    attr_accessor :multiplex
+
     def subscription_update?
       @subscription_topic && subscription?
     end

data/lib/graphql/query/context.rb

@@ -158,6 +158,10 @@ module GraphQL
         @scoped_context = {}
       end
 
+      def dataloader
+        @dataloader ||= query.multiplex.dataloader
+      end
+
       # @api private
       attr_writer :interpreter
 

data/lib/graphql/query/serial_execution.rb

@@ -16,6 +16,7 @@ module GraphQL
       # @param query_object [GraphQL::Query] the query object for this execution
       # @return [Hash] a spec-compliant GraphQL result, as a hash
       def execute(ast_operation, root_type, query_object)
+        warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         operation_resolution.resolve(
           query_object.irep_selection,
           root_type,

data/lib/graphql/relay/base_connection.rb

@@ -59,6 +59,13 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+
+        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
+        if deprecated_caller
+          warn "  -> called from #{deprecated_caller}"
+        end
+
         @context = context
         @nodes = nodes
         @arguments = arguments

data/lib/graphql/relay/connection_instrumentation.rb

@@ -10,10 +10,10 @@ module GraphQL
       def self.default_arguments
         @default_arguments ||= begin
           argument_definitions = [
-              ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
-              ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
-              ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
-              ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+              ["first", GraphQL::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
             ]
 
           argument_definitions.reduce({}) do |memo, arg_defn|

data/lib/graphql/relay/connection_type.rb

@@ -20,7 +20,7 @@ module GraphQL
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
-        ObjectType.define do
+        ObjectType.deprecated_define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
           edge_type ||= wrapped_type.edge_type
           name("#{type_name}Connection")

data/lib/graphql/relay/mutation.rb

@@ -30,6 +30,7 @@ module GraphQL
       alias :input_fields :arguments
 
       def initialize
+        warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
         @fields = {}
         @arguments = {}
         @has_generated_return_type = false

data/lib/graphql/relay/node.rb

@@ -5,6 +5,7 @@ module GraphQL
     module Node
       # @return [GraphQL::Field] a field for finding objects by their global ID.
       def self.field(**kwargs, &block)
+        warn "GraphQL::Relay::Node.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodeField instead"
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
@@ -18,6 +19,7 @@ module GraphQL
       end
 
       def self.plural_field(**kwargs, &block)
+        warn "GraphQL::Relay::Nodes.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodesField instead"
         field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
@@ -29,6 +31,7 @@ module GraphQL
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
       def self.interface
+        warn "GraphQL::Relay::Node.interface will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::Node instead"
         @interface ||= GraphQL::Types::Relay::Node.graphql_definition
       end
     end