graphql 1.8.7 → 1.9.0

data/lib/graphql/query/result.rb

@@ -37,7 +37,7 @@ module GraphQL
       end
 
       def inspect
-        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h} >"
+        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h}>"
       end
 
       # A result is equal to another object when:

data/lib/graphql/query/validation_pipeline.rb

@@ -14,6 +14,8 @@ module GraphQL
     #
     # @api private
     class ValidationPipeline
+      attr_reader :max_depth, :max_complexity
+
       def initialize(query:, validate:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
         @internal_representation = nil
@@ -34,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
@@ -74,11 +76,11 @@ module GraphQL
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 
-          if @validation_errors.none?
+          if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
           end
 
-          if @validation_errors.none?
+          if @validation_errors.empty?
             @query_analyzers = build_analyzers(
               @schema,
               @max_depth,
@@ -87,24 +89,46 @@ module GraphQL
           end
         end
 
-        @valid = @validation_errors.none?
+        @valid = @validation_errors.empty?
       end
 
       # If there are max_* values, add them,
       # otherwise reuse the schema's list of analyzers.
       def build_analyzers(schema, max_depth, max_complexity)
-        if max_depth || max_complexity
-          qa = schema.query_analyzers.dup
+        qa = schema.query_analyzers.dup
 
-          if max_depth
-            qa << GraphQL::Analysis::MaxQueryDepth.new(max_depth)
+        # Filter out the built in authorization analyzer.
+        # It is deprecated and does not have an AST analyzer alternative.
+        qa = qa.select do |analyzer|
+          if analyzer == GraphQL::Authorization::Analyzer && schema.using_ast_analysis?
+            raise "The Authorization analyzer is not supported with AST Analyzers"
+          else
+            true
           end
-          if max_complexity
-            qa << GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)
+        end
+
+        if max_depth || max_complexity
+          # Depending on the analysis engine, we must use different analyzers
+          # remove this once everything has switched over to AST analyzers
+          if schema.using_ast_analysis?
+            if max_depth
+              qa << GraphQL::Analysis::AST::MaxQueryDepth
+            end
+            if max_complexity
+              qa << GraphQL::Analysis::AST::MaxQueryComplexity
+            end
+          else
+            if max_depth
+              qa << GraphQL::Analysis::MaxQueryDepth.new(max_depth)
+            end
+            if max_complexity
+              qa << GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)
+            end
           end
+
           qa
         else
-          schema.query_analyzers
+          qa
         end
       end
     end

data/lib/graphql/query/variable_validation_error.rb

@@ -14,7 +14,16 @@ module GraphQL
       end
 
       def to_h
-        super.merge({ "value" => value, "problems" => validation_result.problems })
+        # It is possible there are other extension items in this error, so handle
+        # a one level deep merge explicitly. However beyond that only show the
+        # latest value and problems.
+        super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
+          if oldValue.respond_to? merge
+            oldValue.merge(newValue)
+          else
+            newValue
+          end
+        end
       end
     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
@@ -221,11 +234,12 @@ module GraphQL
       with_prepared_ast { @validation_pipeline }
     end
 
-    def_delegators :validation_pipeline, :validation_errors, :internal_representation, :analyzers
+    def_delegators :validation_pipeline, :validation_errors, :internal_representation,
+                   :analyzers, :ast_analyzers, :max_depth, :max_complexity
 
     attr_accessor :analysis_errors
     def valid?
-      validation_pipeline.valid? && analysis_errors.none?
+      validation_pipeline.valid? && analysis_errors.empty?
     end
 
     def warden

data/lib/graphql/relay/base_connection.rb

@@ -70,6 +70,8 @@ module GraphQL
 
       def decode(data)
         @encoder.decode(data, nonce: true)
+      rescue ArgumentError
+        raise GraphQL::ExecutionError, "Invalid cursor: #{data.inspect}"
       end
 
       # The value passed as `first:`, if there was one. Negative numbers become `0`.

data/lib/graphql/relay/connection_instrumentation.rb

@@ -32,7 +32,9 @@ module GraphQL
       # - Merging in the default arguments
       # - Transforming its resolve function to return a connection object
       def self.instrument(type, field)
-        if field.connection?
+        # Don't apply the wrapper to class-based fields, since they
+        # use Schema::Field::ConnectionFilter
+        if field.connection? && !field.metadata[:type_class]
           connection_arguments = default_arguments.merge(field.arguments)
           original_resolve = field.resolve_proc
           original_lazy_resolve = field.lazy_resolve_proc

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/node.rb

