graphql 1.8.2 → 1.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cbf4bc1aa62d7f5ea7cec15027db39ca2162fe1
-  data.tar.gz: f622a8c446b557fb4fcdfb50e8868a808cb0b94b
+  metadata.gz: 9b0ed1ae533e9983c59332bf6ad38dd5db6e2c92
+  data.tar.gz: 928cd4a961b87fdc43ffe2b71bfd34cea0ae0349
 SHA512:
-  metadata.gz: '0948dbb7c4dca8399a2c20a5e59bd823223c0662fb687e6062cdeb76709f0f5ad097bd6d0e77425d19125ddbd0ed4a1ba3ee88a3f5da61f2eae1a4dd34d8e7d7'
-  data.tar.gz: 409291f67651736ac996e6971b53fea7aa854983a69ad89887e6d71b68cef3550022317f83f268e23f83242c8e13ad71e65e5658da99aefa2e09c0c485ebda70
+  metadata.gz: 1f35a05c996558a3742b79e71e89bb83b5dbc41d432e42d6dd06a9a00c3a616c5d0cb1bd23d80b48b66dff52285866ce614d781fd6abe6c61f64df57f3fa41ce
+  data.tar.gz: 6d3fba06e769adf32bd38f450c5d0d7b21f462e8b93160663c1f1c5f9731e1bf27985b25b20b850e9335be114dc28298f9a6dafd323ffb4d2b5640ae33906f80

data/lib/generators/graphql/templates/interface.erb

@@ -1,3 +1,4 @@
-class <%= type_ruby_name %> < Types::BaseInterface
+module <%= type_ruby_name %>
+  include Types::BaseInterface
 <% normalized_fields.each do |f| %>  <%= f.to_ruby %>
 <% end %>end

data/lib/graphql.rb

@@ -59,11 +59,7 @@ require "graphql/type_kinds"
 
 require "graphql/backwards_compatibility"
 require "graphql/scalar_type"
-require "graphql/boolean_type"
-require "graphql/float_type"
-require "graphql/id_type"
-require "graphql/int_type"
-require "graphql/string_type"
+
 require "graphql/directive"
 require "graphql/name_validator"
 
@@ -73,6 +69,12 @@ require "graphql/tracing"
 require "graphql/execution"
 require "graphql/relay"
 require "graphql/schema"
+require "graphql/boolean_type"
+require "graphql/float_type"
+require "graphql/id_type"
+require "graphql/int_type"
+require "graphql/string_type"
+require "graphql/schema/built_in_types"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
 require "graphql/introspection"

data/lib/graphql/base_type.rb

@@ -114,6 +114,7 @@ module GraphQL
     end
 
     alias :inspect :to_s
+    alias :to_type_signature :to_s
 
     def valid_isolated_input?(value)
       valid_input?(value, GraphQL::Query::NullContext)

data/lib/graphql/boolean_type.rb

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
-GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
-  name "Boolean"
-  description "Represents `true` or `false` values."
-
-  coerce_input ->(value, _ctx) { (value == true || value == false) ? value : nil }
-  coerce_result ->(value, _ctx) { !!value }
-  default_scalar true
-end
+require "graphql/types/boolean"
+GraphQL::BOOLEAN_TYPE = GraphQL::Types::Boolean.graphql_definition

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -137,7 +137,19 @@ module GraphQL
             assert_equal 'if', type.arguments[0].name
             assert_equal 'Boolean', type.arguments[0].type.of_type.name
 
-            assert_equal ['FIELD', 'FRAGMENT_SPREAD', 'INLINE_FRAGMENT'], type.locations
+            assert_equal 3, type.locations.length
+
+            assert_instance_of GraphQL::Language::Nodes::DirectiveLocation, type.locations[0]
+            assert_equal 'FIELD', type.locations[0].name
+            assert_equal [3, 20], type.locations[0].position
+
+            assert_instance_of GraphQL::Language::Nodes::DirectiveLocation, type.locations[1]
+            assert_equal 'FRAGMENT_SPREAD', type.locations[1].name
+            assert_equal [4, 19], type.locations[1].position
+
+            assert_instance_of GraphQL::Language::Nodes::DirectiveLocation, type.locations[2]
+            assert_equal 'INLINE_FRAGMENT', type.locations[2].name
+            assert_equal [5, 19], type.locations[2].position
           end
 
           def test_it_parses_field_arguments

