graphql 0.11.1 → 0.12.0

data/lib/graphql/float_type.rb

@@ -1,6 +1,5 @@
 GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
   name "Float"
-  coerce -> (value) do
-    value.is_a?(Numeric) ? value.to_f : nil
-  end
+  coerce_input -> (value) { value.is_a?(Numeric) ? value.to_f : nil }
+  coerce_result -> (value) { value.to_f }
 end

data/lib/graphql/id_type.rb

@@ -1,4 +1,12 @@
 GraphQL::ID_TYPE = GraphQL::ScalarType.define do
   name "ID"
-  coerce -> (value) { value.to_s }
+  coerce_result -> (value) { value.to_s }
+  coerce_input -> (value) {
+    case value
+    when String, Fixnum, Bignum
+      value.to_s
+    else
+      nil
+    end
+  }
 end

data/lib/graphql/input_object_type.rb

@@ -8,12 +8,15 @@
 #   end
 #
 class GraphQL::InputObjectType < GraphQL::BaseType
-  attr_accessor :name, :description, :input_fields
-  defined_by_config :name, :description, :input_fields
-  alias :arguments :input_fields
+  accepts_definitions input_field: GraphQL::Define::AssignArgument
 
-  def input_fields=(new_fields)
-    @input_fields = GraphQL::DefinitionHelpers::StringNamedHash.new(new_fields).to_h
+  # @return [Hash<String, GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
+  attr_accessor :arguments
+
+  alias :input_fields :arguments
+
+  def initialize
+    @arguments = {}
   end
 
   def kind
@@ -25,13 +28,13 @@ class GraphQL::InputObjectType < GraphQL::BaseType
 
     # Items in the input that are unexpected
     input.each do |name, value|
-      if input_fields[name].nil?
+      if arguments[name].nil?
         result.add_problem("Field is not defined on #{self.name}", [name])
       end
     end
 
     # Items in the input that are expected, but have invalid values
-    invalid_fields = input_fields.map do |name, field|
+    invalid_fields = arguments.map do |name, field|
       field_result = field.type.validate_input(input[name])
       if !field_result.valid?
         result.merge_result!(name, field_result)
@@ -44,7 +47,7 @@ class GraphQL::InputObjectType < GraphQL::BaseType
   def coerce_non_null_input(value)
     input_values = {}
 
-    input_fields.each do |input_key, input_field_defn|
+    arguments.each do |input_key, input_field_defn|
       field_value = value[input_key]
       field_value = input_field_defn.type.coerce_input(field_value)
 

data/lib/graphql/int_type.rb

@@ -1,4 +1,5 @@
 GraphQL::INT_TYPE = GraphQL::ScalarType.define do
   name "Int"
-  coerce -> (value) { value.is_a?(Numeric) ? value.to_i : nil }
+  coerce_input -> (value) { value.is_a?(Numeric) ? value.to_i : nil }
+  coerce_result -> (value) { value.to_i }
 end

data/lib/graphql/interface_type.rb

@@ -12,8 +12,13 @@
 #
 class GraphQL::InterfaceType < GraphQL::BaseType
   include GraphQL::BaseType::HasPossibleTypes
-  defined_by_config :name, :description, :fields, :resolve_type
-  attr_accessor :name, :description, :fields
+  accepts_definitions :resolve_type, field: GraphQL::Define::AssignObjectField
+
+  attr_accessor :fields
+
+  def initialize
+    @fields = {}
+  end
 
   def kind
     GraphQL::TypeKinds::INTERFACE

data/lib/graphql/introspection/input_value_type.rb

@@ -4,5 +4,14 @@ GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
   field :name, !types.String, "The key for this value"
   field :description, types.String, "What this value is used for"
   field :type, -> { !GraphQL::Introspection::TypeType }, "The expected type for this value"
-  field :defaultValue, types.String, "The value applied if no other value is provided", property: :default_value
+  field :defaultValue, types.String, "The value applied if no other value is provided" do
+    resolve -> (obj, args, ctx) {
+      value = obj.default_value
+      if value.is_a?(String)
+        "\"#{value}\""
+      else
+        value
+      end
+    }
+  end
 end

