graphql 1.4.5 → 1.5.3

data/lib/graphql/internal_representation/visit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GraphQL
+  module InternalRepresentation
+    # Traverse a re-written query tree, calling handlers for each node
+    module Visit
+      module_function
+      def visit_each_node(operations, handlers)
+        # Post-validation: make some assertions about the rewritten query tree
+        operations.each do |op_name, op_node|
+          # Yield each node to listeners which were attached by validators
+          op_node.typed_children.each do |obj_type, children|
+            children.each do |name, op_child_node|
+              each_node(op_child_node) do |node|
+                for h in handlers
+                  h.call(node)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Traverse a node in a rewritten query tree,
+      # visiting the node itself and each of its typed children.
+      def each_node(node)
+        yield(node)
+        if node.typed_children.any?
+          visit_block = Proc.new
+          node.typed_children.each do |obj_type, children|
+            children.each do |name, node|
+              each_node(node, &visit_block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/introspection/input_value_type.rb

@@ -11,7 +11,16 @@ GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
     resolve ->(obj, args, ctx) {
       if obj.default_value?
         value = obj.default_value
-        value.nil? ? 'null' : GraphQL::Language.serialize(obj.type.coerce_result(value))
+        if value.nil?
+          'null'
+        else
+          coerced_default_value = obj.type.coerce_result(value)
+          if obj.type.unwrap.is_a?(GraphQL::EnumType)
+            coerced_default_value
+          else
+            GraphQL::Language.serialize(coerced_default_value)
+          end
+        end
       else
         nil
       end

data/lib/graphql/introspection/schema_type.rb

@@ -6,7 +6,7 @@ GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
               "query, mutation, and subscription operations."
 
   field :types, !types[!GraphQL::Introspection::TypeType], "A list of all types supported by this server." do
-    resolve -> (obj, arg, ctx) { ctx.warden.types }
+    resolve ->(obj, arg, ctx) { ctx.warden.types }
   end
 
   field :queryType, !GraphQL::Introspection::TypeType, "The type that query operations will be rooted at." do

data/lib/graphql/language/lexer.rb

@@ -990,7 +990,7 @@ end
       def self.record_comment(ts, te, meta)
         token = GraphQL::Language::Token.new(
           name: :COMMENT,
-          value: meta[:data][ts...te].pack("c*").force_encoding("UTF-8"),
+          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
           line: meta[:line],
           col: meta[:col],
           prev_token: meta[:previous_token],
@@ -1004,7 +1004,7 @@ end
       def self.emit(token_name, ts, te, meta)
         meta[:tokens] << token = GraphQL::Language::Token.new(
           name: token_name,
-          value: meta[:data][ts...te].pack("c*").force_encoding("UTF-8"),
+          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
           line: meta[:line],
           col: meta[:col],
           prev_token: meta[:previous_token],
@@ -1031,8 +1031,11 @@ end
 
       VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
 
+      PACK_DIRECTIVE = "c*"
+      UTF_8_ENCODING = "UTF-8"
+
       def self.emit_string(ts, te, meta)
-        value = meta[:data][ts...te].pack("c*").force_encoding("UTF-8")
+        value = meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
         if value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/language/lexer.rl

@@ -145,7 +145,7 @@ module GraphQL
       def self.record_comment(ts, te, meta)
         token = GraphQL::Language::Token.new(
           name: :COMMENT,
-          value: meta[:data][ts...te].pack("c*").force_encoding("UTF-8"),
+          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
           line: meta[:line],
           col: meta[:col],
           prev_token: meta[:previous_token],
@@ -159,7 +159,7 @@ module GraphQL
       def self.emit(token_name, ts, te, meta)
         meta[:tokens] << token = GraphQL::Language::Token.new(
           name: token_name,
-          value: meta[:data][ts...te].pack("c*").force_encoding("UTF-8"),
+          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
           line: meta[:line],
           col: meta[:col],
           prev_token: meta[:previous_token],
@@ -186,8 +186,11 @@ module GraphQL
 
       VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
 
+      PACK_DIRECTIVE = "c*"
+      UTF_8_ENCODING = "UTF-8"
+
       def self.emit_string(ts, te, meta)
-        value = meta[:data][ts...te].pack("c*").force_encoding("UTF-8")
+        value = meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
         if value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/object_type.rb

@@ -23,6 +23,7 @@ module GraphQL
   #
   class ObjectType < GraphQL::BaseType
     accepts_definitions :interfaces, :fields, :mutation, field: GraphQL::Define::AssignObjectField
+    accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
 
     attr_accessor :fields, :mutation
     ensure_defined(:fields, :mutation, :interfaces)
@@ -33,34 +34,39 @@ module GraphQL
     # @!attribute mutation
     #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
 
-
     def initialize
       super
       @fields = {}
+      @interface_fields = {}
       @dirty_interfaces = []
+      @dirty_inherited_interfaces = []
     end
 
     def initialize_copy(other)
       super
       @clean_interfaces = nil
+      @clean_inherited_interfaces = nil
       @dirty_interfaces = other.dirty_interfaces.dup
+      @dirty_inherited_interfaces = other.dirty_inherited_interfaces.dup
       @fields = other.fields.dup
     end
 
+    # This method declares interfaces for this type AND inherits any field definitions
     # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
+    # @deprecated Use `implements` instead of `interfaces`.
     def interfaces=(new_interfaces)
       @clean_interfaces = nil
-      @dirty_interfaces = new_interfaces
+      @clean_inherited_interfaces = nil
+      @clean_inherited_fields = nil
+
+      @dirty_inherited_interfaces = []
+      @dirty_inherited_fields = {}
+      implements(new_interfaces, inherit: true)
     end
 
     def interfaces
-      @clean_interfaces ||= begin
-        if @dirty_interfaces.respond_to?(:map)
-          @dirty_interfaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
-        else
-          @dirty_interfaces
-        end
-      end
+      load_interfaces
+      @clean_interfaces
     end
 
     def kind
@@ -77,16 +83,50 @@ module GraphQL
       interface_fields.merge(self.fields).values
     end
 
+    # Declare that this object implements this interface.
+    # This declaration will be validated when the schema is defined.
+    # @param interfaces [Array<GraphQL::Interface>] add a new interface that this type implements
+    # @param inherits [Boolean] If true, copy the interfaces' field definitions to this type
+    def implements(interfaces, inherit: false)
+      if !interfaces.is_a?(Array)
+        raise ArgumentError, "`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})"
+      end
+
+      @clean_interfaces = nil
+      @clean_inherited_fields = nil
+      dirty_ifaces = inherit ? @dirty_inherited_interfaces : @dirty_interfaces
+      dirty_ifaces.concat(interfaces)
+    end
+
     protected
 
-    attr_reader :dirty_interfaces
+    attr_reader :dirty_interfaces, :dirty_inherited_interfaces
 
     private
 
-    # Create a {name => defn} hash for fields inherited from interfaces
+    def normalize_interfaces(ifaces)
+      ifaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
+    end
+
     def interface_fields
-      interfaces.reduce({}) do |memo, iface|
-        memo.merge!(iface.fields)
+      load_interfaces
+      @clean_inherited_fields
+    end
+
+    def load_interfaces
+      @clean_interfaces ||= begin
+        ensure_defined
+        clean_ifaces = normalize_interfaces(@dirty_interfaces)
+        clean_inherited_ifaces = normalize_interfaces(@dirty_inherited_interfaces)
+        inherited_fields = {}
+        clean_inherited_ifaces.each do |iface|
+          # This will be found later in schema validation:
+          if iface.is_a?(GraphQL::InterfaceType)
+            inherited_fields.merge!(iface.fields)
+          end
+        end
+        @clean_inherited_fields = inherited_fields
+        clean_inherited_ifaces + clean_ifaces
       end
     end
   end

data/lib/graphql/query.rb

@@ -35,7 +35,8 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param except [<#call(schema_member)>] If provided, objects will be hidden from the schema when `.call(schema_member)` returns truthy
+    # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
+    # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
     def initialize(schema, query_string = nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
       fail ArgumentError, "a query string or document is required" unless query_string || document
 
@@ -62,8 +63,15 @@ module GraphQL
         @provided_variables = variables
       end
       @query_string = query_string
-      @document = document || GraphQL.parse(query_string)
-      @document.definitions.each do |part|
+      @parse_error = nil
+      @document = document || begin
+        GraphQL.parse(query_string)
+      rescue GraphQL::ParseError => err
+        @parse_error = err
+        @schema.parse_error(err, @context)
+        nil
+      end
+      @document && @document.definitions.each do |part|
         if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
           @fragments[part.name] = part
         elsif part.is_a?(GraphQL::Language::Nodes::OperationDefinition)
@@ -109,7 +117,7 @@ module GraphQL
         begin
           instrumenters.each { |i| i.before_query(self) }
           @result = if !valid?
-            all_errors = validation_errors + analysis_errors
+            all_errors = validation_errors + analysis_errors + context.errors
             if all_errors.any?
               { "errors" => all_errors.map(&:to_h) }
             else
@@ -156,10 +164,7 @@ module GraphQL
     end
 
     def irep_selection
-      @selection ||= begin
-        irep_root = internal_representation[selected_operation.name]
-        GraphQL::InternalRepresentation::Selection.new(query: self, nodes: [irep_root])
-      end
+      @selection ||= internal_representation[selected_operation.name]
     end
 
 
@@ -181,11 +186,22 @@ module GraphQL
     # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
     def arguments_for(irep_node, definition)
       @arguments_cache[irep_node][definition] ||= begin
-        GraphQL::Query::LiteralInput.from_arguments(
-          irep_node.ast_node.arguments,
-          definition.arguments,
-          self.variables
-        )
+        ast_node = case irep_node
+        when GraphQL::Language::Nodes::AbstractNode
+          irep_node
+        else
+          irep_node.ast_node
+        end
+        ast_arguments = ast_node.arguments
+        if ast_arguments.none?
+          definition.default_arguments
+        else
+          GraphQL::Query::LiteralInput.from_arguments(
+            ast_arguments,
+            definition.arguments,
+            self.variables
+          )
+        end
       end
     end
 
@@ -195,7 +211,7 @@ module GraphQL
     def valid?
       @was_validated ||= begin
         @was_validated = true
-        @valid = document_valid? && query_valid? && variables.errors.none?
+        @valid = @parse_error.nil? && document_valid? && query_valid? && variables.errors.none?
         true
       end
 

data/lib/graphql/query/arguments.rb

@@ -48,6 +48,8 @@ module GraphQL
         end
       end
 
+      NO_ARGS = self.new({}, argument_definitions: [])
+
       private
 
       class ArgumentValue

data/lib/graphql/query/context.rb

@@ -88,12 +88,12 @@ module GraphQL
 
         # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
         def ast_node
-          selection.irep_node.ast_node
+          @selection.ast_node
         end
 
         # @return [GraphQL::InternalRepresentation::Node]
         def irep_node
-          selection.irep_node
+          @selection
         end
 
         # Add error to current field resolution.

data/lib/graphql/query/literal_input.rb

@@ -29,7 +29,16 @@ module GraphQL
         end
       end
 
+      def self.defaults_for(argument_defns)
+        if argument_defns.none? { |name, arg| arg.default_value? }
+          GraphQL::Query::Arguments::NO_ARGS
+        else
+          from_arguments([], argument_defns, nil)
+        end
+      end
+
       def self.from_arguments(ast_arguments, argument_defns, variables)
+
         values_hash = {}
         indexed_arguments = ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
 

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -6,12 +6,12 @@ module GraphQL
         attr_reader :irep_node, :parent_type, :target, :field, :arguments, :query
 
         def initialize(selection, parent_type, target, query_ctx)
-          @irep_node = selection.irep_node
+          @irep_node = selection
           @selection = selection
           @parent_type = parent_type
           @target = target
           @query = query_ctx.query
-          @field = @query.get_field(parent_type, irep_node.definition_name)
+          @field = irep_node.definition
           @field_ctx = query_ctx.spawn(
             key: irep_node.name,
             selection: selection,

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -6,7 +6,7 @@ module GraphQL
         def self.resolve(target, current_type, selection, query_ctx)
           selection_result = {}
 
-          selection.each_selection(type: current_type) do |name, subselection|
+          selection.typed_children[current_type].each do |name, subselection|
             selection_result.merge!(query_ctx.execution_strategy.field_resolution.new(
               subselection,
               current_type,

data/lib/graphql/relay.rb

@@ -6,6 +6,7 @@ require 'graphql/relay/edge'
 require 'graphql/relay/edge_type'
 require 'graphql/relay/base_connection'
 require 'graphql/relay/array_connection'
+require 'graphql/relay/range_add'
 require 'graphql/relay/relation_connection'
 require 'graphql/relay/global_id_resolve'
 require 'graphql/relay/mutation'

data/lib/graphql/relay/array_connection.rb

@@ -43,7 +43,7 @@ module GraphQL
         @starting_offset = if before
           [previous_offset, 0].max
         elsif last
-          nodes.count - last
+          [nodes.count - last, 0].max
         else
           previous_offset
         end

data/lib/graphql/relay/base_connection.rb

@@ -74,21 +74,28 @@ module GraphQL
         @encoder.decode(data, nonce: true)
       end
 
-      # Provide easy access to provided arguments:
-      METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before]
-
-      # @!method first
-      #   The value passed as `first:`, if there was one
-      # @!method after
-      #   The value passed as `after:`, if there was one
-      # @!method last
-      #   The value passed as `last:`, if there was one
-      # @!method before
-      #   The value passed as `before:`, if there was one
-      METHODS_FROM_ARGUMENTS.each do |arg_name|
-        define_method(arg_name) do
-          arguments[arg_name]
-        end
+      # The value passed as `first:`, if there was one. Negative numbers become `0`.
+      # @return [Integer, nil]
+      def first
+        @first ||= get_limited_arg(:first)
+      end
+
+      # The value passed as `after:`, if there was one
+      # @return [String, nil]
+      def after
+        arguments[:after]
+      end
+
+      # The value passed as `last:`, if there was one. Negative numbers become `0`.
+      # @return [Integer, nil]
+      def last
+        @last ||= get_limited_arg(:last)
+      end
+
+      # The value passed as `before:`, if there was one
+      # @return [String, nil]
+      def before
+        arguments[:before]
       end
 
       # These are the nodes to render for this connection,
@@ -137,6 +144,18 @@ module GraphQL
 
       private
 
+      # Return a sanitized `arguments[arg_name]` (don't allow negatives)
+      def get_limited_arg(arg_name)
+        arg_value = arguments[arg_name]
+        if arg_value.nil?
+          arg_value
+        elsif arg_value < 0
+          0
+        else
+          arg_value
+        end
+      end
+
       def paged_nodes
         raise NotImplementedError, "must return nodes for this connection after paging"
       end