graphql 0.16.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e4d95f2f01d1d24633dc5b6c062a67e6a752379
-  data.tar.gz: 19634030a6f735243babd83be75d9279c2987795
+  metadata.gz: 24203b4225051e3273a336d37502cdddd29c3c21
+  data.tar.gz: d3c4de442aa838dfde6db055cd4da9e397a89578
 SHA512:
-  metadata.gz: 189c9d0eacdc54969b15f412dbb968c3a1d9aadedd0ccd4e74cc3e9afaf1af33c83c0f4a9b911ed563a3fc9dc8f256c75d74d013832273038087ae38734abeb2
-  data.tar.gz: 675427c4e5233153a58f6ff3a2abbe754e9216261872d666301ceeeeb1919b8098c4b7bdf2ee8065ccb781d3ad35c6a2bfa7f1e0e5e719486176655831032efb
+  metadata.gz: d134105d845e9b416078a504048f9ba263943fba5741a4de5d9f3cf229a193614858794b9d6ef5b857b84cb14ea3f1bb14d1b9ffc6beb4ee9e6fff2d9c9fac1c
+  data.tar.gz: e7107d02800a97cf95ed00dc54463056ba7dd0bc38623f5750deb4cc6a0ea736074a84ee77da81859c7c548ffe75b117a9c130e7a98fc13a6339dfdc8a8ba1ea

data/lib/graphql/analysis/query_complexity.rb

@@ -38,7 +38,7 @@ module GraphQL
             else
               0
             end
-            memo[:complexities_on_type].last.merge(irep_node.on_types, own_complexity)
+            memo[:complexities_on_type].last.merge(irep_node.definitions, own_complexity)
           end
         end
         memo
@@ -56,17 +56,24 @@ 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)
-        field_defn = irep_node.definition
-        defined_complexity = field_defn.complexity
-        case defined_complexity
-        when Proc
-          args = query.arguments_for(irep_node)
-          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}")
+        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
         end
+        max_possible_complexity
       end
 
       # Selections on an object may apply differently depending on what is _actually_ returned by the resolve function.
@@ -97,8 +104,8 @@ module GraphQL
         end
 
         # Store the complexity score for each of `types`
-        def merge(types, complexity)
-          types.each { |t| @types[t] += complexity }
+        def merge(definitions, complexity)
+          definitions.each { |type_defn, field_defn| @types[type_defn] += complexity }
         end
 
         private

data/lib/graphql/analysis/query_depth.rb

@@ -24,7 +24,7 @@ module GraphQL
       def call(memo, visit_type, irep_node)
         if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
           if visit_type == :enter
-            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition.name)
+            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name)
               # Don't validate introspection fields
               memo[:skip_current_scope] = true
             elsif memo[:skip_current_scope]
@@ -33,7 +33,7 @@ module GraphQL
               memo[:current_depth] += 1
             end
           else
-            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition.name)
+            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name)
               memo[:skip_current_scope] = false
             elsif GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
               if memo[:max_depth] < memo[:current_depth]

data/lib/graphql/argument.rb

@@ -17,9 +17,14 @@ module GraphQL
   class Argument
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :name, :type, :description, :default_value
-    attr_accessor :type, :description, :default_value
+    lazy_defined_attr_accessor :type, :description, :default_value
 
     # @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
-    attr_accessor :name
+    def name
+      ensure_defined
+      @name
+    end
+
+    attr_writer :name
   end
 end

data/lib/graphql/base_type.rb

@@ -3,8 +3,8 @@ module GraphQL
   class BaseType
     include GraphQL::Define::NonNullWithBang
     include GraphQL::Define::InstanceDefinable
-    attr_accessor :name, :description
     accepts_definitions :name, :description
+    lazy_defined_attr_accessor :name, :description
 
     # @param other [GraphQL::BaseType] compare to this object
     # @return [Boolean] are these types equivalent? (incl. non-null, list)
@@ -53,6 +53,7 @@ module GraphQL
       # @param ctx [GraphQL::Query::Context]
       # @return [GraphQL::ObjectType] the type which should expose `object`
       def resolve_type(object, ctx)
+        ensure_defined
         instance_exec(object, ctx, &(@resolve_type_proc || DEFAULT_RESOLVE_TYPE))
       end
 

data/lib/graphql/boolean_type.rb

@@ -3,6 +3,7 @@ GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
   ALLOWED_INPUTS = [true, false]
 
   name "Boolean"
+  description "Represents `true` or `false` values."
 
   coerce_input -> (value) { ALLOWED_INPUTS.include?(value) ? value : nil }
   coerce_result -> (value) { !!value }

data/lib/graphql/define/assign_object_field.rb

@@ -2,15 +2,28 @@ module GraphQL
   module Define
     # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}
     module AssignObjectField
