graphql 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d1d8b93486b17d67f6714c1ad867c5f5eb403a4
-  data.tar.gz: 68dc546c4124fd8fb3752c911b63be9f9753ffc2
+  metadata.gz: 8e06bd99f6bb6350c2d7111d5014ef9c71154f8a
+  data.tar.gz: 1b90cfb31081700c64abab2f8f26a665bd2fe6fa
 SHA512:
-  metadata.gz: eb42f273418ba3eda88ca784f3af4a20b0a57223b02adbf64736953446312e87ece3392f2c7b3d696ebbd66cecc8a38809ff6ff79bb623942dd6bced33c4f5bc
-  data.tar.gz: 54669eb238917fedceba3df22ac927461a0a427b1d259a3277e6be1ffef420ada7ee1fc5abd63f605a4d5397e88a23d1d8ea73f95ebfd9cbaa97554b09b05089
+  metadata.gz: d8c0847198e4c6403cffac42b6cf8ab3cf1446d04ebcb91d2cb916244e170f0072d6ef9ee1ac355c4585ab62d0eac73048d34cb89e990b0cf62bde639d8fd166
+  data.tar.gz: ce1ea3d57512c38593c50ba2531994b5ce5ed83b0cb91ee13e4e78402d3ed4494c8d8ec88db2c037460e0379820b47821c0fcdb03a18cc804de17157fc252acd

data/lib/graphql/analysis/analyze_query.rb

@@ -32,8 +32,10 @@ module GraphQL
     def reduce_node(irep_node, reducer_states)
       visit_analyzers(:enter, irep_node, reducer_states)
 
-      irep_node.children.each do |name, child_irep_node|
-        reduce_node(child_irep_node, reducer_states)
+      irep_node.typed_children.each do |type_defn, children|
+        children.each do |name, child_irep_node|
+          reduce_node(child_irep_node, reducer_states)
+        end
       end
 
       visit_analyzers(:leave, irep_node, reducer_states)

data/lib/graphql/analysis/field_usage.rb

@@ -26,10 +26,10 @@ module GraphQL
 
       def call(memo, visit_type, irep_node)
         if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field) && visit_type == :leave
-          irep_node.definitions.each do |type_defn, field_defn|
-            field = "#{type_defn.name}.#{field_defn.name}"
-            memo[:used_fields] << field
-            memo[:used_deprecated_fields] << field if field_defn.deprecation_reason
+          field = "#{irep_node.owner_type.name}.#{irep_node.definition.name}"
+          memo[:used_fields] << field
+          if irep_node.definition.deprecation_reason
+            memo[:used_deprecated_fields] << field
           end
         end
 

data/lib/graphql/analysis/query_complexity.rb

@@ -46,7 +46,7 @@ module GraphQL
               type_complexities = memo[:complexities_on_type].pop
               child_complexity = type_complexities.max_possible_complexity
               own_complexity = get_complexity(irep_node, memo[:query], child_complexity)
-              memo[:complexities_on_type].last.merge(irep_node.definitions, own_complexity)
+              memo[:complexities_on_type].last.merge(irep_node.owner_type, own_complexity)
             end
           end
         end
@@ -65,24 +65,18 @@ module GraphQL
       # Get a complexity value for a field,
       # by getting the number or calling its proc
       def get_complexity(irep_node, query, child_complexity)
-        max_possible_complexity = 0
-        irep_node.definitions.each do |type_defn, field_defn|
-          defined_complexity = field_defn.complexity
-          type_cpx = case defined_complexity
-          when Proc
-            args = query.arguments_for(irep_node, field_defn)
-            defined_complexity.call(query.context, args, child_complexity)
-          when Numeric
-            defined_complexity + (child_complexity || 0)
-          else
-            raise("Invalid complexity: #{defined_complexity.inspect} on #{field_defn.name}")
-          end
-
-          if type_cpx > max_possible_complexity
-            max_possible_complexity = type_cpx
-          end
+        type_defn = irep_node.owner_type
+        field_defn = irep_node.definition
+        defined_complexity = field_defn.complexity
+        case defined_complexity
+        when Proc
+          args = query.arguments_for(irep_node, field_defn)
+          defined_complexity.call(query.context, args, child_complexity)
+        when Numeric
+          defined_complexity + (child_complexity || 0)
+        else
+          raise("Invalid complexity: #{defined_complexity.inspect} on #{field_defn.name}")
         end
