graphql 0.18.15 → 0.19.0

data/lib/graphql/language/parser.y

@@ -46,7 +46,7 @@ rule
 
   variable_definitions_opt:
       /* none */                              { return [] }
-    | RPAREN variable_definitions_list LPAREN { return val[1] }
+    | LPAREN variable_definitions_list RPAREN { return val[1] }
 
   variable_definitions_list:
       variable_definition                           { return [val[0]] }
@@ -65,15 +65,15 @@ rule
   type:
       name                   { return make_node(:TypeName, name: val[0])}
     | type BANG              { return make_node(:NonNullType, of_type: val[0]) }
-    | RBRACKET type LBRACKET { return make_node(:ListType, of_type: val[1]) }
+    | LBRACKET type RBRACKET { return make_node(:ListType, of_type: val[1]) }
 
   default_value_opt:
       /* none */          { return nil }
     | EQUALS input_value  { return val[1] }
 
   selection_set:
-      RCURLY LCURLY                { return [] }
-    | RCURLY selection_list LCURLY { return val[1] }
+      LCURLY RCURLY                { return [] }
+    | LCURLY selection_list RCURLY { return val[1] }
 
   selection_set_opt:
       /* none */    { return [] }
@@ -155,8 +155,8 @@ rule
 
   arguments_opt:
       /* none */                    { return [] }
-    | RPAREN LPAREN                 { return [] }
-    | RPAREN arguments_list LPAREN  { return val[1] }
+    | LPAREN RPAREN                 { return [] }
+    | LPAREN arguments_list RPAREN  { return val[1] }
 
   arguments_list:
       argument                { return [val[0]] }
@@ -179,16 +179,16 @@ rule
   variable: VAR_SIGN name { return make_node(:VariableIdentifier, name: val[1], position_source: val[0]) }
 
   list_value:
-      RBRACKET LBRACKET                 { return [] }
-    | RBRACKET list_value_list LBRACKET { return val[1] }
+      LBRACKET RBRACKET                 { return [] }
+    | LBRACKET list_value_list RBRACKET { return val[1] }
 
   list_value_list:
       input_value                 { return [val[0]] }
     | list_value_list input_value { val[0] << val[1] }
 
   object_value:
-      RCURLY LCURLY                   { return make_node(:InputObject, arguments: [], position_source: val[0])}
-    | RCURLY object_value_list LCURLY { return make_node(:InputObject, arguments: val[1], position_source: val[0])}
+      LCURLY RCURLY                   { return make_node(:InputObject, arguments: [], position_source: val[0])}
+    | LCURLY object_value_list RCURLY { return make_node(:InputObject, arguments: val[1], position_source: val[0])}
 
   object_value_list:
       object_value_field                    { return [val[0]] }
@@ -249,9 +249,10 @@ rule
   type_system_definition:
      schema_definition
    | type_definition
+   | directive_definition
 
   schema_definition:
-      SCHEMA RCURLY operation_type_definition_list LCURLY { return make_node(:SchemaDefinition, val[2]) }
+      SCHEMA LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, val[2]) }
 
   operation_type_definition_list:
       operation_type_definition
@@ -271,7 +272,7 @@ rule
   scalar_type_definition: SCALAR name directives_list_opt { return make_node(:ScalarTypeDefinition, name: val[1], directives: val[2]) }
 
   object_type_definition:
-      TYPE name implements_opt directives_list_opt RCURLY field_definition_list LCURLY {
+      TYPE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY {
         return make_node(:ObjectTypeDefinition, name: val[1], interfaces: val[2], directives: val[3], fields: val[5])
       }
 
@@ -290,7 +291,7 @@ rule
 
   arguments_definitions_opt:
       /* none */ { return [] }
-    | RPAREN input_value_definition_list LPAREN { return val[1] }
+    | LPAREN input_value_definition_list RPAREN { return val[1] }
 
   field_definition:
       name arguments_definitions_opt COLON type directives_list_opt {
@@ -302,7 +303,7 @@ rule
     | field_definition_list field_definition { val[0] << val[1] }
 
   interface_type_definition:
-      INTERFACE name directives_list_opt RCURLY field_definition_list LCURLY {
+      INTERFACE name directives_list_opt LCURLY field_definition_list RCURLY {
         return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4])
       }
 
@@ -316,14 +317,23 @@ rule
       }
 
   enum_type_definition:
-      ENUM name directives_list_opt RCURLY enum_value_definitions LCURLY {
+      ENUM name directives_list_opt LCURLY enum_value_definitions RCURLY {
          return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4])
       }
 
   input_object_type_definition:
