graphql 1.1.0 → 1.2.0

data/lib/graphql/relay/mutation.rb

@@ -55,9 +55,9 @@ module GraphQL
         input_field: GraphQL::Define::AssignArgument,
         return_field: GraphQL::Define::AssignObjectField,
       )
-      lazy_defined_attr_accessor :name, :description
-      lazy_defined_attr_accessor :fields, :arguments, :return_type
+      attr_accessor :name, :description, :fields, :arguments, :return_type
 
+      ensure_defined(:name, :description, :fields, :arguments, :return_type, :resolve=, :field, :result_class, :input_type)
       # For backwards compat, but do we need this separate API?
       alias :return_fields :fields
       alias :input_fields :arguments
@@ -75,13 +75,11 @@ module GraphQL
       end
 
       def resolve=(new_resolve_proc)
-        ensure_defined
         @resolve_proc = MutationResolve.new(self, new_resolve_proc, wrap_result: has_generated_return_type?)
       end
 
       def field
         @field ||= begin
-          ensure_defined
           relay_mutation = self
           field_resolve_proc = @resolve_proc
           GraphQL::Field.define do
@@ -95,7 +93,6 @@ module GraphQL
       end
 
       def return_type
-        ensure_defined
         @return_type ||= begin
           @has_generated_return_type = true
           relay_mutation = self
@@ -113,14 +110,15 @@ module GraphQL
 
       def input_type
         @input_type ||= begin
-          ensure_defined
           relay_mutation = self
           GraphQL::InputObjectType.define do
             name("#{relay_mutation.name}Input")
             description("Autogenerated input type of #{relay_mutation.name}")
             input_field :clientMutationId, types.String, "A unique identifier for the client performing the mutation."
             relay_mutation.input_fields.each do |input_field_name, field_obj|
-              input_field input_field_name, field_obj.type, field_obj.description, default_value: field_obj.default_value
+              kwargs = {}
+              kwargs[:default_value] = field_obj.default_value if field_obj.default_value?
+              input_field input_field_name, field_obj.type, field_obj.description, **kwargs
             end
             mutation(relay_mutation)
           end
@@ -129,7 +127,6 @@ module GraphQL
 
       def result_class
         @result_class ||= begin
-          ensure_defined
           Result.define_subclass(self)
         end
       end

data/lib/graphql/scalar_type.rb

@@ -35,6 +35,7 @@ module GraphQL
   #
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
+    ensure_defined :coerce_non_null_input, :coerce_result
 
     def coerce=(proc)
       self.coerce_input = proc
@@ -50,7 +51,6 @@ module GraphQL
     end
 
     def coerce_non_null_input(value)
-      ensure_defined
       @coerce_input_proc.call(value)
     end
 
@@ -61,7 +61,6 @@ module GraphQL
     end
 
     def coerce_result(value)
-      ensure_defined
       @coerce_result_proc ? @coerce_result_proc.call(value) : value
     end
 

data/lib/graphql/schema.rb

@@ -61,7 +61,7 @@ module GraphQL
       middleware: ->(schema, middleware) { schema.middleware << middleware },
       rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)}
 
-    lazy_defined_attr_accessor \
+    attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
@@ -99,17 +99,16 @@ module GraphQL
     end
 
     def rescue_from(*args, &block)
-      ensure_defined
       rescue_middleware.rescue_from(*args, &block)
     end
 
     def remove_handler(*args, &block)
-      ensure_defined
       rescue_middleware.remove_handler(*args, &block)
     end
 
     def define(**kwargs, &block)
       super
+      ensure_defined
       all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
       @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
 