-        max_possible_complexity
       end
 
       # Selections on an object may apply differently depending on what is _actually_ returned by the resolve function.
@@ -112,9 +106,10 @@ module GraphQL
           max_complexity
         end
 
-        # Store the complexity score for each of `types`
-        def merge(definitions, complexity)
-          definitions.each { |type_defn, field_defn| @types[type_defn] += complexity }
+        # Store the complexity for the branch on `type_defn`.
+        # Later we will see if this is the max complexity among branches.
+        def merge(type_defn, complexity)
+          @types[type_defn] += complexity
         end
 
         private

data/lib/graphql/argument.rb

@@ -17,24 +17,31 @@ module GraphQL
   class Argument
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :name, :type, :description, :default_value
-    lazy_defined_attr_accessor :type, :description, :default_value, :name
+    attr_accessor :type, :description, :default_value, :name
+
+    ensure_defined(:name, :description, :default_value, :type=, :type)
+
+    def default_value?
+      !!@has_default_value
+    end
+
+    def default_value=(new_default_value)
+      @has_default_value = true
+      @default_value = new_default_value
+    end
 
     # @!attribute name
     #   @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
 
     # @param new_input_type [GraphQL::BaseType, Proc] Assign a new input type for this argument (if it's a proc, it will be called after schema initialization)
     def type=(new_input_type)
-      ensure_defined
       @clean_type = nil
       @dirty_type = new_input_type
     end
 
     # @return [GraphQL::BaseType] the input type for this argument
     def type
-      @clean_type ||= begin
-        ensure_defined
-        GraphQL::BaseType.resolve_related_type(@dirty_type)
-      end
+      @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
     end
   end
 end

data/lib/graphql/base_type.rb

@@ -8,7 +8,8 @@ module GraphQL
         global_id_field: GraphQL::Define::AssignGlobalIdField,
       }
 
-    lazy_defined_attr_accessor :name, :description
+    attr_accessor :name, :description
+    ensure_defined(:name, :description)
 
     # @!attribute name
     #   @return [String] the name of this type, must be unique within a Schema

data/lib/graphql/compatibility/execution_specification.rb

@@ -407,6 +407,82 @@ module GraphQL
             error_messages = res["errors"].map { |e| e["message"] }
             assert_equal ["Error on Nullable"], error_messages
           end
