graphql 0.19.0 → 0.19.1

data/lib/graphql/language/parser.y

@@ -126,6 +126,7 @@ rule
     | UNION
     | ENUM
     | INPUT
+    | DIRECTIVE
 
   name_without_on:
       IDENTIFIER

data/lib/graphql/language/parser_tests.rb

@@ -33,7 +33,7 @@ module GraphQL
             }
 
             fragment moreNestedFields on NestedType @or(something: "ok") {
-              anotherNestedField
+              anotherNestedField @enum(directive: true)
             }
           |}
 

data/lib/graphql/object_type.rb

@@ -74,26 +74,5 @@ module GraphQL
         memo.merge!(iface.fields)
       end
     end
-
-
-    # Error raised when the value provided for a field can't be resolved to one of the possible types
-    # for the field.
-    class UnresolvedTypeError < GraphQL::Error
-      attr_reader :field_name, :field_type, :parent_type
-
-      def initialize(field_name, field_type, parent_type)
-        @field_name = field_name
-        @field_type = field_type
-        @parent_type = parent_type
-        super(exception_message)
-      end
-
-      private
-
-      def exception_message
-        "The value returned for field #{field_name} on #{parent_type} could not be resolved "\
-        "to one of the possible types for #{field_type}."
-      end
-    end
   end
 end

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

@@ -57,12 +57,11 @@ module GraphQL
 
         class HasPossibleTypeResolution < BaseResolution
           def non_null_result
-            # When deprecations are removed:
-            # resolved_type = execution_context.schema.resolve_type(value)
-            resolved_type = field_type.legacy_resolve_type(value, execution_context)
+            resolved_type = execution_context.schema.resolve_type(value, execution_context.query.context)
+            possible_types = execution_context.schema.possible_types(field_type)
 
-            unless resolved_type.is_a?(GraphQL::ObjectType)
-              raise GraphQL::ObjectType::UnresolvedTypeError.new(irep_node.definition_name, field_type, parent_type)
+            unless resolved_type.is_a?(GraphQL::ObjectType) && possible_types.include?(resolved_type)
+              raise GraphQL::UnresolvedTypeError.new(irep_node.definition_name, execution_context.schema, field_type, parent_type, resolved_type)
             end
 
             strategy_class = get_strategy_for_kind(resolved_type.kind)
@@ -87,7 +86,7 @@ module GraphQL
           # Get the "wrapped" type and resolve the value according to that type
           def result
             if value.nil? || value.is_a?(GraphQL::ExecutionError)
-              raise GraphQL::InvalidNullError.new(irep_node.definition_name, value)
+              raise GraphQL::InvalidNullError.new(parent_type.name, irep_node.definition_name, value)
             else
               wrapped_type = field_type.of_type
               strategy_class = get_strategy_for_kind(wrapped_type.kind)

data/lib/graphql/relay/node.rb

@@ -7,12 +7,17 @@ module GraphQL
         # We have to define it fresh each time because
         # its name will be modified and its description
         # _may_ be modified.
-        GraphQL::Field.define do
+        node_field = GraphQL::Field.define do
           type(GraphQL::Relay::Node.interface)
           description("Fetches an object given its ID")
           argument(:id, !types.ID, "ID of the object")
           resolve(GraphQL::Relay::Node::FindNode)
         end
+
+        # This is used to identify generated fields in the schema
+        node_field.metadata[:relay_node_field] = true
+
+        node_field
       end
 
       # @return [GraphQL::InterfaceType] The interface which all Relay types must implement

data/lib/graphql/schema.rb

@@ -63,11 +63,8 @@ module GraphQL
 
     DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective, GraphQL::Directive::DeprecatedDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
-    RESOLVE_TYPE_PROC_REQUIRED = -> (obj, ctx) { raise(NotImplementedError, "Schema.resolve_type is undefined, can't resolve type for #{obj.inspect}") }
-    OBJECT_FROM_ID_PROC_REQUIRED = -> (id, ctx) { raise(NotImplementedError, "Schema.object_from_id is undefined, can't fetch object for #{id.inspect}") }
-    ID_FROM_OBJECT_PROC_REQUIRED = -> (obj, type, ctx) { raise(NotImplementedError, "Schema.id_from_object is undefined, can't return an ID for #{obj.inspect}") }
 
-    attr_reader :directives, :static_validator, :object_from_id_proc, :id_from_object_proc
+    attr_reader :directives, :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
     # @!attribute [r] middleware
     #   @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
