graphql 1.9.0.pre1 → 1.9.0.pre2

data/lib/graphql/language/printer.rb

@@ -254,7 +254,7 @@ module GraphQL
         return ''.dup unless node.description
 
         description = indent != '' && !first_in_block ? "\n".dup : "".dup
-        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
+        description << GraphQL::Language::BlockString.print(node.description, indent: indent)
       end
 
       def print_field_definitions(fields)

data/lib/graphql/language/visitor.rb

@@ -85,18 +85,21 @@ module GraphQL
         if node == DELETE_NODE
           # This might be passed to `super(DELETE_NODE, ...)`
           # by a user hook, don't want to keep visiting in that case.
-          return node, parent
+          [node, parent]
         else
           # Run hooks if there are any
           begin_hooks_ok = @visitors.none? || begin_visit(node, parent)
           if begin_hooks_ok
             node.children.each do |child_node|
+              new_child_and_node = on_node_with_modifications(child_node, node)
               # Reassign `node` in case the child hook makes a modification
-              _new_child_node, node = on_node_with_modifications(child_node, node)
+              if new_child_and_node.is_a?(Array)
+                node = new_child_and_node[1]
+              end
             end
           end
           @visitors.any? && end_visit(node, parent)
-          return node, parent
+          [node, parent]
         end
       end
 
@@ -155,20 +158,26 @@ module GraphQL
       # copy `parent` so that it contains the copy of that node as a child,
       # then return the copies
       def on_node_with_modifications(node, parent)
-        new_node, new_parent = visit_node(node, parent)
-        if new_node.is_a?(Nodes::AbstractNode) && !node.equal?(new_node)
-          # The user-provided hook returned a new node.
-          new_parent = new_parent && new_parent.replace_child(node, new_node)
-          return new_node, new_parent
-        elsif new_node == DELETE_NODE
-          # The user-provided hook requested to remove this node
-          new_parent = new_parent && new_parent.delete_child(node)
-          return nil, new_parent
+        new_node_and_new_parent = visit_node(node, parent)
+        if new_node_and_new_parent.is_a?(Array)
+          new_node = new_node_and_new_parent[0]
+          new_parent = new_node_and_new_parent[1]
+          if new_node.is_a?(Nodes::AbstractNode) && !node.equal?(new_node)
+            # The user-provided hook returned a new node.
+            new_parent = new_parent && new_parent.replace_child(node, new_node)
+            return new_node, new_parent
+          elsif new_node == DELETE_NODE
+            # The user-provided hook requested to remove this node
+            new_parent = new_parent && new_parent.delete_child(node)
+            return nil, new_parent
+          else
+            new_node_and_new_parent
+          end
         else
           # The user-provided hook didn't make any modifications.
           # In fact, the hook might have returned who-knows-what, so
           # ignore the return value and use the original values.
-          return node, parent
+          [node, parent]
         end
       end
 

data/lib/graphql/literal_validation_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module GraphQL
+  class LiteralValidationError < GraphQL::Error
+    attr_accessor :ast_value
+  end
+end

data/lib/graphql/query.rb

@@ -135,10 +135,23 @@ module GraphQL
       end
     end
 
+    def_delegators :@schema, :interpreter?
+
     def subscription_update?
       @subscription_topic && subscription?
     end
 
+    # A lookahead for the root selections of this query
+    # @return [GraphQL::Execution::Lookahead]
+    def lookahead
+      @lookahead ||= begin
+        ast_node = selected_operation
+        root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
+        root_type = root_type.metadata[:type_class] || raise("Invariant: `lookahead` only works with class-based types")
+        GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+      end
+    end
+
     # @api private
     def result_values=(result_hash)
       if @executed

data/lib/graphql/query/arguments.rb

@@ -6,6 +6,7 @@ module GraphQL
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
       extend Forwardable
+      include GraphQL::Dig
 
       def self.construct_arguments_class(argument_owner)
         argument_definitions = argument_owner.arguments