@@ -8,13 +8,7 @@ module GraphQL
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
-        field = GraphQL::Field.define do
-          type(GraphQL::Relay::Node.interface)
-          description("Fetches an object given its ID.")
-          argument(:id, types.ID.to_non_null_type, "ID of the object.")
-          resolve(GraphQL::Relay::Node::FindNode)
-          relay_node_field(true)
-        end
+        field = GraphQL::Types::Relay::NodeField.graphql_definition
 
         if kwargs.any? || block
           field = field.redefine(kwargs, &block)
@@ -24,13 +18,7 @@ module GraphQL
       end
 
       def self.plural_field(**kwargs, &block)
-        field = GraphQL::Field.define do
-          type(!types[GraphQL::Relay::Node.interface])
-          description("Fetches a list of objects given a list of IDs.")
-          argument(:ids, types.ID.to_non_null_type.to_list_type.to_non_null_type, "IDs of the objects.")
-          resolve(GraphQL::Relay::Node::FindNodes)
-          relay_nodes_field(true)
-        end
+        field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
           field = field.redefine(kwargs, &block)
@@ -43,20 +31,6 @@ module GraphQL
       def self.interface
         @interface ||= GraphQL::Types::Relay::Node.graphql_definition
       end
-
-      # A field resolve for finding objects by IDs
-      module FindNodes
-        def self.call(obj, args, ctx)
-          args[:ids].map { |id| ctx.query.schema.object_from_id(id, ctx) }
-        end
-      end
-
-      # A field resolve for finding an object by ID
-      module FindNode
-        def self.call(obj, args, ctx)
-          ctx.query.schema.object_from_id(args[:id], ctx )
-        end
-      end
     end
   end
 end

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/argument.rb

@@ -4,6 +4,7 @@ module GraphQL
     class Argument
       include GraphQL::Schema::Member::CachedGraphQLDefinition
       include GraphQL::Schema::Member::AcceptsDefinition
+      include GraphQL::Schema::Member::HasPath
 
       NO_DEFAULT = :__no_default__
 
@@ -27,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
@@ -50,6 +51,14 @@ module GraphQL
         end
       end
 
+      # @return [Object] the value used when the client doesn't provide a value for this argument
+      attr_reader :default_value
+
+      # @return [Boolean] True if this argument has a default value
+      def default_value?
+        @default_value != NO_DEFAULT
+      end
+
       attr_writer :description
 
       # @return [String] Documentation for this argument
@@ -96,12 +105,11 @@ module GraphQL
       # Used by the runtime.
       # @api private
       def prepare_value(obj, value)
-        case @prepare
-        when nil
+        if @prepare.nil?
           value
-        when Symbol, String
+        elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)
           obj.public_send(@prepare, value)
-        when Proc
+        elsif @prepare.respond_to?(:call)
           @prepare.call(value, obj.context)
         else
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"

data/lib/graphql/schema/base_64_encoder.rb

@@ -6,13 +6,13 @@ module GraphQL
   class Schema
     # @api private
     module Base64Encoder
-      def self.encode(plaintext, nonce: false)
-        Base64.strict_encode64(plaintext)
+      def self.encode(unencoded_text, nonce: false)
+        Base64Bp.urlsafe_encode64(unencoded_text, padding: false)
       end
 
-      def self.decode(ciphertext, nonce: false)
+      def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
-        Base64Bp.urlsafe_decode64(ciphertext)
+        Base64Bp.urlsafe_decode64(encoded_text)
       end
     end
   end

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/default_type_error.rb

@@ -6,7 +6,7 @@ module GraphQL
         case type_error
         when GraphQL::InvalidNullError
           ctx.errors << type_error
-        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError
+        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
         end
       end