data/lib/graphql/invalid_null_error.rb

@@ -1,7 +1,7 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < RuntimeError
+  class InvalidNullError < GraphQL::Error
     def initialize(field_name, value)
       @field_name = field_name
       @value = value

data/lib/graphql/object_type.rb

@@ -1,37 +1,39 @@
 # This type exposes fields on an object.
 #
-#  @example defining a type for your IMDB clone
-#    MovieType = GraphQL::ObjectType.define do
-#      name "Movie"
-#      description "A full-length film or a short film"
-#      interfaces [ProductionInterface, DurationInterface]
+# @example defining a type for your IMDB clone
+#   MovieType = GraphQL::ObjectType.define do
+#     name "Movie"
+#     description "A full-length film or a short film"
+#     interfaces [ProductionInterface, DurationInterface]
 #
-#      field :runtimeMinutes, !types.Int, property: :runtime_minutes
-#      field :director, PersonType
-#      field :cast, CastType
-#      field :starring, types[PersonType] do
-#        arguments :limit, types.Int
-#        resolve -> (object, args, ctx) {
-#          stars = object.cast.stars
-#          args[:limit] && stars = stars.limit(args[:limit])
-#          stars
-#        }
-#       end
-#    end
+#     field :runtimeMinutes, !types.Int, property: :runtime_minutes
+#     field :director, PersonType
+#     field :cast, CastType
+#     field :starring, types[PersonType] do
+#       arguments :limit, types.Int
+#       resolve -> (object, args, ctx) {
+#         stars = object.cast.stars
+#         args[:limit] && stars = stars.limit(args[:limit])
+#         stars
+#       }
+#      end
+#   end
 #
 class GraphQL::ObjectType < GraphQL::BaseType
-  defined_by_config :name, :description, :interfaces, :fields
-  attr_accessor :name, :description, :interfaces, :fields
+  accepts_definitions :interfaces, field: GraphQL::Define::AssignObjectField
+  attr_accessor :name, :description, :interfaces
 
-  # Define fields to be `new_fields`, normalize with {StringNamedHash}
-  # @param new_fields [Hash] The fields exposed by this type
-  def fields=(new_fields)
-    @fields = GraphQL::DefinitionHelpers::StringNamedHash.new(new_fields).to_h
+  # @return [Hash<String, GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
+  attr_accessor :fields
+
+  def initialize
+    @fields = {}
+    @interfaces = []
   end
 
-  #   Shovel this type into each interface's `possible_types` array.
+  # Shovel this type into each interface's `possible_types` array.
   #
-  #   @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
+  # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
   def interfaces=(new_interfaces)
     @interfaces ||= []
     (@interfaces - new_interfaces).each { |i| i.possible_types.delete(self) }

data/lib/graphql/query.rb

@@ -1,16 +1,12 @@
 class GraphQL::Query
-  class OperationNameMissingError < StandardError
+  class OperationNameMissingError < GraphQL::Error
     def initialize(names)
       msg = "You must provide an operation name from: #{names.join(", ")}"
       super(msg)
     end
   end
 
-  # If a resolve function returns `GraphQL::Query::DEFAULT_RESOLVE`,
-  # The executor will send the field's name to the target object
-  # and use the result.
-  DEFAULT_RESOLVE = :__default_resolve
-  attr_reader :schema, :document, :context, :fragments, :operations, :debug
+  attr_reader :schema, :document, :context, :fragments, :operations, :debug, :max_depth
 
   # Prepare query `query_string` on `schema`
   # @param schema [GraphQL::Schema]
@@ -20,9 +16,10 @@ class GraphQL::Query
   # @param debug [Boolean] if true, errors are raised, if false, errors are put in the `errors` key
   # @param validate [Boolean] if true, `query_string` will be validated with {StaticValidation::Validator}
   # @param operation_name [String] if the query string contains many operations, this is the one which should be executed
-  def initialize(schema, query_string, context: nil, variables: {}, debug: false, validate: true, operation_name: nil)
+  def initialize(schema, query_string, context: nil, variables: {}, debug: false, validate: true, operation_name: nil, max_depth: nil)
     @schema = schema
     @debug = debug