@@ -40,7 +41,7 @@ module GraphQL
       def initialize(values, context:, defaults_used:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
           arg_name = inner_key.to_s
-          arg_defn = self.class.argument_definitions[arg_name]
+          arg_defn = self.class.argument_definitions[arg_name] || raise("Not found #{arg_name} among #{self.class.argument_definitions.keys}")
           arg_default_used = defaults_used.include?(arg_name)
           arg_value = wrap_value(inner_value, arg_defn.type, context)
           string_key = arg_defn.expose_as

data/lib/graphql/query/context.rb

@@ -7,7 +7,7 @@ module GraphQL
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
       module SharedMethods
-        # @return [Object] The target for field resultion
+        # @return [Object] The target for field resolution
         attr_accessor :object
 
         # @return [Hash, Array, String, Integer, Float, Boolean, nil] The resolved value for this field
@@ -155,13 +155,6 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods
-        # The interpreter will set this
-        @interpreter = nil
-      end
-
-      # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
-      def interpreter?
-        @interpreter
       end
 
       # @api private
@@ -170,8 +163,8 @@ module GraphQL
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :key?, :fetch, :dig
-      def_delegators :@query, :trace
+      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
+      def_delegators :@query, :trace, :interpreter?
 
       # @!method [](key)
       #   Lookup `key` from the hash passed to {Schema#execute} as `context:`

data/lib/graphql/query/executor.rb

@@ -12,7 +12,7 @@ module GraphQL
         @query = query
       end
 
-      # Evalute {operation_name} on {query}.
+      # Evaluate {operation_name} on {query}.
       # Handle {GraphQL::ExecutionError}s by putting them in the "errors" key.
       # @return [Hash] A GraphQL response, with either a "data" key or an "errors" key
       def result

data/lib/graphql/query/validation_pipeline.rb

@@ -36,7 +36,7 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::StaticValidation::Message>] Static validation errors for the query string
+      # @return [Array<GraphQL::StaticValidation::Error >] Static validation errors for the query string
       def validation_errors
         ensure_has_validated
         @validation_errors

data/lib/graphql/relay/connection_resolve.rb

@@ -9,7 +9,7 @@ module GraphQL
       end
 
       def call(obj, args, ctx)
-        # in a lazy ressolve hook, obj is the promise,
+        # in a lazy resolve hook, obj is the promise,
         # get the object that the promise was
         # originally derived from
         parent = ctx.object

data/lib/graphql/relay/relation_connection.rb

@@ -124,7 +124,7 @@ module GraphQL
       # If a relation contains a `.group` clause, a `.count` will return a Hash.
       def relation_count(relation)
         count_or_hash = if(defined?(ActiveRecord::Relation) && relation.is_a?(ActiveRecord::Relation))
-          relation.count(:all)
+          relation.respond_to?(:unscope)? relation.unscope(:order).count(:all) : relation.count(:all)
         else # eg, Sequel::Dataset, don't mess up others
           relation.count
         end

data/lib/graphql/schema.rb

@@ -33,6 +33,11 @@ require "graphql/schema/interface"
 require "graphql/schema/scalar"
 require "graphql/schema/object"
 require "graphql/schema/union"
