graphql 0.10.9 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f073abd68886cc4042f66cff4457c9adcae153f7
-  data.tar.gz: 895ea36770f92665af805b9181c8641fb5614567
+  metadata.gz: 1cd9ee8f70346b2d0419202f3997fd562149ab8f
+  data.tar.gz: a0faf5a06c605e3d44cd23b65e0e6b8cd8fc04a6
 SHA512:
-  metadata.gz: ce609e9c9523281b908378697e48344ffdc4e8c0597b69b30ddcea15f51468fa971805e4346f6aad5c36536f760bfefccd6449abcaf1825e80f925af149682c1
-  data.tar.gz: 78611caafff37f1b1a142aa74af6eadac62b5cfdd35c0099f5afda063a95142ed1d036004e6eb7d2904762459b2c38cb97e36944af2b636f33fe7ef8ef15e69d
+  metadata.gz: ac440bd4b73f1f5c3c9de705928bfb90f4498ad0d614c856c3d9ad74fcead1b1881b663176dd368b48cbe7b651dddc1e32258799d4c334ea9347b8c550ce69f9
+  data.tar.gz: 3e573c20b9ab0ba44fdbd1a2e73a373b4d5c6e822ee5c4ebfc21c08849ea4ac5c37ac5933ca9e5c8128f0415a908b2c30868d4b7830d4e67f8008ff70c4434d9

data/lib/graphql.rb

@@ -16,12 +16,14 @@ module GraphQL
   end
 
   # Turn a query string into an AST
-  # @param string [String] a GraphQL query string
-  # @param as [Symbol] If you want to use this to parse some _piece_ of a document, pass the rule name (from {GraphQL::Parser})
+  # @param [String] a GraphQL query string
   # @return [GraphQL::Language::Nodes::Document]
-  def self.parse(string, as: nil)
-    parser = as ? GraphQL::PARSER.send(as) : GraphQL::PARSER
-    tree = parser.parse(string)
+  def self.parse(query_string)
+    parse_with_parslet(query_string)
+  end
+
+  def self.parse_with_parslet(string)
+    tree = GraphQL::PARSER.parse(string)
     document = GraphQL::TRANSFORM.apply(tree)
     if !document.is_a?(GraphQL::Language::Nodes::Document)
       raise("Parse failed! Sorry, somehow we failed to turn this string into a document. Please report this bug!")
@@ -66,6 +68,7 @@ require 'graphql/schema/printer'
 # Order does not matter for these:
 
 require 'graphql/execution_error'
+require 'graphql/invalid_null_error'
 require 'graphql/query'
 require 'graphql/repl'
 require 'graphql/static_validation'

data/lib/graphql/definition_helpers/defined_by_config.rb

@@ -26,6 +26,7 @@ module GraphQL::DefinitionHelpers::DefinedByConfig
       :interfaces, # object
       :deprecation_reason, # field
       :type, # field / argument
+      :property, # field
       :resolve, # field / directive
       :resolve_type, # interface / union
       :possible_types, # interface / union
@@ -59,7 +60,7 @@ module GraphQL::DefinitionHelpers::DefinedByConfig
       end
       type && field.type = type
       desc && field.description = desc
-      property && field.resolve = -> (t,a,c) { t.public_send(property)}
+      property && field.property = property
       field.name ||= name.to_s
       fields[name.to_s] = field
     end

data/lib/graphql/field.rb

@@ -8,6 +8,16 @@
 #     field :name, types.String, "The name of this thing "
 #   end
 #
+# @example handling a circular reference
+#   # If the field's type isn't defined yet, you have two options:
+#
+#   GraphQL::ObjectType.define do
+#     # If you pass a Proc, it will be evaluated at schema build-time
+#     field :city, -> { CityType }
+#     # If you pass a String, it will be looked up in the global namespace at schema build-time
+#     field :country, "CountryType"
+#   end
+#
 # @example creating a field that accesses a different property on the object
 #   GraphQL::ObjectType.define do
 #     # use the `property` option:
@@ -28,15 +38,14 @@
 #   end
 #
 class GraphQL::Field
-  DEFAULT_RESOLVE = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
   include GraphQL::DefinitionHelpers::DefinedByConfig
-  attr_accessor :arguments, :deprecation_reason, :name, :description, :type
+  attr_accessor :arguments, :deprecation_reason, :name, :description, :type, :property
   attr_reader :resolve_proc