-      def self.call(fields_type, name, type = nil, desc = nil, field: nil, deprecation_reason: nil, property: nil, complexity: nil, &block)
-        if block_given?
+      def self.call(fields_type, name, type_or_field = nil, desc = nil, field: nil, deprecation_reason: nil, property: nil, complexity: nil, hash_key: nil, &block)
+        if type_or_field.is_a?(GraphQL::Field)
+          field = type_or_field
+        elsif block_given?
           field = GraphQL::Field.define(&block)
-        else
-          field ||= GraphQL::Field.new
+        elsif field.nil?
+          field = GraphQL::Field.new
         end
-        type && field.type = type
+
+        if !type_or_field.nil? && !type_or_field.is_a?(GraphQL::Field)
+          field.type = type_or_field
+        end
+
         desc && field.description = desc
-        property && field.property = property
+
+        # If the field's resolve proc was defined in the config block,
+        # don't override it with `property` or `hash_key`
+        if field.resolve_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
+          property && field.property = property
+          hash_key && field.hash_key = hash_key
+        end
+
         complexity && field.complexity = complexity
         deprecation_reason && field.deprecation_reason = deprecation_reason
         field.name ||= name.to_s

data/lib/graphql/define/instance_definable.rb

@@ -44,12 +44,36 @@ module GraphQL
         base.extend(ClassMethods)
       end
 
+      # Set the definition block for this instance.
+      # It can be run later with {#ensure_defined}
+      def definition_proc=(defn_block)
+        @definition_proc = defn_block
+      end
+
+      private
+
+      # Run the definition block if it hasn't been run yet.
+      # This can only be run once: the block is deleted after it's used.
+      # You have to call this before using any value which could
+      # come from the definition block.
+      # @return [void]
+      def ensure_defined
+        if @definition_proc
+          defn_proc = @definition_proc
+          @definition_proc = nil
+          proxy = DefinedObjectProxy.new(self, self.class.dictionary)
+          proxy.instance_eval(&defn_proc)
+        end
+        nil
+      end
+
       module ClassMethods
-        # Define an instance of this class using its {.definitions}.
+        # Prepare the defintion for an instance of this class using its {.definitions}.
+        # Note that the block is not called right away -- instead, it's deferred until
+        # one of the defined fields is needed.
         def define(&block)
           instance = self.new
-          proxy = DefinedObjectProxy.new(instance, dictionary)
-          block && proxy.instance_eval(&block)
+          instance.definition_proc = block
           instance
         end
 
@@ -60,6 +84,23 @@ module GraphQL
           @own_dictionary = own_dictionary.merge(AssignmentDictionary.create(*accepts))
         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)
+            end
+          end
+        end
+
         # @return [Hash] combined definitions for self and ancestors
         def dictionary
           if superclass.respond_to?(:dictionary)

data/lib/graphql/directive.rb

@@ -3,7 +3,7 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :locations, :name, :description, :include_proc, argument: GraphQL::Define::AssignArgument
 
-    attr_accessor :locations, :arguments, :name, :description
+    lazy_defined_attr_accessor :locations, :arguments, :name, :description, :include_proc
 
     LOCATIONS = [
       QUERY =               :QUERY,
@@ -20,11 +20,7 @@ module GraphQL
     end
 
     def include?(arguments)
-      @include_proc.call(arguments)
-    end
-
-    def include_proc=(include_proc)
-      @include_proc = include_proc
+      include_proc.call(arguments)
     end
 
     def to_s

data/lib/graphql/enum_type.rb

@@ -19,10 +19,10 @@ module GraphQL
       @values_by_value = {}
     end
 
-    def values=(values)
+    def values=(new_values)
       @values_by_name = {}
       @values_by_value = {}
-      values.each { |enum_value| add_value(enum_value) }
+      new_values.each { |enum_value| add_value(enum_value) }
     end
 
     def add_value(enum_value)
@@ -31,24 +31,16 @@ module GraphQL
     end
 
     def values
+      ensure_defined
       @values_by_name
     end
 
-    # Define a value within this enum
-    # @deprecated use {.define} API instead
-    # @param name [String] the string representation of this value
-    # @param description [String]
-    # @param deprecation_reason [String] if provided, `deprecated?` will be true
-    # @param value [Object] the underlying value for this enum value
-    def value(name, description=nil, deprecation_reason: nil, value: name)
-      values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
-    end
-
     def kind
       GraphQL::TypeKinds::ENUM
     end
 
     def validate_non_null_input(value_name)
+      ensure_defined
       result = GraphQL::Query::InputValidationResult.new
 
       if !@values_by_name.key?(value_name)
@@ -67,11 +59,16 @@ 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)
-      return nil unless @values_by_name.key?(value_name)
-      @values_by_name.fetch(value_name).value
+      ensure_defined
+      if @values_by_name.key?(value_name)
+        @values_by_name.fetch(value_name).value
+      else
+        nil
+      end
     end
 
     def coerce_result(value)