+require "graphql/schema/directive"
+require "graphql/schema/directive/include"
+require "graphql/schema/directive/skip"
+require "graphql/schema/directive/feature"
+require "graphql/schema/directive/transform"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
@@ -79,11 +84,13 @@ module GraphQL
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
+      :error_bubbling,
       :raise_definition_error,
       :object_from_id, :id_from_object,
       :default_mask,
       :cursor_encoder,
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m } },
+      directive: ->(schema, directive) { schema.directives[directive.graphql_name] = directive },
       instrument: ->(schema, type, instrumenter, after_built_ins: false) {
         if type == :field && after_built_ins
           type = :field_after_built_ins
@@ -114,6 +121,9 @@ module GraphQL
       :introspection_namespace,
       :analysis_engine
 
+    # [Boolean] True if this object bubbles validation errors up from a field into its parent InputObject, if there is one.
+    attr_accessor :error_bubbling
+
     # Single, long-lived instance of the provided subscriptions class, if there is one.
     # @return [GraphQL::Subscriptions]
     attr_accessor :subscriptions
@@ -141,7 +151,6 @@ module GraphQL
     # @see {Query#tracers} for query-specific tracers
     attr_reader :tracers
 
-    DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
     attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
@@ -150,7 +159,7 @@ module GraphQL
       @tracers = []
       @definition_error = nil
       @orphan_types = []
-      @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
+      @directives = self.class.default_directives
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
       @middleware = MiddlewareChain.new(final_step: GraphQL::Execution::Execute::FieldResolveStep)
       @query_analyzers = []
@@ -174,8 +183,18 @@ module GraphQL
       @context_class = GraphQL::Query::Context
       @introspection_namespace = nil
       @introspection_system = nil
+      @interpeter = false
+      @error_bubbling = true
+    end
+
+    # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
+    def interpreter?
+      @interpreter
     end
 
+    # @api private
+    attr_writer :interpreter
+
     def inspect
       "#<#{self.class.name} ...>"
     end
@@ -225,7 +244,7 @@ module GraphQL
 
     # Validate a query string according to this schema.
     # @param string_or_document [String, GraphQL::Language::Nodes::Document]
-    # @return [Array<GraphQL::StaticValidation::Message>]
+    # @return [Array<GraphQL::StaticValidation::Error >]
     def validate(string_or_document, rules: nil)
       doc = if string_or_document.is_a?(String)
         GraphQL.parse(string_or_document)
@@ -556,7 +575,8 @@ module GraphQL
 
     # Can't delegate to `class`
     alias :_schema_class :class
-    def_delegators :_schema_class, :visible?, :accessible?, :authorized?, :unauthorized_object, :inaccessible_fields
+    def_delegators :_schema_class, :visible?, :accessible?, :authorized?, :unauthorized_object, :unauthorized_field, :inaccessible_fields
+    def_delegators :_schema_class, :directive
 
     # A function to call when {#execute} receives an invalid query string
     #
@@ -673,8 +693,9 @@ module GraphQL
         :execution_strategy_for_operation,
         :validate, :multiplex_analyzers, :lazy?, :lazy_method_name, :after_lazy, :sync_lazy,
         # Configuration
-        :analysis_engine, :analysis_engine=, :using_ast_analysis?,
+        :analysis_engine, :analysis_engine=, :using_ast_analysis?, :interpreter?,
         :max_complexity=, :max_depth=,
+        :error_bubbling=,
         :metadata,
         :default_mask,
         :default_filter, :redefine,
@@ -708,10 +729,14 @@ module GraphQL
         schema_defn.mutation = mutation
         schema_defn.subscription = subscription
         schema_defn.max_complexity = max_complexity
+        schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
-        schema_defn.directives = directives
+
+        prepped_dirs = {}
+        directives.each { |k, v| prepped_dirs[k] = v.graphql_definition}
+        schema_defn.directives = prepped_dirs
         schema_defn.introspection_namespace = introspection
         schema_defn.resolve_type = method(:resolve_type)
         schema_defn.object_from_id = method(:object_from_id)
@@ -842,6 +867,14 @@ module GraphQL
         end
       end
 
+      def error_bubbling(new_error_bubbling = nil)
+        if !new_error_bubbling.nil?
+          @error_bubbling = new_error_bubbling
+        else
+          @error_bubbling
+        end
+      end
+
       def max_depth(new_max_depth = nil)
         if new_max_depth
           @max_depth = new_max_depth
@@ -874,9 +907,11 @@ module GraphQL
         end
       end
 
-      def rescue_from(err_class, &handler_block)
+      def rescue_from(*err_classes, &handler_block)
         @rescues ||= {}
-        @rescues[err_class] = handler_block
+        err_classes.each do |err_class|
+          @rescues[err_class] = handler_block
+        end
       end
 
       def resolve_type(type, obj, ctx)
@@ -918,7 +953,7 @@ module GraphQL
       # By default, this hook just replaces the unauthorized object with `nil`.
       #
       # Whatever value is returned from this method will be used instead of the
-      # unauthorized object (accessible ass `unauthorized_error.object`). If an
+      # unauthorized object (accessible as `unauthorized_error.object`). If an
       # error is raised, then `nil` will be used.
       #
       # If you want to add an error to the `"errors"` key, raise a {GraphQL::ExecutionError}
@@ -930,6 +965,22 @@ module GraphQL
         nil
       end
 
+      # This hook is called when a field fails an `authorized?` check.
+      #
+      # By default, this hook implements the same behavior as unauthorized_object.
+      #
+      # Whatever value is returned from this method will be used instead of the
+      # unauthorized field . If an error is raised, then `nil` will be used.
+      #
+      # If you want to add an error to the `"errors"` key, raise a {GraphQL::ExecutionError}
+      # in this hook.
+      #
+      # @param unauthorized_error [GraphQL::UnauthorizedFieldError]
+      # @return [Field] The returned field will be put in the GraphQL response
+      def unauthorized_field(unauthorized_error)
+        unauthorized_object(unauthorized_error)
+      end
+
       def type_error(type_err, ctx)
         DefaultTypeError.call(type_err, ctx)
       end
@@ -952,7 +1003,19 @@ module GraphQL
           @directives = new_directives.reduce({}) { |m, d| m[d.name] = d; m }
         end
 
-        @directives ||= directives(DIRECTIVES)
+        @directives ||= default_directives
+      end
+
+      def directive(new_directive)
+        directives[new_directive.graphql_name] = new_directive
+      end
+
+      def default_directives
+        {
+          "include" => GraphQL::Directive::IncludeDirective,
+          "skip" => GraphQL::Directive::SkipDirective,
+          "deprecated" => GraphQL::Directive::DeprecatedDirective,
+        }
       end
 
       def tracer(new_tracer)
@@ -1067,7 +1130,14 @@ module GraphQL
     # @param ctx [GraphQL::Query::Context] the context for this query
     # @return [Object] A GraphQL-ready (non-lazy) object
     def self.sync_lazy(value)
-      yield(value)
+      if block_given?
+        # This was already hit by the instance, just give it back
+        yield(value)
+      else
+        # This was called directly on the class, hit the instance
+        # which has the lazy method map
+        self.graphql_definition.sync_lazy(value)
+      end
     end
 
     # @see Schema.sync_lazy for a hook to override

data/lib/graphql/schema/argument.rb

@@ -28,7 +28,7 @@ module GraphQL
       # @param description [String]
       # @param default_value [Object]
       # @param as [Symbol] Override the keyword name when passed to a method
-      # @param prepare [Symbol] A method to call to tranform this argument's valuebefore sending it to field resolution
+      # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
         arg_name ||= name

data/lib/graphql/schema/build_from_definition.rb

@@ -64,9 +64,7 @@ module GraphQL
             end
           end
 
-          GraphQL::Schema::DIRECTIVES.each do |built_in_directive|
-            directives[built_in_directive.name] = built_in_directive unless directives[built_in_directive.name]
-          end
+          directives = GraphQL::Schema.default_directives.merge(directives)
 
           if schema_definition
             if schema_definition.query
@@ -113,7 +111,7 @@ module GraphQL
         end
 
         NullResolveType = ->(type, obj, ctx) {
-          raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution.")
+          raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
         NullScalarCoerce = ->(val, _ctx) { val }

data/lib/graphql/schema/directive.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Subclasses of this can influence how {GraphQL::Execution::Interpreter} runs queries.
+    #
+    # - {.include?}: if it returns `false`, the field or fragment will be skipped altogether, as if it were absent
+    # - {.resolve}: Wraps field resolution (so it should call `yield` to continue)
+    class Directive < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::HasArguments
+      class << self
+        def default_graphql_name
+          super.downcase
+        end
+
+        def locations(*new_locations)
+          if new_locations.any?
+            @locations = new_locations
+          else
+            @locations ||= (superclass.respond_to?(:locations) ? superclass.locations : [])
+          end
+        end
+
+        def default_directive(new_default_directive = nil)
+          if new_default_directive != nil
+            @default_directive = new_default_directive
+          elsif @default_directive.nil?
+            @default_directive = (superclass.respond_to?(:default_directive) ? superclass.default_directive : false)
+          else
+            @default_directive
+          end
+        end
+
+        def to_graphql
+          defn = GraphQL::Directive.new
+          defn.name = self.graphql_name
+          defn.description = self.description
+          defn.locations = self.locations
+          defn.default_directive = self.default_directive
+          defn.metadata[:type_class] = self
+          arguments.each do |name, arg_defn|
+            arg_graphql = arg_defn.to_graphql
+            defn.arguments[arg_graphql.name] = arg_graphql
+          end
+          defn
+        end
+
+        # If false, this part of the query won't be evaluated
+        def include?(_object, _arguments, _context)
+          true
+        end
+
+        # Continuing is passed as a block; `yield` to continue
+        def resolve(object, arguments, context)
+          yield
+        end
+      end
+
+      LOCATIONS = [
+        QUERY =                  :QUERY,
+        MUTATION =               :MUTATION,
+        SUBSCRIPTION =           :SUBSCRIPTION,
+        FIELD =                  :FIELD,
+        FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
+        FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
+        INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+        SCHEMA =                 :SCHEMA,
+        SCALAR =                 :SCALAR,
+        OBJECT =                 :OBJECT,
+        FIELD_DEFINITION =       :FIELD_DEFINITION,
+        ARGUMENT_DEFINITION =    :ARGUMENT_DEFINITION,
+        INTERFACE =              :INTERFACE,
+        UNION =                  :UNION,
+        ENUM =                   :ENUM,
+        ENUM_VALUE =             :ENUM_VALUE,
+        INPUT_OBJECT =           :INPUT_OBJECT,
+        INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
+      ]
+
+      DEFAULT_DEPRECATION_REASON = 'No longer supported'
+      LOCATION_DESCRIPTIONS = {
+        QUERY:                    'Location adjacent to a query operation.',
+        MUTATION:                 'Location adjacent to a mutation operation.',
+        SUBSCRIPTION:             'Location adjacent to a subscription operation.',
+        FIELD:                    'Location adjacent to a field.',
+        FRAGMENT_DEFINITION:      'Location adjacent to a fragment definition.',
+        FRAGMENT_SPREAD:          'Location adjacent to a fragment spread.',
+        INLINE_FRAGMENT:          'Location adjacent to an inline fragment.',
+        SCHEMA:                   'Location adjacent to a schema definition.',
+        SCALAR:                   'Location adjacent to a scalar definition.',
+        OBJECT:                   'Location adjacent to an object type definition.',
+        FIELD_DEFINITION:         'Location adjacent to a field definition.',
+        ARGUMENT_DEFINITION:      'Location adjacent to an argument definition.',
+        INTERFACE:                'Location adjacent to an interface definition.',
+        UNION:                    'Location adjacent to a union definition.',
+        ENUM:                     'Location adjacent to an enum definition.',
+        ENUM_VALUE:               'Location adjacent to an enum value definition.',
+        INPUT_OBJECT:             'Location adjacent to an input object type definition.',
+        INPUT_FIELD_DEFINITION:   'Location adjacent to an input object field definition.',
+      }
+    end
+  end
+end