+    @max_depth = max_depth || schema.max_depth
     @context = Context.new(query: self, values: context)
     @validate = validate
     @operation_name = operation_name
@@ -72,7 +69,7 @@ class GraphQL::Query
   private
 
   def validation_errors
-    @validation_errors ||= schema.static_validator.validate(document)
+    @validation_errors ||= schema.static_validator.validate(self)
   end
 
 

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

@@ -62,22 +62,12 @@ module GraphQL
 
 
         # Execute the field's resolve method
-        # then handle the DEFAULT_RESOLVE
         # @return [Proc] suitable to be the last step in a middleware chain
         def get_middleware_proc_from_field_resolve
           -> (_parent_type, parent_object, field_definition, field_args, context, _next) {
             context.ast_node = ast_node
             value = field_definition.resolve(parent_object, field_args, context)
             context.ast_node = nil
-
-            if value == GraphQL::Query::DEFAULT_RESOLVE
-              begin
-                value = target.public_send(ast_node.name)
-              rescue NoMethodError => err
-                raise("Couldn't resolve field '#{ast_node.name}' to #{parent_object.class} '#{parent_object}' (resulted in #{err})")
-              end
-            end
-
             value
           }
         end

data/lib/graphql/scalar_type.rb

@@ -11,8 +11,7 @@ module GraphQL
   #   end
   #
   class ScalarType < GraphQL::BaseType
-    defined_by_config :name, :coerce, :coerce_input, :coerce_result, :description
-    attr_accessor :name, :description
+    accepts_definitions :coerce, :coerce_input, :coerce_result
 
     def coerce=(proc)
       self.coerce_input = proc
@@ -21,7 +20,9 @@ module GraphQL
 
     def validate_non_null_input(value)
       result = Query::InputValidationResult.new
-      result.add_problem("Could not coerce value #{JSON.dump(value)} to #{name}") if coerce_non_null_input(value).nil?
+      if coerce_non_null_input(value).nil?
+        result.add_problem("Could not coerce value #{JSON.dump(value)} to #{name}")
+      end
       result
     end
 

data/lib/graphql/schema.rb

@@ -69,7 +69,7 @@ class GraphQL::Schema
     GraphQL::Schema::TypeExpression.new(self, ast_node).type
   end
 
-  class InvalidTypeError < StandardError
+  class InvalidTypeError < GraphQL::Error
     def initialize(type, errors)
       super("Type #{type.respond_to?(:name) ? type.name :  "Unnamed type" } is invalid: #{errors.join(", ")}")
     end

data/lib/graphql/static_validation/rules/document_does_not_exceed_max_depth.rb

@@ -4,7 +4,7 @@ module GraphQL
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
-        max_allowed_depth = context.schema.max_depth
+        max_allowed_depth = context.query.max_depth
         return if max_allowed_depth.nil?
 
         visitor = context.visitor

data/lib/graphql/static_validation/validation_context.rb

@@ -11,10 +11,11 @@ module GraphQL
     # It also provides limited access to the {TypeStack} instance,
     # which tracks state as you climb in and out of different fields.
     class ValidationContext
-      attr_reader :schema, :document, :errors, :visitor, :fragments, :operations
-      def initialize(schema, document)
-        @schema = schema
-        @document = document
+      attr_reader :query, :schema, :document, :errors, :visitor, :fragments, :operations
+      def initialize(query)
+        @query = query
+        @schema = query.schema
+        @document = query.document
         @fragments = {}
         @operations = {}
 

data/lib/graphql/static_validation/validator.rb

@@ -18,12 +18,12 @@ class GraphQL::StaticValidation::Validator
   # Validate `document` against the schema. Returns an array of message hashes.
   # @param document [GraphQL::Language::Nodes::Document]
   # @return [Array<Hash>]
-  def validate(document)
-    context = GraphQL::StaticValidation::ValidationContext.new(@schema, document)
+  def validate(query)
+    context = GraphQL::StaticValidation::ValidationContext.new(query)
     @rules.each do |rules|
       rules.new.validate(context)
     end
-    context.visitor.visit(document)
+    context.visitor.visit(query.document)
     context.errors.map(&:to_h)
   end
 end