-      INPUT name directives_list_opt RCURLY input_value_definition_list LCURLY {
+      INPUT name directives_list_opt LCURLY input_value_definition_list RCURLY {
         return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4])
       }
+
+  directive_definition:
+      DIRECTIVE DIR_SIGN name arguments_definitions_opt ON directive_locations {
+        return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5])
+      }
+
+  directive_locations:
+      name                          { return [val[0].to_s] }
+    | directive_locations PIPE name { val[0] << val[2].to_s }
 end
 
 ---- header ----

data/lib/graphql/language/parser_tests.rb

@@ -380,6 +380,25 @@ module GraphQL
                 assert_equal 'No longer supported', deprecated_directive.arguments[0].value
               end
 
+              it "parses directive definition" do
+                document = subject.parse('
+                  directive @include(if: Boolean!)
+                    on FIELD
+                    | FRAGMENT_SPREAD
+                    | INLINE_FRAGMENT
+                ')
+
+                type = document.definitions.first
+                assert_equal GraphQL::Language::Nodes::DirectiveDefinition, type.class
+                assert_equal 'include', type.name
+
+                assert_equal 1, type.arguments.length
+                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
+              end
+
               it "parses scalar types" do
                 document = subject.parse('scalar DateTime')
 
@@ -535,7 +554,7 @@ module GraphQL
                 ")
               end
               assert_includes(e.message, '"{"')
-              assert_includes(e.message, "RCURLY")
+              assert_includes(e.message, "LCURLY")
               assert_equal(3, e.line)
               assert_equal(33, e.col)
             end

data/lib/graphql/list_type.rb

@@ -53,7 +53,11 @@ module GraphQL
     end
 
     def coerce_non_null_input(value)
-      ensure_array(value).map{ |item| of_type.coerce_input(item) }
+      ensure_array(value).map { |item| of_type.coerce_input(item) }
+    end
+
+    def coerce_result(value)
+      ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item) }
     end
 
     private

data/lib/graphql/non_null_type.rb

@@ -57,6 +57,10 @@ module GraphQL
       of_type.coerce_input(value)
     end
 
+    def coerce_result(value)
+      of_type.coerce_result(value)
+    end
+
     def kind
       GraphQL::TypeKinds::NON_NULL
     end

data/lib/graphql/object_type.rb

@@ -11,7 +11,7 @@ module GraphQL
   #     field :director, PersonType
   #     field :cast, CastType
   #     field :starring, types[PersonType] do
-  #       arguments :limit, types.Int
+  #       argument :limit, types.Int
   #       resolve -> (object, args, ctx) {
   #         stars = object.cast.stars
   #         args[:limit] && stars = stars.limit(args[:limit])

data/lib/graphql/query/literal_input.rb

@@ -16,7 +16,7 @@ module GraphQL
         values_hash = {}
         argument_defns.each do |arg_name, arg_defn|
           ast_arg = ast_arguments.find { |ast_arg| ast_arg.name == arg_name }
-          arg_default_value = arg_defn.type.coerce_input(arg_defn.default_value)
+          arg_default_value = arg_defn.default_value
           if ast_arg.nil? && arg_default_value.nil?
             # If it wasn't in the document,
             # and there's no provided default,

data/lib/graphql/relay.rb

@@ -1,6 +1,5 @@
 require 'base64'
 
-require 'graphql/relay/global_node_identification'
 require 'graphql/relay/page_info'
 require 'graphql/relay/edge'
 require 'graphql/relay/edge_type'
@@ -9,6 +8,7 @@ require 'graphql/relay/array_connection'
 require 'graphql/relay/relation_connection'
 require 'graphql/relay/global_id_resolve'
 require 'graphql/relay/mutation'
+require 'graphql/relay/node'
 require 'graphql/relay/connection_field'
 require 'graphql/relay/connection_resolve'
 require 'graphql/relay/connection_type'

data/lib/graphql/relay/global_id_resolve.rb

@@ -1,14 +1,12 @@
 module GraphQL
   module Relay
     class GlobalIdResolve
-      def initialize(type_name:, property:)
-        @property = property
-        @type_name = type_name
+      def initialize(type:)
+        @type = type
       end
 
       def call(obj, args, ctx)
-        id_value = obj.public_send(@property)
-        ctx.query.schema.node_identification.to_global_id(@type_name, id_value)
+        ctx.query.schema.id_from_object(obj, @type, ctx)
       end
     end
   end

data/lib/graphql/relay/node.rb