data/lib/graphql/float_type.rb

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
-GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
-  name "Float"
-  description "Represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point)."
-
-  coerce_input ->(value, _ctx) { value.is_a?(Numeric) ? value.to_f : nil }
-  coerce_result ->(value, _ctx) { value.to_f }
-  default_scalar true
-end
+require "graphql/types/float"
+GraphQL::FLOAT_TYPE = GraphQL::Types::Float.graphql_definition

data/lib/graphql/id_type.rb

@@ -1,16 +1,3 @@
 # frozen_string_literal: true
-GraphQL::ID_TYPE = GraphQL::ScalarType.define do
-  name "ID"
-  description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."
-
-  coerce_result ->(value, _ctx) { value.to_s }
-  coerce_input ->(value, _ctx) {
-    case value
-    when String, Integer
-      value.to_s
-    else
-      nil
-    end
-  }
-  default_scalar true
-end
+require "graphql/types/id"
+GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition

data/lib/graphql/int_type.rb

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
-GraphQL::INT_TYPE = GraphQL::ScalarType.define do
-  name "Int"
-  description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."
-
-  coerce_input ->(value, _ctx) { value.is_a?(Numeric) ? value.to_i : nil }
-  coerce_result ->(value, _ctx) { value.to_i }
-  default_scalar true
-end
+require "graphql/types/int"
+GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition

data/lib/graphql/interface_type.rb

@@ -64,5 +64,23 @@ module GraphQL
     def all_fields
       fields.values
     end
+
+    # Get a possible type of this {InterfaceType} by type name
+    # @param type_name [String]
+    # @param ctx [GraphQL::Query::Context] The context for the current query
+    # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and implements this {InterfaceType}, (else `nil`)
+    def get_possible_type(type_name, ctx)
+      type = ctx.query.get_type(type_name)
+      type if type && ctx.query.schema.possible_types(self).include?(type)
+    end
+
+    # Check if a type is a possible type of this {InterfaceType}
+    # @param type [String, GraphQL::BaseType] Name of the type or a type definition
+    # @param ctx [GraphQL::Query::Context] The context for the current query
+    # @return [Boolean] True if the `type` exists and is a member of this {InterfaceType}, (else `nil`)
+    def possible_type?(type, ctx)
+      type_name = type.is_a?(String) ? type : type.graphql_name
+      !get_possible_type(type_name, ctx).nil?
+    end
   end
 end

data/lib/graphql/language/document_from_schema_definition.rb

@@ -149,11 +149,21 @@ module GraphQL
         GraphQL::Language::Nodes::DirectiveDefinition.new(
           name: directive.name,
           arguments: build_argument_nodes(warden.arguments(directive)),
-          locations: directive.locations.map(&:to_s),
+          locations: build_directive_location_nodes(directive.locations),
           description: directive.description,
         )
       end
 
+      def build_directive_location_nodes(locations)
+        locations.map { |location| build_directive_location_node(location) }
+      end
+
+      def build_directive_location_node(location)
+        GraphQL::Language::Nodes::DirectiveLocation.new(
+          name: location.to_s
+        )
+      end
+
       def build_type_name_node(type)
         case type
         when GraphQL::ListType

data/lib/graphql/language/nodes.rb

@@ -144,6 +144,8 @@ module GraphQL
         end
       end
 
+      class DirectiveLocation < NameOnlyNode; end
+
       # This is the AST root for normal queries
       #
       # @example Deriving a document by parsing a string
@@ -537,7 +539,6 @@ module GraphQL
         include Scalars::Name
 
         attr_accessor :name, :fields, :directives, :description
-        alias :children :fields
 
         def initialize_node(name:, fields:, directives: [], description: nil)
           @name = name
@@ -545,6 +546,10 @@ module GraphQL
           @directives = directives
           @description = description
         end
+
+        def children
+          fields + directives
+        end
       end
     end
   end

data/lib/graphql/language/parser.rb

@@ -1697,14 +1697,14 @@ module_eval(<<'.,.,', 'parser.y', 365)
 
 module_eval(<<'.,.,', 'parser.y', 369)
   def _reduce_147(val, _values, result)