-  defined_by_config :arguments, :deprecation_reason, :name, :description, :type, :resolve
+  defined_by_config :arguments, :deprecation_reason, :name, :description, :type, :resolve, :property
 
   def initialize
     @arguments = {}
-    @resolve_proc = DEFAULT_RESOLVE
+    @resolve_proc = build_default_resolver
   end
 
   def arguments(new_arguments=nil)
@@ -63,19 +72,37 @@ class GraphQL::Field
   end
 
   def resolve=(resolve_proc)
-    @resolve_proc = resolve_proc || DEFAULT_RESOLVE
+    @resolve_proc = resolve_proc || build_default_resolver
   end
 
   # Get the return type for this field.
   def type
-    if @type.is_a?(Proc)
+    case @type
+    when Proc
       # lazy-eval it
       @type = @type.call
+    when String
+      # Get a constant by this name
+      @type = Object.const_get(@type)
+    else
+      @type
     end
-    @type
   end
 
   def to_s
     "<Field: #{name || "not-named"}>"
   end
+
+  private
+
+  def build_default_resolver
+    # Note: lambda accesses the current Field via self
+    -> (t, a, c) do
+      if property = self.property
+        t.public_send(property)
+      else
+        GraphQL::Query::DEFAULT_RESOLVE
+      end
+    end
+  end
 end

data/lib/graphql/input_object_type.rb

@@ -20,10 +20,11 @@ class GraphQL::InputObjectType < GraphQL::BaseType
     GraphQL::TypeKinds::INPUT_OBJECT
   end
 
+  # assert that all present fields are defined
+  # _and_ all defined fields have valid values
   def valid_non_null_input?(input)
-    return false unless input.is_a?(Hash) || input.is_a?(GraphQL::Query::Arguments)
-    return false unless input.all? { |name, value| input_fields[name] }
-    input_fields.all? { |name, field| field.type.valid_input?(input[name]) }
+    input.all? { |name, value| input_fields[name] } &&
+      input_fields.all? { |name, field| field.type.valid_input?(input[name]) }
   end
 
   def coerce_non_null_input(value)

data/lib/graphql/invalid_null_error.rb

@@ -0,0 +1,22 @@
+module GraphQL
+  # Raised automatically when a field's resolve function returns `nil`
+  # for a non-null field.
+  class InvalidNullError < RuntimeError
+    def initialize(field_name, value)
+      @field_name = field_name
+      @value = value
+    end
+
+    # @return [Hash] An entry for the response's "errors" key
+    def to_h
+      {
+        "message" => "Cannot return null for non-nullable field #{@field_name}"
+      }
+    end
+
+    # @return [Boolean] Whether the null in question was caused by another error
+    def parent_error?
+      @value.is_a?(GraphQL::ExecutionError)
+    end
+  end
+end

data/lib/graphql/language/nodes.rb

@@ -8,86 +8,193 @@ module GraphQL
         attr_accessor :line, :col
 
         # @param options [Hash] Must contain all attributes defined by {required_attrs}, may also include `position_source`
-        def initialize(options)
-          required_keys = self.class.required_attrs
-          allowed_keys = required_keys + [:line, :col]
-          position_source = options.delete(:position_source)
-          if !position_source.nil?
-            options[:line], options[:col] = position_source.line_and_column
+        def initialize(options={})
+          if options.key?(:position_source)
+            position_source = options.delete(:position_source)
+            @line, @col = position_source.line_and_column
+          elsif options.key?(:line)
+            @line = options.delete(:line)
+            @col = options.delete(:col)
           end
 
-          present_keys = options.keys
-          extra_keys = present_keys - allowed_keys
-          if extra_keys.any?
-            raise ArgumentError, "#{self.class.name} Extra arguments: #{extra_keys}"
-          end
-
-          missing_keys = required_keys - present_keys
-          if missing_keys.any?
-            raise ArgumentError, "#{self.class.name} Missing arguments: #{missing_keys}"
-          end
+          initialize_node(options)
+        end
 
-          allowed_keys.each do |key|
-            if options.has_key?(key)
-              value = options[key]
-              self.send("#{key}=", value)
-            end
-          end
+        # This is called with node-specific options
+        def initialize_node(options={})
+          raise NotImplementedError
         end
 