data/lib/graphql/schema/directive/feature.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      # An example directive to show how you might interact with the runtime.
+      #
+      # This directive might be used along with a server-side feature flag system like Flipper.
+      #
+      # With that system, you could use this directive to exclude parts of a query
+      # if the current viewer doesn't have certain flags enabled.
+      # (So, this flag would be for internal clients, like your iOS app, not third-party API clients.)
+      #
+      # To use it, you have to implement `.enabled?`, for example:
+      #
+      # @example Implementing the Feature directive
+      #   # app/graphql/directives/feature.rb
+      #   class Directives::Feature < GraphQL::Schema::Directive::Feature
+      #     def self.enabled?(flag_name, _obj, context)
+      #       # Translate some GraphQL data for Ruby:
+      #       flag_key = flag_name.underscore
+      #       current_user = context[:viewer]
+      #       # Check the feature flag however your app does it:
+      #       MyFeatureFlags.enabled?(current_user, flag_key)
+      #     end
+      #   end
+      #
+      # @example Flagging a part of the query
+      #   viewer {
+      #     # This field only runs if `.enabled?("recommendationEngine", obj, context)`
+      #     # returns true. Otherwise, it's treated as if it didn't exist.
+      #     recommendations @feature(flag: "recommendationEngine") {
+      #       name
+      #       rating
+      #     }
+      #   }
+      class Feature < Schema::Directive
+        description "Directs the executor to run this only if a certain server-side feature is enabled."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+          GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+          GraphQL::Schema::Directive::INLINE_FRAGMENT
+        )
+
+        argument :flag, String, required: true,
+          description: "The name of the feature to check before continuing"
+
+        # Implement the Directive API
+        def self.include?(object, arguments, context)
+          flag_name = arguments[:flag]
+          self.enabled?(flag_name, object, context)
+        end
+
+        # Override this method in your app's subclass of this directive.
+        #
+        # @param flag_name [String] The client-provided string of a feature to check
+        # @param object [GraphQL::Schema::Objct] The currently-evaluated GraphQL object instance
+        # @param context [GraphQL::Query::Context]
+        # @return [Boolean] If truthy, execution will continue
+        def self.enabled?(flag_name, object, context)
+          raise NotImplementedError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/include.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class Include < GraphQL::Schema::Directive
+        description "Directs the executor to include this field or fragment only when the `if` argument is true."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+          GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+          GraphQL::Schema::Directive::INLINE_FRAGMENT
+        )
+
+        argument :if, Boolean, required: true,
+          description: "Included when true."
+
+        default_directive true
+
+        def self.include?(obj, args, ctx)
+          !!args[:if]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/skip.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class Skip < Schema::Directive
+        description "Directs the executor to skip this field or fragment when the `if` argument is true."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+          GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+          GraphQL::Schema::Directive::INLINE_FRAGMENT
+        )
+
+        argument :if, Boolean, required: true,
+          description: "Skipped when true."
+
+        default_directive true
+
+        def self.include?(obj, args, ctx)
+          !args[:if]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive/transform.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      # An example directive to show how you might interact with the runtime.
+      #
+      # This directive takes the return value of the tagged part of the query,
+      # and if the named transform is whitelisted and applies to the return value,
+      # it's applied by calling a method with that name.
+      #
+      # @example Installing the directive
+      #   class MySchema < GraphQL::Schema
+      #     directive(GraphQL::Schema::Directive::Transform)
+      #   end
+      #
+      # @example Transforming strings
+      #   viewer {
+      #     username @transform(by: "upcase")
+      #   }
+      class Transform < Schema::Directive
+        description "Directs the executor to run named transform on the return value."
+
+        locations(
+          GraphQL::Schema::Directive::FIELD,
+        )
+
+        argument :by, String, required: true,
+          description: "The name of the transform to run if applicable"
+
+        TRANSFORMS = [
+          "upcase",
+          "downcase",
+          # ??
+        ]
+        # Implement the Directive API
+        def self.resolve(object, arguments, context)
+          path = context.namespace(:interpreter)[:current_path]
+          return_value = yield
+          transform_name = arguments[:by]
+          if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
+            return_value = return_value.public_send(transform_name)
+            context.namespace(:interpreter)[:runtime].write_in_response(path, return_value)
+          end
+        end
+      end
+    end
+  end
+end

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

data/lib/graphql/schema/enum_value.rb

@@ -27,6 +27,7 @@ module GraphQL
     #   end
     class EnumValue < GraphQL::Schema::Member
       include GraphQL::Schema::Member::AcceptsDefinition
+      include GraphQL::Schema::Member::HasPath
 
       attr_reader :graphql_name
 
@@ -39,7 +40,7 @@ module GraphQL
       def initialize(graphql_name, desc = nil, owner:, description: nil, value: nil, deprecation_reason: nil, &block)
         @graphql_name = graphql_name.to_s
         @description = desc || description
-        @value = value || @graphql_name
+        @value = value.nil? ? @graphql_name : value
         @deprecation_reason = deprecation_reason
         @owner = owner
 
@@ -56,7 +57,7 @@ module GraphQL
       end
 
       def value(new_val = nil)
-        if new_val
+        unless new_val.nil?
           @value = new_val
         end
         @value