-     return [val[0].to_s] 
+     return [make_node(:DirectiveLocation, name: val[0].to_s, position_source: val[0])] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 370)
   def _reduce_148(val, _values, result)
-     val[0] << val[2].to_s 
+     val[0] << make_node(:DirectiveLocation, name: val[2].to_s, position_source: val[2]) 
     result
   end
 .,.,

data/lib/graphql/language/parser.y

@@ -367,8 +367,8 @@ rule
       }
 
   directive_locations:
-      name                          { return [val[0].to_s] }
-    | directive_locations PIPE name { val[0] << val[2].to_s }
+      name                          { return [make_node(:DirectiveLocation, name: val[0].to_s, position_source: val[0])] }
+    | directive_locations PIPE name { val[0] << make_node(:DirectiveLocation, name: val[2].to_s, position_source: val[2]) }
 end
 
 ---- header ----

data/lib/graphql/language/printer.rb

@@ -247,7 +247,7 @@ module GraphQL
           out << print_arguments(directive.arguments)
         end
 
-        out << " on #{directive.locations.join(' | ')}"
+        out << " on #{directive.locations.map(&:name).join(' | ')}"
       end
 
       def print_description(node, indent: "", first_in_block: true)

data/lib/graphql/list_type.rb

@@ -40,6 +40,7 @@ module GraphQL
       "[#{of_type.to_s}]"
     end
     alias_method :inspect, :to_s
+    alias :to_type_signature :to_s
 
     def coerce_result(value, ctx = nil)
       if ctx.nil?

data/lib/graphql/non_null_type.rb

@@ -72,6 +72,7 @@ module GraphQL
       "#{of_type.to_s}!"
     end
     alias_method :inspect, :to_s
+    alias :to_type_signature :to_s
 
     def non_null?
       true

data/lib/graphql/relay/connection_instrumentation.rb

@@ -7,21 +7,25 @@ module GraphQL
     # The original resolve proc is used to fetch nodes,
     # then a connection implementation is fetched with {BaseConnection.connection_for_nodes}.
     module ConnectionInstrumentation
-      ARGUMENT_DEFINITIONS = [
-          ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
-          ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified global ID."],
-          ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
-          ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified global ID."],
-        ]
+      def self.default_arguments
+        @default_arguments ||= begin
+          argument_definitions = [
+              ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+            ]
 
-      DEFAULT_ARGUMENTS = ARGUMENT_DEFINITIONS.reduce({}) do |memo, arg_defn|
-        argument = GraphQL::Argument.new
-        name, type, description = arg_defn
-        argument.name = name
-        argument.type = type
-        argument.description = description
-        memo[argument.name.to_s] = argument
-        memo
+          argument_definitions.reduce({}) do |memo, arg_defn|
+            argument = GraphQL::Argument.new
+            name, type, description = arg_defn
+            argument.name = name
+            argument.type = type
+            argument.description = description
+            memo[argument.name.to_s] = argument
+            memo
+          end
+        end
       end
 
       # Build a connection field from a {GraphQL::Field} by:
@@ -29,7 +33,7 @@ module GraphQL
       # - Transforming its resolve function to return a connection object
       def self.instrument(type, field)
         if field.connection?
-          connection_arguments = DEFAULT_ARGUMENTS.merge(field.arguments)
+          connection_arguments = default_arguments.merge(field.arguments)
           original_resolve = field.resolve_proc
           original_lazy_resolve = field.lazy_resolve_proc
           connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve, lazy: false)

data/lib/graphql/relay/node.rb

@@ -11,7 +11,7 @@ module GraphQL
         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.")
+          argument(:id, types.ID.to_non_null_type, "ID of the object.")
           resolve(GraphQL::Relay::Node::FindNode)
           relay_node_field(true)
         end
@@ -27,7 +27,7 @@ module GraphQL
         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[!types.ID], "IDs of the objects.")
+          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
@@ -44,7 +44,7 @@ module GraphQL
         @interface ||= GraphQL::InterfaceType.define do
           name("Node")
           description("An object with an ID.")
-          field(:id, !types.ID, "ID of the object.")
+          field(:id, types.ID.to_non_null_type, "ID of the object.")
           default_relay(true)
         end
       end