@@ -0,0 +1,34 @@
+module GraphQL
+  module Relay
+    # Helpers for working with Relay-specific Node objects.
+    module Node
+      # @return [GraphQL::Field] a field for finding objects by their global ID.
+      def self.field
+        # We have to define it fresh each time because
+        # its name will be modified and its description
+        # _may_ be modified.
+        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
+      end
+
+      # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
+      def self.interface
+        @interface ||= GraphQL::InterfaceType.define do
+          name "Node"
+          field :id, !types.ID
+        end
+      end
+
+      # A field resolve for finding an object by ID
+      module FindNode
+        def self.call(obj, args, ctx)
+          ctx.query.schema.object_from_id(args[:id], ctx )
+        end
+      end
+    end
+  end
+end

data/lib/graphql/scalar_type.rb

@@ -62,7 +62,7 @@ module GraphQL
 
     def coerce_result(value)
       ensure_defined
-      @coerce_result_proc.call(value)
+      @coerce_result_proc ? @coerce_result_proc.call(value) : value
     end
 
     def coerce_result=(proc)

data/lib/graphql/schema.rb

@@ -1,12 +1,13 @@
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/middleware_chain"
-require "graphql/schema/rescue_middleware"
 require "graphql/schema/possible_types"
+require "graphql/schema/rescue_middleware"
 require "graphql/schema/reduce_types"
 require "graphql/schema/timeout_middleware"
 require "graphql/schema/type_expression"
 require "graphql/schema/type_map"
+require "graphql/schema/unique_within_type"
 require "graphql/schema/validation"
 
 module GraphQL
@@ -47,8 +48,8 @@ module GraphQL
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
-      :node_identification,
       :orphan_types, :resolve_type,
+      :object_from_id, :id_from_object,
       query_analyzer: -> (schema, analyzer) { schema.query_analyzers << analyzer },
       middleware: -> (schema, middleware) { schema.middleware << middleware },
       rescue_from: -> (schema, err_class, &block) { schema.rescue_from(err_class, &block)}
@@ -57,23 +58,16 @@ module GraphQL
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
-      :orphan_types, :node_identification,
+      :orphan_types,
       :query_analyzers, :middleware
 
-
-    DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
+    DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective, GraphQL::Directive::DeprecatedDirective]
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
-    RESOLVE_TYPE_PROC_REQUIRED = -> (obj, ctx) { raise("Schema.resolve_type is undefined, can't resolve type for #{obj.inspect}") }
+    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
-
-    # @!attribute node_identification
-    #   @return [GraphQL::Relay::GlobalNodeIdentification] the node identification instance for this schema, when using Relay
-
-    def node_identification=(new_node_ident)
-      new_node_ident.schema = self
-      @node_identification = new_node_ident
-    end
+    attr_reader :directives, :static_validator, :object_from_id_proc, :id_from_object_proc
 
     # @!attribute [r] middleware
     #   @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
@@ -99,6 +93,8 @@ module GraphQL
       @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
       # Default to the built-in execution strategy:
       @query_execution_strategy = GraphQL::Query::SerialExecution
       @mutation_execution_strategy = GraphQL::Query::SerialExecution
@@ -192,6 +188,8 @@ module GraphQL
 
     # Determine the GraphQL type for a given object.
     # This is required for unions and interfaces (include Relay's node interface)
+    # @param object [Any] An application object which GraphQL is currently resolving on
+    # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
     def resolve_type(object, ctx)
       ensure_defined
@@ -210,5 +208,35 @@ module GraphQL
       ensure_defined
       @resolve_type_proc = new_resolve_type_proc
     end
+
+    # Fetch an application object by its unique id
+    # @param id [String] A unique identifier, provided previously by this GraphQL schema
+    # @param ctx [GraphQL::Query::Context] The context for the current query
+    # @return [Any] The application object identified by `id`
+    def object_from_id(id, ctx)
+      ensure_defined
+      @object_from_id_proc.call(id, ctx)
+    end
+
+    # @param new_proc [#call] A new callable for fetching objects by ID
+    def object_from_id=(new_proc)
+      ensure_defined
+      @object_from_id_proc = new_proc
+    end
+
+    # Get a unique identifier from this object
+    # @param object [Any] An application object
+    # @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)
+      ensure_defined
+      @id_from_object_proc.call(type, object, ctx)
+    end
+
+    # @param new_proc [#call] A new callable for generating unique IDs
+    def id_from_object=(new_proc)
+      ensure_defined
+      @id_from_object_proc = new_proc
+    end
   end
 end

data/lib/graphql/schema/loader.rb

@@ -58,7 +58,7 @@ module GraphQL
                   name: enum["name"],
                   description: enum["description"],
                   deprecation_reason: enum["deprecationReason"],