+
+          def test_it_only_resolves_fields_once_on_typed_fragments
+            count = 0
+            counter_type = nil
+
+            has_count_interface = GraphQL::InterfaceType.define do
+              name "HasCount"
+              field :count, types.Int
+              field :counter, ->{ counter_type }
+            end
+
+            counter_type = GraphQL::ObjectType.define do
+              name "Counter"
+              interfaces [has_count_interface]
+              field :count, types.Int, resolve: ->(o,a,c) { count += 1 }
+              field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+            end
+
+            alt_counter_type = GraphQL::ObjectType.define do
+              name "AltCounter"
+              interfaces [has_count_interface]
+              field :count, types.Int, resolve: ->(o,a,c) { count += 1 }
+              field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+            end
+
+            has_counter_interface = GraphQL::InterfaceType.define do
+              name "HasCounter"
+              field :counter, counter_type
+            end
+
+            query_type = GraphQL::ObjectType.define do
+              name "Query"
+              interfaces [has_counter_interface]
+              field :counter, has_count_interface, resolve: ->(o,a,c) { :counter }
+            end
+
+            schema = GraphQL::Schema.define(
+              query: query_type,
+              resolve_type: ->(o, c) { o == :counter ? counter_type : nil },
+              orphan_types: [alt_counter_type],
+            )
+
+            res = schema.execute("
+            {
+              counter { count }
+              ... on HasCounter {
+                counter { count }
+              }
+            }
+            ")
+
+            expected_data = {
+              "counter" => { "count" => 1 }
+            }
+            assert_equal expected_data, res["data"]
+            assert_equal 1, count
+
+            # Deep typed children are correctly distinguished:
+            res = schema.execute("
+            {
+              counter {
+                ... on Counter {
+                  counter { count }
+                }
+                ... on AltCounter {
+                  counter { count, t: __typename }
+                }
+              }
+            }
+            ")
+
+            expected_data = {
+              "counter" => { "counter" => { "count" => 2 } }
+            }
+            assert_equal expected_data, res["data"]
+          end
         end
       end
     end

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -57,12 +57,15 @@ module GraphQL
                   int: 3,
                   float: 4.7e-24,
                   bool: false,
-                  string: "☀︎🏆\\n \\" \u00b6 /",
+                  string: "☀︎🏆 \\b \\f \\n \\r \\t \\" \u00b6 \\u00b6 / \\/",
                   enum: ENUM_NAME,
                   array: [7, 8, 9]
                   object: {a: [1,2,3], b: {c: "4"}}
                   unicode_bom: "\xef\xbb\xbfquery"
                   keywordEnum: on
+                  nullValue: null
+                  nullValueInObject: {a: null, b: "b"}
+                  nullValueInArray: ["a", null, "b"]
                 )
               }
             |
@@ -71,7 +74,7 @@ module GraphQL
             assert_equal 3, inputs[0].value, "Integers"
             assert_equal 0.47e-23, inputs[1].value, "Floats"
             assert_equal false, inputs[2].value, "Booleans"
-            assert_equal %|☀︎🏆\n " ¶ /|, inputs[3].value, "Strings"
+            assert_equal %|☀︎🏆 \b \f \n \r \t " ¶ ¶ / /|, inputs[3].value, "Strings"
             assert_instance_of GraphQL::Language::Nodes::Enum, inputs[4].value
             assert_equal "ENUM_NAME", inputs[4].value.name, "Enums"
             assert_equal [7,8,9], inputs[5].value, "Lists"
@@ -85,6 +88,17 @@ module GraphQL
 
             assert_equal %|\xef\xbb\xbfquery|, inputs[7].value, "Unicode BOM"
             assert_equal "on", inputs[8].value.name, "Enum value 'on'"
+
+            assert_instance_of GraphQL::Language::Nodes::NullValue, inputs[9].value
+
+            args = inputs[10].value.arguments
+            assert_instance_of GraphQL::Language::Nodes::NullValue, args.find{ |arg| arg.name == 'a' }.value
+            assert_equal 'b', args.find{ |arg| arg.name == 'b' }.value
+
+            values = inputs[11].value
+            assert_equal 'a', values[0]
+            assert_instance_of GraphQL::Language::Nodes::NullValue, values[1]
+            assert_equal 'b', values[2]
           end
         end
       end

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -70,11 +70,6 @@ module GraphQL
           assert_raises_parse_error("{ ...on }")
           assert_raises_parse_error("fragment on on Type { field }")
         end
-
-        def test_it_rejects_null
-          err = assert_raises_parse_error("{ field(input: null) }")
-          assert_includes(err.message, "null")
-        end
       end
     end
   end

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -184,6 +184,11 @@ module GraphQL
             assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, interface_type_definition.class
             assert_equal 'Comment for interface definitions', interface_type_definition.description
             assert_equal 'Amount of wheels', interface_type_definition.fields[0].description