data/lib/graphql/schema.rb

@@ -134,7 +134,6 @@ module GraphQL
 
     self.default_execution_strategy = GraphQL::Execution::Execute
 
-    BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
     DIRECTIVES = [GraphQL::Directive::IncludeDirective, GraphQL::Directive::SkipDirective, GraphQL::Directive::DeprecatedDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 

data/lib/graphql/schema/build_from_definition.rb

@@ -251,7 +251,7 @@ module GraphQL
             name: directive_definition.name,
             description: directive_definition.description,
             arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
-            locations: directive_definition.locations.map(&:to_sym),
+            locations: directive_definition.locations.map { |location| location.name.to_sym },
           )
 
           directive.ast_node = directive_definition

data/lib/graphql/schema/built_in_types.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    BUILT_IN_TYPES = {
+      "Int" => INT_TYPE,
+      "String" => STRING_TYPE,
+      "Float" => FLOAT_TYPE,
+      "Boolean" => BOOLEAN_TYPE,
+      "ID" => ID_TYPE,
+    }
+  end
+end

data/lib/graphql/schema/field.rb

@@ -242,8 +242,8 @@ module GraphQL
           # TODO: this could be a bit weird, because these fields won't be present
           # after initialization, only in the `to_graphql` response.
           # This calculation _could_ be moved up if need be.
-          argument :after, "String", "Returns the elements in the list that come after the specified global ID.", required: false
-          argument :before, "String", "Returns the elements in the list that come before the specified global ID.", required: false
+          argument :after, "String", "Returns the elements in the list that come after the specified cursor.", required: false
+          argument :before, "String", "Returns the elements in the list that come before the specified cursor.", required: false
           argument :first, "Int", "Returns the first _n_ elements from the list.", required: false
           argument :last, "Int", "Returns the last _n_ elements from the list.", required: false
         end

data/lib/graphql/schema/list.rb

@@ -27,6 +27,14 @@ module GraphQL
       def unwrap
         @of_type.unwrap
       end
+
+      def list?
+        true
+      end
+
+      def to_type_signature
+        "[#{@of_type.to_type_signature}]"
+      end
     end
   end
 end

data/lib/graphql/schema/member/build_type.rb

@@ -16,15 +16,15 @@ module GraphQL
           when String
             case type_expr
             when "String"
-              GraphQL::STRING_TYPE
+              GraphQL::Types::String
             when "Int", "Integer"
-              GraphQL::INT_TYPE
+              GraphQL::Types::Int
             when "Float"
-              GraphQL::FLOAT_TYPE
+              GraphQL::Types::Float
             when "Boolean"
-              GraphQL::BOOLEAN_TYPE
+              GraphQL::Types::Boolean
             when "ID"
-              GraphQL::ID_TYPE
+              GraphQL::Types::ID
             when /\A\[.*\]\Z/
               list_type = true
               # List members are required by default

data/lib/graphql/schema/member/type_system_helpers.rb

@@ -24,6 +24,10 @@ module GraphQL
           false
         end
 
+        def to_type_signature
+          graphql_name
+        end
+
         # @return [GraphQL::TypeKinds::TypeKind]
         def kind
           raise NotImplementedError

data/lib/graphql/schema/non_null.rb

@@ -33,6 +33,10 @@ module GraphQL
       def unwrap
         @of_type.unwrap
       end
+
+      def to_type_signature
+        "#{@of_type.to_type_signature}!"
+      end
     end
   end
 end

data/lib/graphql/schema/scalar.rb

@@ -23,12 +23,20 @@ module GraphQL
           type_defn.coerce_result = method(:coerce_result)
           type_defn.coerce_input = method(:coerce_input)
           type_defn.metadata[:type_class] = self
+          type_defn.default_scalar = default_scalar
           type_defn
         end
 
         def kind
           GraphQL::TypeKinds::SCALAR
         end
+
+        def default_scalar(is_default = nil)
+          if !is_default.nil?
+            @default_scalar = is_default
+          end
+          @default_scalar
+        end
       end
     end
   end

data/lib/graphql/schema/timeout_middleware.rb

@@ -34,7 +34,7 @@ module GraphQL
       end
 
       def call(parent_type, parent_object, field_definition, field_args, query_context)