-                  value: enum["value"]
+                  value: enum["name"]
                 )
               })
           when "INTERFACE"
@@ -102,7 +102,7 @@ module GraphQL
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
-              default_value: type["defaultValue"]
+              default_value: type["defaultValue"] ? JSON.parse(type["defaultValue"], quirks_mode: true) : nil
             )
           when "SCALAR"
             case type.fetch("name")

data/lib/graphql/schema/printer.rb

@@ -12,7 +12,7 @@ module GraphQL
       # Return a GraphQL schema string for the defined types in the schema
       # @param schema [GraphQL::Schema]
       def print_schema(schema)
-        print_filtered_schema(schema, method(:is_defined_type))
+        print_filtered_schema(schema, lambda { |n| !is_spec_directive(n) }, method(:is_defined_type))
       end
 
       # Return the GraphQL schema string for the introspection type system
@@ -21,16 +21,20 @@ module GraphQL
           name "Query"
         end
         schema = GraphQL::Schema.define(query: query_root)
-        print_filtered_schema(schema, method(:is_introspection_type))
+        print_filtered_schema(schema, method(:is_spec_directive), method(:is_introspection_type))
       end
 
       private
 
-      def print_filtered_schema(schema, type_filter)
+      def print_filtered_schema(schema, directive_filter, type_filter)
+        directives = schema.directives.values.select{ |directive| directive_filter.call(directive) }
+        directive_definitions = directives.map{ |directive| print_directive(directive) }
+
         types = schema.types.values.select{ |type| type_filter.call(type) }.sort_by(&:name)
         type_definitions = types.map{ |type| print_type(type) }
 
-        [print_schema_definition(schema)].concat(type_definitions).join("\n\n")
+        [print_schema_definition(schema)].concat(directive_definitions)
+                                         .concat(type_definitions).join("\n\n")
       end
 
       def print_schema_definition(schema)
@@ -44,6 +48,10 @@ module GraphQL
       BUILTIN_SCALARS = Set.new(["String", "Boolean", "Int", "Float", "ID"])
       private_constant :BUILTIN_SCALARS
 
+      def is_spec_directive(directive)
+        ['skip', 'include', 'deprecated'].include?(directive.name)
+      end
+
       def is_introspection_type(type)
         type.name.start_with?("__")
       end
@@ -56,12 +64,27 @@ module GraphQL
         TypeKindPrinters::STRATEGIES.fetch(type.kind).print(type)
       end
 
+      def print_directive(directive)
+        TypeKindPrinters::DirectivePrinter.print(directive)
+      end
+
       module TypeKindPrinters
-        module FieldPrinter
-          def print_fields(type)
-            type.all_fields.map{ |field| "  #{field.name}#{print_args(field)}: #{field.type}" }.join("\n")
+        module DeprecatedPrinter
+          def print_deprecated(field_or_enum_value)
+            return unless field_or_enum_value.deprecation_reason
+
+            case field_or_enum_value.deprecation_reason
+            when nil
+              ''
+            when '', GraphQL::Directive::DEFAULT_DEPRECATION_REASON
+              ' @deprecated'
+            else
+              " @deprecated(reason: #{field_or_enum_value.deprecation_reason.to_s.inspect})"
+            end
           end
+        end
 
+        module ArgsPrinter
           def print_args(field)
             return if field.arguments.empty?
             "(#{field.arguments.values.map{ |arg| print_input_value(arg) }.join(", ")})"
@@ -105,6 +128,24 @@ module GraphQL
           end
         end
 
+        module FieldPrinter
+          include DeprecatedPrinter
+          include ArgsPrinter
+          def print_fields(type)
+            type.all_fields.map{ |field|
+              "  #{field.name}#{print_args(field)}: #{field.type}#{print_deprecated(field)}"
+            }.join("\n")
+          end
+        end
+
+        class DirectivePrinter
+          extend ArgsPrinter
+          def self.print(directive)
+            "directive @#{directive.name}#{print_args(directive)} "\
+            "on #{directive.locations.join(' | ')}"
+          end
+        end
+
         class ScalarPrinter
           def self.print(type)
             "scalar #{type.name}"
@@ -137,8 +178,9 @@ module GraphQL
         end
 
         class EnumPrinter
+          extend DeprecatedPrinter
           def self.print(type)
-            values = type.values.values.map{ |v| "  #{v.name}" }.join("\n")
+            values = type.values.values.map{ |v| "  #{v.name}#{print_deprecated(v)}" }.join("\n")
             "enum #{type.name} {\n#{values}\n}"
           end
         end