@@ -92,9 +89,9 @@ module GraphQL
       @rescue_middleware = GraphQL::Schema::RescueMiddleware.new
       @middleware = [@rescue_middleware]
       @query_analyzers = []
-      @resolve_type_proc = RESOLVE_TYPE_PROC_REQUIRED
-      @object_from_id_proc = OBJECT_FROM_ID_PROC_REQUIRED
-      @id_from_object_proc = ID_FROM_OBJECT_PROC_REQUIRED
+      @resolve_type_proc = nil
+      @object_from_id_proc = nil
+      @id_from_object_proc = nil
       # Default to the built-in execution strategy:
       @query_execution_strategy = GraphQL::Query::SerialExecution
       @mutation_execution_strategy = GraphQL::Query::SerialExecution
@@ -111,6 +108,15 @@ module GraphQL
       @rescue_middleware.remove_handler(*args, &block)
     end
 
+    def define(**kwargs, &block)
+      super
+      types
+      # Assert that all necessary configs are present:
+      validation_error = Validation.validate(self)
+      validation_error && raise(NotImplementedError, validation_error)
+      nil
+    end
+
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
     def types
       @types ||= begin
@@ -193,6 +199,11 @@ module GraphQL
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
     def resolve_type(object, ctx)
       ensure_defined
+
+      if @resolve_type_proc.nil?
+        raise(NotImplementedError, "Can't determine GraphQL type for: #{object.inspect}, define `resolve_type (obj, ctx) -> { ... }` inside `Schema.define`.")
+      end
+
       type_result = @resolve_type_proc.call(object, ctx)
       if type_result.nil?
         nil
@@ -215,7 +226,11 @@ module GraphQL
     # @return [Any] The application object identified by `id`
     def object_from_id(id, ctx)
       ensure_defined
-      @object_from_id_proc.call(id, ctx)
+      if @object_from_id_proc.nil?
+        raise(NotImplementedError, "Can't fetch an object for id \"#{id}\" because the schema's `object_from_id (id, ctx) -> { ... }` function is not defined")
+      else
+        @object_from_id_proc.call(id, ctx)
+      end
     end
 
     # @param new_proc [#call] A new callable for fetching objects by ID
@@ -226,11 +241,16 @@ module GraphQL
 
     # Get a unique identifier from this object
     # @param object [Any] An application object
+    # @param type [GraphQL::BaseType] The current type definition
     # @param ctx [GraphQL::Query::Context] the context for the current query
     # @return [String] a unique identifier for `object` which clients can use to refetch it
-    def id_from_object(type, object, ctx)
+    def id_from_object(object, type, ctx)
       ensure_defined
-      @id_from_object_proc.call(type, object, ctx)
+      if @id_from_object_proc.nil?
+        raise(NotImplementedError, "Can't generate an ID for #{object.inspect} of type #{type}, schema's `id_from_object` must be defined")
+      else
+        @id_from_object_proc.call(object, type, ctx)
+      end
     end
 
     # @param new_proc [#call] A new callable for generating unique IDs

data/lib/graphql/schema/loader.rb

@@ -22,7 +22,7 @@ module GraphQL
           types[type_object.name] = type_object
         end
 
-        kargs = { :orphan_types => types.values }
+        kargs = { orphan_types: types.values, resolve_type: NullResolveType }
         [:query, :mutation, :subscription].each do |root|
           type = schema["#{root}Type"]
           kargs[root] = types.fetch(type.fetch("name")) if type
@@ -31,6 +31,10 @@ module GraphQL
         Schema.define(**kargs)
       end
 
+      NullResolveType = -> (obj, ctx) {
+        raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
+      }
+
       class << self
         private
 

data/lib/graphql/schema/validation.rb

@@ -125,6 +125,32 @@ module GraphQL
             "type must be a valid input type (Scalar or InputObject), not #{outer_type.class} (#{outer_type})"
           end
         }