-        ns = query_context.namespace(TimeoutMiddleware)
+        ns = query_context.namespace(self.class)
         timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
 
         if timeout_at < Time.now

data/lib/graphql/string_type.rb

@@ -1,18 +1,3 @@
 # frozen_string_literal: true
-GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
-  name "String"
-  description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
-
-  coerce_result ->(value, ctx) {
-    begin
-      str = value.to_s
-      str.encoding == Encoding::UTF_8 ? str : str.encode(Encoding::UTF_8)
-    rescue EncodingError
-      err = GraphQL::StringEncodingError.new(str)
-      ctx.schema.type_error(err, ctx)
-    end
-  }
-
-  coerce_input ->(value, _ctx) { value.is_a?(String) ? value : nil }
-  default_scalar true
-end
+require "graphql/types/string"
+GraphQL::STRING_TYPE = GraphQL::Types::String.graphql_definition

data/lib/graphql/types/boolean.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    class Boolean < GraphQL::Schema::Scalar
+      description "Represents `true` or `false` values."
+
+      def self.coerce_input(value, _ctx)
+        (value == true || value == false) ? value : nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        !!value
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types/float.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class Float < GraphQL::Schema::Scalar
+      description "Represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point)."
+
+      def self.coerce_input(value, _ctx)
+        value.is_a?(Numeric) ? value.to_f : nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        value.to_f
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types/id.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    class ID < GraphQL::Schema::Scalar
+      graphql_name "ID"
+      description "Represents a unique identifier that is Base64 obfuscated. It is often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `\"VXNlci0xMA==\"`) or integer (such as `4`) input value will be accepted as an ID."
+      default_scalar true
+      def self.coerce_result(value, _ctx)
+        value.is_a?(::String) ? value : value.to_s
+      end
+
+      def self.coerce_input(value, _ctx)
+        case value
+        when ::String
+          value
+        when Integer
+          value.to_s
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/int.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class Int < GraphQL::Schema::Scalar
+      description "Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1."
+
+      def self.coerce_input(value, _ctx)
+        value.is_a?(Numeric) ? value.to_i : nil
+      end
+
+      def self.coerce_result(value, _ctx)
+        value.to_i
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    # This scalar takes `DateTime`s and transmits them as strings,
+    # using ISO 8601 format.
+    #
+    # To use it, require it in your project:
+    #
+    #     require "graphql/types/iso_8601_date_time"
+    #
+    # Then use it for fields or arguments:
+    #
+    #     field :created_at, GraphQL::Types::ISO8601DateTime, null: false
+    #
+    #     argument :deliver_at, GraphQL::Types::ISO8601DateTime, null: false
+    #
+    # Alternatively, use this built-in scalar as inspiration for your
+    # own DateTime type.
+    class ISO8601DateTime < GraphQL::Schema::Scalar
+      description "An ISO 8601-encoded datetime"
+
+      # @param value [DateTime]
+      # @return [String]
+      def self.coerce_result(value, _ctx)
+        value.iso8601
+      end
+
+      # @param str_value [String]
+      # @return [DateTime]
+      def self.coerce_input(str_value, _ctx)
+        DateTime.iso8601(str_value)
+      rescue ArgumentError
+        # Invalid input
+        nil
+      end
+    end
+  end
+end

data/lib/graphql/types/string.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class String < GraphQL::Schema::Scalar
+      description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
+
+      def self.coerce_result(value, ctx)
+        str = value.to_s
+        str.encoding == Encoding::UTF_8 ? str : str.encode(Encoding::UTF_8)
+      rescue EncodingError
+        err = GraphQL::StringEncodingError.new(str)
+        ctx.schema.type_error(err, ctx)
+      end
+
+      def self.coerce_input(value, _ctx)
+        value.is_a?(::String) ? value : nil
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/union_type.rb

@@ -67,6 +67,24 @@ module GraphQL
       end
     end
 