+      ensure_defined
       @values_by_value.fetch(value).name
     end
 

data/lib/graphql/field.rb

@@ -1,3 +1,5 @@
+require "graphql/field/resolve"
+
 module GraphQL
   # {Field}s belong to {ObjectType}s and {InterfaceType}s.
   #
@@ -57,20 +59,35 @@ module GraphQL
   #
   class Field
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :description, :resolve, :type, :property, :deprecation_reason, :complexity, argument: GraphQL::Define::AssignArgument
+    accepts_definitions :name, :description, :resolve, :type, :property, :deprecation_reason, :complexity, :hash_key, argument: GraphQL::Define::AssignArgument
 
-    attr_accessor :deprecation_reason, :name, :description, :property
+    lazy_defined_attr_accessor :deprecation_reason, :description, :property, :hash_key
 
     attr_reader :resolve_proc
 
     # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
-    attr_reader :name
+    def name
+      ensure_defined
+      @name
+    end
+
+    attr_writer :name
 
     # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-    attr_accessor :arguments
+    def arguments
+      ensure_defined
+      @arguments
+    end
+
+    attr_writer :arguments
 
     # @return [Numeric, Proc] The complexity for this field (default: 1), as a constant or a proc like `-> (query_ctx, args, child_complexity) { } # Numeric`
-    attr_accessor :complexity
+    def complexity
+      ensure_defined
+      @complexity
+    end
+
+    attr_writer :complexity
 
     def initialize
       @complexity = 1
@@ -86,21 +103,27 @@ module GraphQL
     # @param arguments [Hash] Arguments declared in the query
     # @param context [GraphQL::Query::Context]
     def resolve(object, arguments, context)
-      @resolve_proc.call(object, arguments, context)
+      ensure_defined
+      resolve_proc.call(object, arguments, context)
     end
 
     def resolve=(resolve_proc)
+      ensure_defined
       @resolve_proc = 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 ||= GraphQL::BaseType.resolve_related_type(@dirty_type)
+      @clean_type ||= begin
+        ensure_defined
+        GraphQL::BaseType.resolve_related_type(@dirty_type)
+      end
     end
 
     # You can only set a field's name _once_ -- this to prevent
@@ -108,13 +131,28 @@ module GraphQL
     #
     # This is important because {#name} may be used by {#resolve}.
     def name=(new_name)
+      ensure_defined
       if @name.nil?
         @name = new_name
-      else
+      elsif @name != new_name
         raise("Can't rename an already-named field. (Tried to rename \"#{@name}\" to \"#{new_name}\".) If you're passing a field with the `field:` argument, make sure it's an unused instance of GraphQL::Field.")
       end
     end
 
+    # @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
+
     def to_s
       "<Field: #{name || "not-named"}>"
     end
@@ -122,10 +160,7 @@ module GraphQL
     private
 
     def build_default_resolver
-      -> (obj, args, ctx) do
-        resolve_method = self.property || self.name
-        obj.public_send(resolve_method)
-      end
+      GraphQL::Field::Resolve.create_proc(self)
     end
   end
 end

data/lib/graphql/field/resolve.rb

@@ -0,0 +1,57 @@
+module GraphQL
+  class Field
+    # Create resolve procs ahead of time based on a {GraphQL::Field}'s `name`, `property`, and `hash_key` configuration.
+    module Resolve
+      module_function
+
+      # @param [GraphQL::Field] A field that needs a resolve proc
+      # @return [Proc] A resolver for this field, based on its config
+      def create_proc(field)
+        if field.property
+          MethodResolve.new(field.property.to_sym)
+        elsif !field.hash_key.nil?
+          HashKeyResolve.new(field.hash_key)
+        else
+          NameResolve.new(field)
+        end
+      end
+
+      class BuiltInResolve
+      end
+
+      # Resolve the field by `public_send`ing `@method_name`
+      class MethodResolve < BuiltInResolve
+        def initialize(method_name)
+          @method_name = method_name
+        end
+
+        def call(obj, args, ctx)
+          obj.public_send(@method_name)
+        end
+      end
+
+      # Resolve the field by looking up `@hash_key` with `#[]`
+      class HashKeyResolve < BuiltInResolve
+        def initialize(hash_key)
+          @hash_key = hash_key
+        end
+
+        def call(obj, args, ctx)
+          obj[@hash_key]
+        end
+      end
+
+      # Call the field's name at query-time since
+      # it might have changed
+      class NameResolve < BuiltInResolve
+        def initialize(field)
+          @field = field
+        end
+
+        def call(obj, args, ctx)
+          obj.public_send(@field.name)
+        end
+      end
+    end
+  end
+end