+
+        SCHEMA_CAN_RESOLVE_TYPES = -> (schema) {
+          if schema.types.values.any? { |type| type.kind.resolves? } && schema.resolve_type_proc.nil?
+            "schema contains Interfaces or Unions, so you must define a `resolve_type (obj, ctx) -> { ... }` function"
+          else
+            # :+1:
+          end
+        }
+
+        SCHEMA_CAN_FETCH_IDS = -> (schema) {
+          has_node_field = schema.query && schema.query.all_fields.any? { |f| f.metadata[:relay_node_field] }
+          if has_node_field && schema.object_from_id_proc.nil?
+            "schema contains `node(id:...)` field, so you must define a `object_from_id (id, ctx) -> { ... }` function"
+          else
+            # :rocket:
+          end
+        }
+
+        SCHEMA_CAN_GENERATE_IDS = -> (schema) {
+          has_id_field = schema.types.values.any? { |t| t.kind.fields? && t.all_fields.any? { |f| f.resolve_proc.is_a?(GraphQL::Relay::GlobalIdResolve) } }
+          if has_id_field && schema.id_from_object_proc.nil?
+            "schema contains `global_id_field`, so you must define a `id_from_object (obj, type, ctx) -> { ... }` function"
+          else
+            # :ok_hand:
+          end
+        }
       end
 
       # A mapping of `{Class => [Proc, Proc...]}` pairs.
@@ -165,6 +191,11 @@ module GraphQL
         GraphQL::InterfaceType => [
           Rules::FIELDS_ARE_VALID,
         ],
+        GraphQL::Schema => [
+          Rules::SCHEMA_CAN_RESOLVE_TYPES,
+          Rules::SCHEMA_CAN_FETCH_IDS,
+          Rules::SCHEMA_CAN_GENERATE_IDS,
+        ],
       }
     end
   end

data/lib/graphql/union_type.rb

@@ -23,7 +23,6 @@ module GraphQL
   #  }
   #
   class UnionType < GraphQL::BaseType
-    include GraphQL::BaseType::HasPossibleTypes
     accepts_definitions :possible_types, :resolve_type
 
     def kind

data/lib/graphql/unresolved_type_error.rb