+    # Get a possible type of this {UnionType} by type name
+    # @param type_name [String]
+    # @param ctx [GraphQL::Query::Context] The context for the current query
+    # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and is a member of this {UnionType}, (else `nil`)
+    def get_possible_type(type_name, ctx)
+      type = ctx.query.get_type(type_name)
+      type if type && ctx.query.schema.possible_types(self).include?(type)
+    end
+
+    # Check if a type is a possible type of this {UnionType}
+    # @param type [String, GraphQL::BaseType] Name of the type or a type definition
+    # @param ctx [GraphQL::Query::Context] The context for the current query
+    # @return [Boolean] True if the `type` exists and is a member of this {UnionType}, (else `nil`)
+    def possible_type?(type, ctx)
+      type_name = type.is_a?(String) ? type : type.graphql_name
+      !get_possible_type(type_name, ctx).nil?
+    end
+
     def resolve_type(value, ctx)
       ctx.query.resolve_type(self, value)
     end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.2"
+  VERSION = "1.8.3"
 end

data/spec/generators/graphql/interface_generator_spec.rb

@@ -16,7 +16,8 @@ class GraphQLGeneratorsInterfaceGeneratorTest < BaseGeneratorTest
     ]
 
     expected_content = <<-RUBY
-class Types::BirdType < Types::BaseInterface
+module Types::BirdType
+  include Types::BaseInterface
   field :wingspan, Integer, null: false
   field :foliage, [Types::ColorType], null: true
 end

data/spec/graphql/interface_type_spec.rb

@@ -149,4 +149,48 @@ describe GraphQL::InterfaceType do
       assert_equal expected_result, result["data"]
     end
   end
+
+  describe "#get_possible_type" do
+    let(:query_string) {%|
+      query fav {
+        favoriteEdible { fatContent }
+      }
+    |}
+
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
+
+    it "returns the type definition if the type exists and is a possible type of the interface" do
+      assert interface.get_possible_type("Cheese", query.context)
+    end
+
+    it "returns nil if the type is not found in the schema" do
+      assert_nil interface.get_possible_type("Foo", query.context)
+    end
+
+    it "returns nil if the type is not a possible type of the interface" do
+      assert_nil interface.get_possible_type("Beverage", query.context)
+    end
+  end
+
+  describe "#possible_type?" do
+    let(:query_string) {%|
+      query fav {
+        favoriteEdible { fatContent }
+      }
+    |}
+
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
+
+    it "returns true if the type exists and is a possible type of the interface" do
+      assert interface.possible_type?("Cheese", query.context)
+    end
+
+    it "returns false if the type is not found in the schema" do
+      refute interface.possible_type?("Foo", query.context)
+    end
+
+    it "returns false if the type is not a possible type of the interface" do
+      refute interface.possible_type?("Beverage", query.context)
+    end
+  end
 end

data/spec/graphql/language/visitor_spec.rb

@@ -40,6 +40,31 @@ describe GraphQL::Language::Visitor do
     assert(counts[:finished])
   end
 