-        # Test all attributes, checking for any other nodes below this one
+        # @return [GraphQL::Language::Nodes::AbstractNode] all nodes in the tree below this one
         def children
-          self.class.required_attrs
-            .map { |attr| send(attr) }
+          self.class.child_attributes
+            .map { |attr_name| public_send(attr_name) }
             .flatten
-            .select { |val| val.is_a?(GraphQL::Language::Nodes::AbstractNode) }
         end
 
         class << self
-          attr_reader :required_attrs
-          # Defines attributes which are required at initialization.
-          def attr_required(*attr_names)
-            @required_attrs ||= []
-            @required_attrs += attr_names
-            attr_accessor(*attr_names)
+          def child_attributes(*attr_names)
+            @child_attributes ||= []
+            @child_attributes += attr_names
           end
+        end
 
-          # Create a new AbstractNode child which
-          # requires and exposes {attr_names}.
-          # @param attr_names [Array<Symbol>] Attributes this node class will have
-          # @param block [Block] Block passed to `Class.new`
-          # @return [Class] A new node class
-          def create(*attr_names, &block)
-            cls = Class.new(self, &block)
-            cls.attr_required(*attr_names)
-            cls
-          end
+        def position
+          [line, col]
+        end
+      end
+
+      class WrapperType < AbstractNode
+        attr_accessor :of_type
+        def initialize_node(of_type: nil)
+          @of_type = of_type
+        end
+
+        def children
+          [].freeze
+        end
+      end
+
+      class NameOnlyNode < AbstractNode
+        attr_accessor :name
+        def initialize_node(name: nil)
+          @name = name
+        end
+
+        def children
+          [].freeze
         end
       end
 
-      Argument = AbstractNode.create(:name, :value)
-      Directive = AbstractNode.create(:name, :arguments)
-      Document = AbstractNode.create(:parts)
-      Enum = AbstractNode.create(:name)
-      Field = AbstractNode.create(:name, :alias, :arguments, :directives, :selections)
-      FragmentDefinition = AbstractNode.create(:name, :type, :directives, :selections)
-      FragmentSpread = AbstractNode.create(:name, :directives)
-      InlineFragment = AbstractNode.create(:type, :directives, :selections)
-      InputObject = AbstractNode.create(:pairs) do
+
+      class Argument < AbstractNode
+        attr_accessor :name, :value
+
+        def initialize_node(name: nil, value: nil)
+          @name = name
+          @value = value
+        end
+
+        def children
+          [value].flatten.select { |v| v.is_a?(AbstractNode) }
+        end
+      end
+
+      class Directive < AbstractNode
+        attr_accessor :name, :arguments
+        child_attributes :arguments
+
+        def initialize_node(name: nil, arguments: [])
+          @name = name
+          @arguments = arguments
+        end
+      end
+
+      class Document < AbstractNode
+        attr_accessor :definitions
+        child_attributes :definitions
+
+        def initialize_node(definitions: [])
+          @definitions = definitions
+        end
+      end
+
+      class Enum < NameOnlyNode; end
+
+      class Field < AbstractNode
+        attr_accessor :name, :alias, :arguments, :directives, :selections
+        child_attributes :arguments, :directives, :selections
+
+        def initialize_node(name: nil, arguments: [], directives: [], selections: [], **kwargs)
+          @name = name
+          # oops, alias is a keyword:
+          @alias = kwargs.fetch(:alias, nil)
+          @arguments = arguments
+          @directives = directives
+          @selections = selections
+        end
+      end
+
+      class FragmentDefinition < AbstractNode
+        attr_accessor :name, :type, :directives, :selections
+        child_attributes :directives, :selections
+
+        def initialize_node(name: nil, type: nil, directives: [], selections: [])
+          @name = name
+          @type = type
+          @directives = directives
+          @selections = selections
+        end
+      end
+
+      class FragmentSpread < AbstractNode
+        attr_accessor :name, :directives
+        child_attributes :directives
+
+        def initialize_node(name: nil, directives: [])
+          @name = name
+          @directives = directives
+        end
+      end
+
+      class InlineFragment < AbstractNode
+        attr_accessor :type, :directives, :selections
+        child_attributes :directives, :selections
+
+        def initialize_node(type: nil, directives: [], selections: [])
+          @type = type
+          @directives = directives
+          @selections = selections
+        end
+      end
+
+      class InputObject < AbstractNode
+        attr_accessor :arguments
+        child_attributes :arguments
+
+        def initialize_node(arguments: [])
+          @arguments = arguments
+        end
+
         def to_h(options={})