@@ -0,0 +1,16 @@
+module GraphQL
+  # Error raised when the value provided for a field can't be resolved to one of the possible types
+  # for the field.
+  class UnresolvedTypeError < GraphQL::Error
+    def initialize(field_name, schema, field_type, parent_type, received_type)
+      possible_types = field_type.kind.resolves? ? schema.possible_types(field_type) : [field_type]
+      message = %|The value from "#{field_name}" on "#{parent_type}" could not be resolved to "#{field_type}". (Received: #{received_type.inspect}, Expected: [#{possible_types.map(&:inspect).join(", ")}])|
+      super(message)
+    end
+  end
+
+  class ObjectType
+    # @deprecated Use {GraphQL::UnresolvedTypeError} instead
+    UnresolvedTypeError = GraphQL::UnresolvedTypeError
+  end
+end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.19.0"
+  VERSION = "0.19.1"
 end

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -255,7 +255,11 @@ describe GraphQL::Analysis::QueryComplexity do
         end
       end
 
-      GraphQL::Schema.define(query: query_type, orphan_types: [double_complexity_type])
+      GraphQL::Schema.define(
+        query: query_type,
+        orphan_types: [double_complexity_type],
+        resolve_type: :pass
+      )
     }
     let(:query_string) {%|
       {

data/spec/graphql/define/instance_definable_spec.rb

@@ -62,6 +62,17 @@ describe GraphQL::Define::InstanceDefinable do
     end
   end
 
+  describe "#define" do
+    it "applies new definitions to an object" do
+      okra = Garden::Vegetable.define(name: "Okra", plant_between: Date.new(2000, 5, 1)..Date.new(2000, 7, 1))
+      assert_equal "Okra", okra.name
+      okra.define(name: "Gumbo")
+      assert_equal "Gumbo", okra.name
+      okra.define { name "Okra" }
+      assert_equal "Okra", okra.name
+    end
+  end
+
   describe "#metadata" do
     it "gets values from definitions" do
       arugula = Garden::Vegetable.define(name: "Arugula", color: :green)

data/spec/graphql/field_spec.rb

@@ -88,9 +88,10 @@ describe GraphQL::Field do
       invalid_field.name = :symbol_name
 
       dummy_query.fields["symbol_name"] = invalid_field
-      dummy_schema = GraphQL::Schema.define(query: dummy_query)
 
-      err = assert_raises(GraphQL::Schema::InvalidTypeError) { dummy_schema.types }
+      err = assert_raises(GraphQL::Schema::InvalidTypeError) {
+        GraphQL::Schema.define(query: dummy_query)
+      }
       assert_equal "QueryType is invalid: field :symbol_name name must return String, not Symbol (:symbol_name)", err.message
     end
   end

data/spec/graphql/non_null_type_spec.rb

@@ -6,7 +6,7 @@ describe GraphQL::NonNullType do
       query_string = %|{ cow { name cantBeNullButIs } }|
       result = DummySchema.execute(query_string)
       assert_equal({"cow" => nil }, result["data"])
-      assert_equal([{"message"=>"Cannot return null for non-nullable field cantBeNullButIs"}], result["errors"])
+      assert_equal([{"message"=>"Cannot return null for non-nullable field Cow.cantBeNullButIs"}], result["errors"])
     end
 
     it "propagates the null up to the next nullable field" do
@@ -25,7 +25,7 @@ describe GraphQL::NonNullType do
       |
       result = DummySchema.execute(query_string)
       assert_equal(nil, result["data"])
-      assert_equal([{"message"=>"Cannot return null for non-nullable field nonNullInt"}], result["errors"])
+      assert_equal([{"message"=>"Cannot return null for non-nullable field DeepNonNull.nonNullInt"}], result["errors"])
     end
   end
 end

data/spec/graphql/query/context_spec.rb

@@ -2,6 +2,7 @@ require "spec_helper"
 
 describe GraphQL::Query::Context do
   let(:query_type) { GraphQL::ObjectType.define {
+    name "Query"
     field :context, types.String do
       argument :key, !types.String
       resolve -> (target, args, ctx) { ctx[args[:key]] }

data/spec/graphql/query/executor_spec.rb

@@ -85,7 +85,7 @@ describe GraphQL::Query::Executor do
         end
       end
 
-      GraphQL::Schema.define(query: DummyQueryType, mutation: MutationType)
+      GraphQL::Schema.define(query: DummyQueryType, mutation: MutationType, resolve_type: :pass, id_from_object: :pass)
     }
     let(:variables) { nil }
     let(:query_string) { %|
@@ -127,7 +127,7 @@ describe GraphQL::Query::Executor do
           "data" => { "cow" => nil },
           "errors" => [
             {
-              "message" => "Cannot return null for non-nullable field cantBeNullButIs"
+              "message" => "Cannot return null for non-nullable field Cow.cantBeNullButIs"
             }
           ]
         }

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -18,20 +18,41 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
       field :someField, !types.Int
     end
 
+    some_object = GraphQL::ObjectType.define do
+      name "SomeObject"
+      interfaces [interface]
+    end
+
+    other_object = GraphQL::ObjectType.define do
+      name "OtherObject"
+    end
+
+    OtherObject = Class.new
+
     query_root = GraphQL::ObjectType.define do
       name "Query"
       field :tomorrow, day_of_week_enum do
         argument :today, day_of_week_enum
         resolve ->(obj, args, ctx) { (args["today"] + 1) % 7 }
       end
-      field :misbehavedInterface, interface do
+      field :resolvesToNilInterface, interface do
         resolve ->(obj, args, ctx) { Object.new }
       end
+      field :resolvesToWrongTypeInterface, interface do
+        resolve ->(obj, args, ctx) { OtherObject.new }
+      end
     end
 
     GraphQL::Schema.define do
       query(query_root)
-      resolve_type -> (obj, ctx) { nil }
+      orphan_types [some_object]
+      resolve_type -> (obj, ctx) do
+        if obj.is_a?(OtherObject)
+          other_object
+        else
+          nil
+        end
+      end
     end
   }
 
@@ -57,14 +78,33 @@ describe GraphQL::Query::SerialExecution::ValueResolution do
   end
 
   describe "interface type resolution" do
-    let(:query_string) { %|
-      {
-        misbehavedInterface { someField }
-      }
-    |}
+    describe "when type can't be resolved" do
+      let(:query_string) { %|
+        {
+          resolvesToNilInterface { someField }
+        }
+      |}
 
-    it "raises an error if it cannot resolve the type of an interface" do
-      assert_raises(GraphQL::ObjectType::UnresolvedTypeError) { result }
+      it "raises an error" do
+        err = assert_raises(GraphQL::ObjectType::UnresolvedTypeError) { result }
+        expected_message = %|The value from "resolvesToNilInterface" on "Query" could not be resolved to "SomeInterface". (Received: nil, Expected: [SomeObject])|
+        assert_equal expected_message, err.message
+      end
     end
+
+    describe "when type resolves but is not a possible type of an interface" do
+      let(:query_string) { %|
+        {
+          resolvesToWrongTypeInterface { someField }
+        }
+      |}
+
+      it "raises an error" do
+        err = assert_raises(GraphQL::ObjectType::UnresolvedTypeError) { result }
+        expected_message = %|The value from "resolvesToWrongTypeInterface" on "Query" could not be resolved to "SomeInterface". (Received: OtherObject, Expected: [SomeObject])|
+        assert_equal expected_message, err.message
+      end
+    end
+
   end
 end