@@ -151,7 +150,6 @@ module GraphQL
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`
     def get_field(parent_type, field_name)
-      ensure_defined
       defined_field = @instrumented_field_map.get(parent_type.name, field_name)
       if defined_field
         defined_field
@@ -167,7 +165,6 @@ module GraphQL
     end
 
     def type_from_ast(ast_node)
-      ensure_defined
       GraphQL::Schema::TypeExpression.build_type(self.types, ast_node)
     end
 
@@ -175,7 +172,6 @@ module GraphQL
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
     def possible_types(type_defn)
-      ensure_defined
       @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
       @possible_types.possible_types(type_defn)
     end
@@ -213,8 +209,6 @@ module GraphQL
     # @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
-
       if @resolve_type_proc.nil?
         raise(NotImplementedError, "Can't determine GraphQL type for: #{object.inspect}, define `resolve_type (obj, ctx) -> { ... }` inside `Schema.define`.")
       end
@@ -231,7 +225,6 @@ module GraphQL
     end
 
     def resolve_type=(new_resolve_type_proc)
-      ensure_defined
       @resolve_type_proc = new_resolve_type_proc
     end
 
@@ -240,7 +233,6 @@ module GraphQL
     # @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
       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
@@ -250,7 +242,6 @@ module GraphQL
 
     # @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
 
@@ -260,7 +251,6 @@ module GraphQL
     # @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(object, type, ctx)
-      ensure_defined
       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
@@ -270,7 +260,6 @@ module GraphQL
 
     # @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
 

data/lib/graphql/schema/build_from_definition.rb

@@ -150,13 +150,23 @@ module GraphQL
           )
         end
 
+        def build_default_value(default_value)
+          case default_value
+          when GraphQL::Language::Nodes::Enum
+            default_value.name
+          when GraphQL::Language::Nodes::NullValue
+            nil
+          else
+            default_value
+          end
+        end
+
         def build_input_arguments(input_object_type_definition, type_resolver)
           input_object_type_definition.fields.map do |input_argument|
-            default_value = case input_argument.default_value
-            when GraphQL::Language::Nodes::Enum
-              input_argument.default_value.name
-            else
-              input_argument.default_value
+            kwargs = {}
+
+            if !input_argument.default_value.nil?
+              kwargs[:default_value] = build_default_value(input_argument.default_value)
             end
 
             [
@@ -165,7 +175,7 @@ module GraphQL
                 name: input_argument.name,
                 type: type_resolver.call(input_argument.type),
                 description: input_argument.description,
-                default_value: default_value,
+                **kwargs,
               )
             ]
           end
@@ -182,13 +192,19 @@ module GraphQL
 
         def build_directive_arguments(directive_definition, type_resolver)
           directive_definition.arguments.map do |directive_argument|
+            kwargs = {}
+
+            if !directive_argument.default_value.nil?
+              kwargs[:default_value] = build_default_value(directive_argument.default_value)
+            end
+
             [
               directive_argument.name,
               GraphQL::Argument.define(
                 name: directive_argument.name,
                 type: type_resolver.call(directive_argument.type),
                 description: directive_argument.description,
-                default_value: directive_argument.default_value,
+                **kwargs,
               )
             ]
           end
@@ -205,18 +221,17 @@ module GraphQL
         def build_fields(field_definitions, type_resolver)
           field_definitions.map do |field_definition|
             field_arguments = Hash[field_definition.arguments.map do |argument|
-              default_value = case argument.default_value
-              when GraphQL::Language::Nodes::Enum
-                argument.default_value.name
-              else
-                argument.default_value
+              kwargs = {}
+
+              if !argument.default_value.nil?
+                kwargs[:default_value] = build_default_value(argument.default_value)
               end
 
               arg = GraphQL::Argument.define(
                 name: argument.name,
                 description: argument.description,
                 type: type_resolver.call(argument.type),
-                default_value: default_value,
+                **kwargs,
               )
 
               [argument.name, arg]

data/lib/graphql/schema/loader.rb

@@ -103,11 +103,14 @@ module GraphQL
               }]
             )
           when "ARGUMENT"
+            kwargs = {}
+            kwargs[:default_value] = JSON.parse(type["defaultValue"], quirks_mode: true) if type["defaultValue"]
+
             Argument.define(
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
-              default_value: type["defaultValue"] ? JSON.parse(type["defaultValue"], quirks_mode: true) : nil
+              **kwargs
             )
           when "SCALAR"
             type_name = type.fetch("name")

data/lib/graphql/schema/printer.rb

@@ -120,10 +120,10 @@ module GraphQL
           end
 
           def print_input_value(arg)
-            if arg.default_value.nil?
-              default_string = nil
-            else
+            if arg.default_value?
               default_string = " = #{print_value(arg.default_value, arg.type)}"
+            else
+              default_string = nil
             end
 
             "#{arg.name}: #{arg.type.to_s}#{default_string}"
@@ -132,16 +132,22 @@ module GraphQL
           def print_value(value, type)
             case type
             when FLOAT_TYPE
+              return 'null' if value.nil?
               value.to_f.inspect
             when INT_TYPE
+              return 'null' if value.nil?
               value.to_i.inspect
             when BOOLEAN_TYPE
+              return 'null' if value.nil?
               (!!value).inspect
             when ScalarType, ID_TYPE, STRING_TYPE
+              return 'null' if value.nil?
               value.to_s.inspect
             when EnumType
+              return 'null' if value.nil?
               type.coerce_result(value)
             when InputObjectType
+              return 'null' if value.nil?
               fields = value.to_h.map{ |field_name, field_value|
                 field_type = type.input_fields.fetch(field_name.to_s).type
                 "#{field_name}: #{print_value(field_value, field_type)}"
@@ -150,6 +156,7 @@ module GraphQL
             when NonNullType
               print_value(value, type.of_type)
             when ListType
+              return 'null' if value.nil?
               "[#{value.to_a.map{ |v| print_value(v, type.of_type) }.join(", ")}]"
             else
               raise NotImplementedError, "Unexpected value type #{type.inspect}"

data/lib/graphql/schema/timeout_middleware.rb

@@ -1,3 +1,5 @@
+require "delegate"
+
 module GraphQL
   class Schema
     # This middleware will stop resolving new fields after `max_seconds` have elapsed.
@@ -43,14 +45,28 @@ module GraphQL
 
       # This is called when a field _would_ be resolved, except that we're over the time limit.
       # @return [GraphQL::Schema::TimeoutMiddleware::TimeoutError] An error whose message will be added to the `errors` key
-      def on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
+      def on_timeout(parent_type, parent_object, field_definition, field_args, field_context)
         err = GraphQL::Schema::TimeoutMiddleware::TimeoutError.new(parent_type, field_definition)
         if @error_handler
-          @error_handler.call(err, query_context.query)
+          query_proxy = TimeoutQueryProxy.new(field_context.query, field_context)
+          @error_handler.call(err, query_proxy)
         end
         err
       end
 
+      # This behaves like {GraphQL::Query} but {#context} returns
+      # the _field-level_ context, not the query-level context.
+      # This means you can reliably get the `irep_node` and `path`
+      # from it after the fact.
+      class TimeoutQueryProxy < SimpleDelegator
+        def initialize(query, ctx)
+          @context = ctx
+          super(query)
+        end
+
+        attr_reader :context
+      end
+
       # This error is raised when a query exceeds `max_seconds`.
       # Since it's a child of {GraphQL::ExecutionError},
       # its message will be added to the response's `errors` key.

data/lib/graphql/schema/unique_within_type.rb

@@ -1,14 +1,17 @@
 module GraphQL
   class Schema
     module UniqueWithinType
-      DEFAULT_SEPARATOR = "-"
+      class << self
+        attr_accessor :default_id_separator
+      end
+      self.default_id_separator = "-"
 
       module_function
 
       # @param type_name [String]
       # @param object_value [Any]
       # @return [String] a unique, opaque ID generated as a function of the two inputs
-      def encode(type_name, object_value, separator: DEFAULT_SEPARATOR)
+      def encode(type_name, object_value, separator: self.default_id_separator)
         object_value_str = object_value.to_s
 
         if type_name.include?(separator) || object_value_str.include?(separator)
@@ -20,7 +23,7 @@ module GraphQL
 
       # @param node_id [String] A unique ID generated by {.encode}
       # @return [Array<(String, String)>] The type name & value passed to {.encode}
-      def decode(node_id, separator: DEFAULT_SEPARATOR)
+      def decode(node_id, separator: self.default_id_separator)
         Base64.decode64(node_id).split(separator)
       end
     end

data/lib/graphql/static_validation/literal_validator.rb

@@ -7,7 +7,9 @@ module GraphQL
       end
 
       def validate(ast_value, type)
-        if type.kind.non_null?
+        if ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
+          !type.kind.non_null?
+        elsif type.kind.non_null?
           (!ast_value.nil?) && validate(ast_value, type.of_type)
         elsif type.kind.list?
           item_type = type.of_type

data/lib/graphql/union_type.rb

@@ -24,6 +24,7 @@ module GraphQL
   #
   class UnionType < GraphQL::BaseType
     accepts_definitions :possible_types, :resolve_type
+    ensure_defined :possible_types
 
     def kind
       GraphQL::TypeKinds::UNION
@@ -40,8 +41,6 @@ module GraphQL
 
     def possible_types
       @clean_possible_types ||= begin
-        ensure_defined
-
         if @dirty_possible_types.respond_to?(:map)
           @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
         else

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/readme.md

@@ -68,3 +68,4 @@ See "Getting Started" on the [website](https://rmosolgo.github.io/graphql-ruby/)
   - Renaming fragments from local names to unique names
 - Document encrypted & versioned cursors
 - Make it faster
+- Is it possible to merge typed branches before resolving them? It's hard because even the branches will have branches.

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -82,14 +82,12 @@ describe GraphQL::Analysis do
           memo ||= Hash.new { |h,k| h[k] = 0 }
           if visit_type == :enter
             if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-              irep_node.definitions.each do |type_defn, field_defn|
-                if field_defn.resolve_proc.is_a?(GraphQL::Relay::ConnectionResolve)
-                  memo[:connection] ||= 0
-                  memo[:connection] += 1
-                else
-                  memo[:field] ||= 0
-                  memo[:field] += 1
-                end
+              if irep_node.definition.resolve_proc.is_a?(GraphQL::Relay::ConnectionResolve)
+                memo[:connection] ||= 0
+                memo[:connection] += 1
+              else
+                memo[:field] ||= 0
+                memo[:field] += 1
               end
             end
           end