+
+            brand_field = interface_type_definition.fields[1]
+            assert_equal 1, brand_field.arguments.length
+            assert_equal 'argument', brand_field.arguments[0].name
+            assert_instance_of GraphQL::Language::Nodes::NullValue, brand_field.arguments[0].default_value
           end
         end
       end
@@ -230,6 +235,7 @@ module GraphQL
         interface Vehicle {
           # Amount of wheels
           wheels: Int!
+          brand(argument: String = null): String!
         }
 
         # Comment at the end of schema

data/lib/graphql/define/assign_argument.rb

@@ -2,16 +2,22 @@ module GraphQL
   module Define
     # Turn argument configs into a {GraphQL::Argument}.
     module AssignArgument
-      def self.call(target, name, type = nil, description = nil, default_value: nil, &block)
+      def self.call(target, name, type = nil, description = nil, **rest, &block)
         argument = if block_given?
           GraphQL::Argument.define(&block)
         else
           GraphQL::Argument.new
         end
+
+        unsupported_keys = rest.keys - [:default_value]
+        if unsupported_keys.any?
+          raise ArgumentError.new("unknown keyword#{unsupported_keys.length > 1 ? 's' : ''}: #{unsupported_keys.join(', ')}")
+        end
+
         argument.name = name.to_s
         type && argument.type = type
         description && argument.description = description
-        !default_value.nil? && argument.default_value = default_value
+        rest.key?(:default_value) && argument.default_value = rest[:default_value]
 
         target.arguments[name.to_s] = argument
       end

data/lib/graphql/define/instance_definable.rb

@@ -71,13 +71,13 @@ module GraphQL
     module InstanceDefinable
       def self.included(base)
         base.extend(ClassMethods)
+        base.ensure_defined(:metadata)
       end
 
       # `metadata` can store arbitrary key-values with an object.
       #
       # @return [Hash<Object, Object>] Hash for user-defined storage
       def metadata
-        ensure_defined
         @metadata ||= {}
       end
 
@@ -174,21 +174,18 @@ module GraphQL
           @own_dictionary = own_dictionary.merge(new_assignments)
         end
 
-        # Define a reader and writer for each of `attr_names` which
-        # ensures that the definition block was called before accessing it.
-        def lazy_defined_attr_accessor(*attr_names)
-          attr_names.each do |attr_name|
-            ivar_name = :"@#{attr_name}"
-            define_method(attr_name) do
-              ensure_defined
-              instance_variable_get(ivar_name)
-            end
-
-            define_method("#{attr_name}=") do |new_value|
-              ensure_defined
-              instance_variable_set(ivar_name, new_value)
+        def ensure_defined(*method_names)
+          ensure_defined_module = Module.new
+          ensure_defined_module.module_eval {
+            method_names.each do |method_name|
+              define_method(method_name) { |*args, &block|
+                ensure_defined
+                super(*args, &block)
+              }
             end
-          end
+          }
+          self.prepend(ensure_defined_module)
+          nil
         end
 
         # @return [Hash] combined definitions for self and ancestors

data/lib/graphql/directive.rb

@@ -9,7 +9,8 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :locations, :name, :description, :arguments, argument: GraphQL::Define::AssignArgument
 