data/lib/graphql/string_type.rb

@@ -1,4 +1,5 @@
 GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
   name "String"
-  coerce -> (value) { value.to_s }
+  coerce_result -> (value) { value.to_s }
+  coerce_input -> (value) { value.is_a?(String) ? value : nil }
 end

data/lib/graphql/union_type.rb

@@ -11,7 +11,7 @@
 class GraphQL::UnionType < GraphQL::BaseType
   include GraphQL::BaseType::HasPossibleTypes
   attr_accessor :name, :description, :possible_types
-  defined_by_config :name, :description, :possible_types, :resolve_type
+  accepts_definitions :possible_types, :resolve_type
 
   def kind
     GraphQL::TypeKinds::UNION

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.11.1"
+  VERSION = "0.12.0"
 end

data/readme.md

@@ -134,18 +134,12 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 
 ## To Do
 
-- Code clean-up
-  - Raise if you try to configure an attribute which doesn't suit the type (ie, if you try to define `resolve` on an ObjectType, it should somehow raise)
-  - make `DefinitionHelpers` more friendly for extension
 - Interface's possible types should be a property of the schema, not the interface
 - Type lookup should be by type name (to support reloaded constants in Rails code)
-- Depth validator should be aware of fragments
 - Add a complexity validator (reject queries if they're too big)
-- Add a custom dump for Relay (it expects default value strings to be double-quoted)
 - Add docs for shared behaviors & DRY code
 - Optimize the pure-Ruby parser (hand-write, RACC?!)
-- Big ideas:
-  - Revamp the fixture Schema to be more useful (better names, more extensible)
-  - __Subscriptions__
-    - This is a good chance to make an `Operation` abstraction of which `query`, `mutation` and `subscription` are members
-    - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)
+- Revamp the fixture Schema to be more useful (better names, more extensible)
+- __Subscriptions__
+  - This is a good chance to make an `Operation` abstraction of which `query`, `mutation` and `subscription` are members
+  - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)

data/spec/graphql/boolean_type_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe GraphQL::BOOLEAN_TYPE do
+  describe "coerce_input" do
+    def coerce_input(input)
+      GraphQL::BOOLEAN_TYPE.coerce_input(input)
+    end
+
+    it "accepts true and false" do
+      assert_equal true, coerce_input(true)
+      assert_equal false, coerce_input(false)
+    end
+
+    it "rejects other types" do
+      assert_equal nil, coerce_input("true")
+      assert_equal nil, coerce_input(5.5)
+      assert_equal nil, coerce_input(nil)
+    end
+  end
+end

data/spec/graphql/define/instance_definable_spec.rb

@@ -0,0 +1,55 @@
+require "date"
+require "spec_helper"
+
+module Garden
+  module DefinePlantBetween
+    def self.call(plant, plant_range)
+      plant.start_planting_on = plant_range.begin
+      plant.end_planting_on = plant_range.end
+    end
+  end
+
+  class Vegetable
+    attr_accessor :name, :start_planting_on, :end_planting_on
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions :name, plant_between: DefinePlantBetween
+
+    # definition added later:
+    attr_accessor :height
+  end
+end
+
+describe GraphQL::Define::InstanceDefinable do
+  describe "extending definitions" do
+    before do
+      Garden::Vegetable.accepts_definitions(:height)
+    end
+
+    after do
+      Garden::Vegetable.own_dictionary.delete(:height)
+    end
+
+    it "accepts after-the-fact definitions" do
+      corn = Garden::Vegetable.define do
+        name "Corn"
+        height 8
+      end
+
+      assert_equal "Corn", corn.name
+      assert_equal 8, corn.height
+    end
+  end
+
+  describe "applying custom definitions" do
+    it "uses custom callables" do
+      tomato = Garden::Vegetable.define do
+        name "Tomato"
+        plant_between Date.new(2000, 4, 20)..Date.new(2000, 6, 1)
+      end
+
+      assert_equal "Tomato", tomato.name
+      assert_equal Date.new(2000, 4, 20), tomato.start_planting_on
+      assert_equal Date.new(2000, 6, 1), tomato.end_planting_on
+    end
+  end
+end