-          pairs.inject({}) do |memo, pair|
+          arguments.inject({}) do |memo, pair|
             v = pair.value
             memo[pair.name] = v.is_a?(InputObject) ? v.to_h : v
             memo
           end
         end
       end
-      ListType = AbstractNode.create(:of_type)
-      NonNullType = AbstractNode.create(:of_type)
-      OperationDefinition = AbstractNode.create(:operation_type, :name, :variables, :directives, :selections)
-      TypeName = AbstractNode.create(:name)
-      Variable = AbstractNode.create(:name, :type, :default_value)
-      VariableIdentifier = AbstractNode.create(:name)
+
+
+
+      class ListType < WrapperType; end
+      class NonNullType < WrapperType; end
+
+      class OperationDefinition < AbstractNode
+        attr_accessor :operation_type, :name, :variables, :directives, :selections
+        child_attributes :variables, :directives, :selections
+
+        def initialize_node(operation_type: nil, name: nil, variables: [], directives: [], selections: [])
+          @operation_type = operation_type
+          @name = name
+          @variables = variables
+          @directives = directives
+          @selections = selections
+        end
+      end
+
+      class TypeName < NameOnlyNode; end
+
+      class VariableDefinition < AbstractNode
+        attr_accessor :name, :type, :default_value
+        def initialize_node(name: nil, type: nil, default_value: nil)
+          @name = name
+          @type = type
+          @default_value = default_value
+        end
+      end
+
+      class VariableIdentifier < NameOnlyNode; end
     end
   end
 end

data/lib/graphql/language/transform.rb

@@ -1,6 +1,5 @@
 module GraphQL
   module Language
-
     # {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Language::Nodes} objects.
     class Transform < Parslet::Transform
 
@@ -18,8 +17,8 @@ module GraphQL
       end
 
       # Document
-      rule(document_parts: sequence(:p)) { CREATE_NODE[:Document, parts: p, line: (p.first ? p.first.line : 1), col: (p.first ? p.first.col : 1)]}
-      rule(document_parts: simple(:p)) { CREATE_NODE[:Document, parts: [], line: 1, col: 1]}
+      rule(document_parts: sequence(:p)) { CREATE_NODE[:Document, definitions: p, line: (p.first ? p.first.line : 1), col: (p.first ? p.first.col : 1)]}
+      rule(document_parts: simple(:p)) { CREATE_NODE[:Document, definitions: [], line: 1, col: 1]}
 
       # Fragment Definition
       rule(
@@ -52,8 +51,8 @@ module GraphQL
         selections:     sequence(:s),
       ) { CREATE_NODE[:OperationDefinition, operation_type: ot.to_s, name: n.to_s, variables: v, directives: d, selections: s, position_source: ot] }
       optional_sequence(:optional_variables)
-      rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: simple(:v)) { CREATE_NODE.(:Variable, name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
-      rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: sequence(:v)) { CREATE_NODE.(:Variable, name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
+      rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: simple(:v)) { CREATE_NODE.(:VariableDefinition, name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
+      rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: sequence(:v)) { CREATE_NODE.(:VariableDefinition, name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
       rule(variable_default_value: simple(:v) ) { v }
       rule(variable_default_value: sequence(:v) ) { v }
       # Query short-hand
@@ -89,7 +88,7 @@ module GraphQL
       rule(array: subtree(:v)) { v }
       rule(array: simple(:v)) { [] } # just `nil`
       rule(boolean: simple(:v)) { v == "true" ? true : false }
-      rule(input_object: sequence(:v)) { CREATE_NODE[:InputObject, pairs: v, line: (v.first ? v.first.line : 1), col: (v.first ? v.first.col : 1)] }
+      rule(input_object: sequence(:v)) { CREATE_NODE[:InputObject, arguments: v, line: (v.first ? v.first.line : 1), col: (v.first ? v.first.col : 1)] }
       rule(input_object_name: simple(:n), input_object_value: simple(:v)) { CREATE_NODE[:Argument, name: n.to_s, value: v, position_source: n]}
       rule(input_object_name: simple(:n), input_object_value: sequence(:v)) { CREATE_NODE[:Argument, name: n.to_s, value: v, position_source: n]}
       rule(int: simple(:v)) { v.to_i }