-    lazy_defined_attr_accessor :locations, :arguments, :name, :description
+    attr_accessor :locations, :arguments, :name, :description
+    ensure_defined(:locations, :arguments, :name, :description)
 
     LOCATIONS = [
       QUERY =                  :QUERY,

data/lib/graphql/enum_type.rb

@@ -72,6 +72,7 @@ module GraphQL
 
   class EnumType < GraphQL::BaseType
     accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
+    ensure_defined(:values, :validate_non_null_input, :coerce_non_null_input, :coerce_result)
 
     def initialize
       @values_by_name = {}
@@ -90,7 +91,6 @@ module GraphQL
 
     # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
     def values
-      ensure_defined
       @values_by_name
     end
 
@@ -99,7 +99,6 @@ module GraphQL
     end
 
     def validate_non_null_input(value_name, warden)
-      ensure_defined
       result = GraphQL::Query::InputValidationResult.new
       allowed_values = warden.enum_values(self)
       matching_value = allowed_values.find { |v| v.name == value_name }
@@ -120,7 +119,6 @@ module GraphQL
     # @param value_name [String] the string representation of this enum value
     # @return [Object] the underlying value for this enum value
     def coerce_non_null_input(value_name)
-      ensure_defined
       if @values_by_name.key?(value_name)
         @values_by_name.fetch(value_name).value
       else
@@ -129,7 +127,6 @@ module GraphQL
     end
 
     def coerce_result(value, warden = nil)
-      ensure_defined
       all_values = warden ? warden.enum_values(self) : @values_by_name.each_value
       enum_value = all_values.find { |val| val.value == value }
       if enum_value
@@ -148,9 +145,10 @@ module GraphQL
     # Created with the `value` helper
     class EnumValue
       include GraphQL::Define::InstanceDefinable
-      accepts_definitions :name, :description, :deprecation_reason, :value
-
-      lazy_defined_attr_accessor :name, :description, :deprecation_reason, :value
+      ATTRIBUTES = [:name, :description, :deprecation_reason, :value]
+      accepts_definitions(*ATTRIBUTES)
+      attr_accessor(*ATTRIBUTES)
+      ensure_defined(*ATTRIBUTES)
     end
 
     class UnresolvedValueError < GraphQL::Error

data/lib/graphql/field.rb

@@ -126,7 +126,11 @@ module GraphQL
       argument: GraphQL::Define::AssignArgument
 
 
-    lazy_defined_attr_accessor :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity
+    attr_accessor :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity
+    ensure_defined(
+      :name, :deprecation_reason, :description, :property, :hash_key, :mutation, :arguments, :complexity,
+      :resolve, :resolve=, :type, :type=, :name=, :property=, :hash_key=
+    )
 
     # @!attribute [r] resolve_proc
     #   @return [<#call(obj, args,ctx)>] A proc-like object which can be called to return the field's value
@@ -158,7 +162,6 @@ module GraphQL
     # @param arguments [Hash] Arguments declared in the query
     # @param context [GraphQL::Query::Context]
     def resolve(object, arguments, context)
-      ensure_defined
       resolve_proc.call(object, arguments, context)
     end
 
@@ -166,22 +169,17 @@ module GraphQL
     # a new resolve proc will be build based on its {#name}, {#property} or {#hash_key}.
     # @param new_resolve_proc [<#call(obj, args, ctx)>, nil]
     def resolve=(new_resolve_proc)
-      ensure_defined
       @resolve_proc = new_resolve_proc || build_default_resolver
     end
 
     def type=(new_return_type)
-      ensure_defined
       @clean_type = nil
       @dirty_type = new_return_type
     end
 
     # Get the return type for this field.
     def type
-      @clean_type ||= begin
-        ensure_defined
-        GraphQL::BaseType.resolve_related_type(@dirty_type)
-      end
+      @clean_type ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
     end
 
     # You can only set a field's name _once_ -- this to prevent
@@ -189,7 +187,6 @@ module GraphQL
     #
     # This is important because {#name} may be used by {#resolve}.
     def name=(new_name)
-      ensure_defined
       if @name.nil?
         @name = new_name
       elsif @name != new_name
@@ -199,14 +196,12 @@ module GraphQL
 
     # @param new_property [Symbol] A method to call to resolve this field. Overrides the existing resolve proc.
     def property=(new_property)
-      ensure_defined
       @property = new_property
       self.resolve = nil # reset resolve proc
     end
 
     # @param new_hash_key [Symbol] A key to access with `#[key]` to resolve this field. Overrides the existing resolve proc.
     def hash_key=(new_hash_key)
-      ensure_defined
       @hash_key = new_hash_key
       self.resolve = nil # reset resolve proc
     end