+  it "can visit a document with directive definitions" do
+    document = GraphQL.parse("
+      # Marks an element of a GraphQL schema as only available via a preview header
+      directive @preview(
+        # The identifier of the API preview that toggles this field.
+        toggledBy: String
+      ) on SCALAR | OBJECT | FIELD_DEFINITION | ARGUMENT_DEFINITION | INTERFACE | UNION | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+
+      type Query {
+        hello: String
+      }
+    ")
+
+    directive = nil
+    directive_locations = []
+
+    v = GraphQL::Language::Visitor.new(document)
+    v[GraphQL::Language::Nodes::DirectiveDefinition] << ->(node, parent) { directive = node }
+    v[GraphQL::Language::Nodes::DirectiveLocation] << ->(node, parent) { directive_locations << node }
+    v.visit
+
+    assert_equal "preview", directive.name
+    assert_equal 10, directive_locations.length
+  end
+
   describe "Visitor::SKIP" do
     it "skips the rest of the node" do
       visitor[GraphQL::Language::Nodes::Document] << ->(node, parent) { GraphQL::Language::Visitor::SKIP }
@@ -47,4 +72,23 @@ describe GraphQL::Language::Visitor do
       assert_equal(0, counts[:fields_entered])
     end
   end
+
+  it "can visit InputObjectTypeDefinition directives" do
+    schema_sdl = <<-GRAPHQL
+    input Test @directive {
+      id: ID!
+    }
+    GRAPHQL
+
+    document = GraphQL.parse(schema_sdl)
+
+    visitor = GraphQL::Language::Visitor.new(document)
+
+    visited_directive = false
+    visitor[GraphQL::Language::Nodes::Directive] << ->(node, parent) { visited_directive = true }
+
+    visitor.visit
+
+    assert visited_directive
+  end
 end

data/spec/graphql/schema/argument_spec.rb

@@ -40,7 +40,7 @@ describe GraphQL::Schema::Argument do
   describe "#type" do
     let(:argument) { SchemaArgumentTest::Query.fields["field"].arguments["arg"] }
     it "returns the type" do
-      assert_equal GraphQL::STRING_TYPE, argument.type
+      assert_equal GraphQL::Types::String, argument.type
     end
   end
 

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -281,10 +281,10 @@ type Type {
 
   # A list of organizations the user belongs to.
   organizations(
-    # Returns the elements in the list that come after the specified global ID.
+    # Returns the elements in the list that come after the specified cursor.
     after: String
 
-    # Returns the elements in the list that come before the specified global ID.
+    # Returns the elements in the list that come before the specified cursor.
     before: String
 
     # Returns the first _n_ elements from the list.

data/spec/graphql/schema/input_object_spec.rb

@@ -28,7 +28,7 @@ describe GraphQL::Schema::InputObject do
 
       assert_equal 3, subclass.arguments.size
       assert_equal ["arg1", "arg2", "arg3"], subclass.arguments.keys
-      assert_equal ["String!", "Int!", "Int!"], subclass.arguments.values.map { |a| a.type.to_s }
+      assert_equal ["String!", "Int!", "Int!"], subclass.arguments.values.map { |a| a.type.to_type_signature }
     end
   end
 

data/spec/graphql/types/iso_8601_date_time_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "graphql/types/iso_8601_date_time"
+describe GraphQL::Types::ISO8601DateTime do
+  module DateTimeTest
+    class DateTimeObject < GraphQL::Schema::Object
+      field :year, Integer, null: false
+      field :month, Integer, null: false
+      field :day, Integer, null: false
+      field :hour, Integer, null: false
+      field :minute, Integer, null: false
+      field :second, Integer, null: false
+      field :zone, String, null: false
+      # Use method: :object so that the DateTime instance is passed to the scalar
+      field :iso8601, GraphQL::Types::ISO8601DateTime, null: false, method: :object
+    end
+
+    class Query < GraphQL::Schema::Object
+      field :parse_date, DateTimeObject, null: true do
+        argument :date, GraphQL::Types::ISO8601DateTime, required: true
+      end
+
+      def parse_date(date:)
+        # Date is parsed by the scalar, so it's already a DateTime
+        date
+      end
+    end
+
+
+    class Schema < GraphQL::Schema
+      query(Query)
+    end
+  end
+
+
+  describe "as an input" do
+
+    def parse_date(date_str)
+      query_str = <<-GRAPHQL
+      query($date: ISO8601DateTime!){
+        parseDate(date: $date) {
+          year
+          month
+          day
+          hour
+          minute
+          second
+          zone
+        }
+      }
+      GRAPHQL
+      full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
+      full_res["errors"] || full_res["data"]["parseDate"]
+    end
+
+    it "parses valid dates" do
+      res = parse_date("2018-06-07T09:31:42-07:00")
+      expected_res = {
+        "year" => 2018,
+        "month" => 6,
+        "day" => 7,
+        "hour" => 9,
+        "minute" => 31,
+        "second" => 42,
+        "zone" => "-07:00",
+      }
+      assert_equal(expected_res, res)
+    end
+
+    it "adds an error for invalid dates" do
+      expected_errors = ["Variable date of type ISO8601DateTime! was provided invalid value"]
+
+      assert_equal expected_errors, parse_date("2018-06-07T99:31:42-07:00").map { |e| e["message"] }
+      assert_equal expected_errors, parse_date("xyz").map { |e| e["message"] }
+      assert_equal expected_errors, parse_date(nil).map { |e| e["message"] }
+    end
+  end
+
+  describe "as an output" do
+    it "returns a string" do
+      query_str = <<-GRAPHQL
+      query($date: ISO8601DateTime!){
+        parseDate(date: $date) {
+          iso8601
+        }
+      }
+      GRAPHQL
+
+      date_str = "2010-02-02T22:30:30-06:00"
+      full_res = DateTimeTest::Schema.execute(query_str, variables: { date: date_str })
+      assert_equal date_str, full_res["data"]["parseDate"]["iso8601"]
+    end
+  end
+
+  describe "structure" do
+    it "is in introspection" do
+      introspection_res = DateTimeTest::Schema.execute <<-GRAPHQL
+      {
+        __type(name: "ISO8601DateTime") {
+          name
+          kind
+        }
+      }
+      GRAPHQL
+
+      expected_res = { "name" => "ISO8601DateTime", "kind" => "SCALAR"}
+      assert_equal expected_res, introspection_res["data"]["__type"]
+    end
+  end
+end

data/spec/graphql/union_type_spec.rb

@@ -158,4 +158,54 @@ describe GraphQL::UnionType do
       assert_equal 3, union_2.possible_types.size
     end
   end
+
+  describe "#get_possible_type" do
+    let(:query_string) {%|
+      {
+        __type(name: "Beverage") {
+          name
+        }
+      }
+    |}
+
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
+    let(:union) { Dummy::BeverageUnion }
+
+    it "returns the type definition if the type exists and is a possible type of the union" do
+      assert union.get_possible_type("Milk", query.context)
+    end
+
+    it "returns nil if the type is not found in the schema" do
+      assert_nil union.get_possible_type("Foo", query.context)
+    end
+
+    it "returns nil if the type is not a possible type of the union" do
+      assert_nil union.get_possible_type("Cheese", query.context)
+    end
+  end
+
+  describe "#possible_type?" do
+    let(:query_string) {%|
+      {
+        __type(name: "Beverage") {
+          name
+        }
+      }
+    |}
+
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
+    let(:union) { Dummy::BeverageUnion }
+
+    it "returns true if the type exists and is a possible type of the union" do
+      assert union.possible_type?("Milk", query.context)
+    end
+
+    it "returns false if the type is not found in the schema" do
+      refute union.possible_type?("Foo", query.context)
+    end
+
+    it "returns false if the type is not a possible type of the union" do
+      refute union.possible_type?("Cheese", query.context)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.8.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-06 00:00:00.000000000 Z
+date: 2018-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -494,6 +494,7 @@ files:
 - lib/graphql/schema/build_from_definition.rb
 - lib/graphql/schema/build_from_definition/resolve_map.rb
 - lib/graphql/schema/build_from_definition/resolve_map/default_resolve.rb
+- lib/graphql/schema/built_in_types.rb
 - lib/graphql/schema/catchall_middleware.rb
 - lib/graphql/schema/default_parse_error.rb
 - lib/graphql/schema/default_type_error.rb
@@ -587,6 +588,12 @@ files:
 - lib/graphql/tracing/scout_tracing.rb
 - lib/graphql/tracing/skylight_tracing.rb
 - lib/graphql/type_kinds.rb
+- lib/graphql/types/boolean.rb
+- lib/graphql/types/float.rb
+- lib/graphql/types/id.rb
+- lib/graphql/types/int.rb
+- lib/graphql/types/iso_8601_date_time.rb
+- lib/graphql/types/string.rb
 - lib/graphql/union_type.rb
 - lib/graphql/unresolved_type_error.rb
 - lib/graphql/upgrader/member.rb
@@ -1094,6 +1101,7 @@ files:
 - spec/graphql/tracing/platform_tracing_spec.rb
 - spec/graphql/tracing/scout_tracing_spec.rb
 - spec/graphql/tracing_spec.rb
+- spec/graphql/types/iso_8601_date_time_spec.rb
 - spec/graphql/union_type_spec.rb
 - spec/graphql/upgrader/member_spec.rb
 - spec/graphql/upgrader/schema_spec.rb
@@ -1641,6 +1649,7 @@ test_files:
 - spec/graphql/tracing/platform_tracing_spec.rb
 - spec/graphql/tracing/scout_tracing_spec.rb
 - spec/graphql/tracing_spec.rb
+- spec/graphql/types/iso_8601_date_time_spec.rb
 - spec/graphql/union_type_spec.rb
 - spec/graphql/upgrader/member_spec.rb
 - spec/graphql/upgrader/schema_spec.rb