graphql 1.4.5 → 1.5.3

data/lib/graphql/directive.rb

@@ -13,7 +13,7 @@ module GraphQL
     attr_accessor :locations, :arguments, :name, :description
     # @api private
     attr_writer :default_directive
-    ensure_defined(:locations, :arguments, :name, :description, :default_directive?)
+    ensure_defined(:locations, :arguments, :name, :description, :default_directive?, :default_arguments)
 
     LOCATIONS = [
       QUERY =                  :QUERY,
@@ -83,6 +83,11 @@ module GraphQL
     def default_directive?
       @default_directive
     end
+
+    # @return [GraphQL::Query::Arguments] Arguments to use when no args are provided in the query
+    def default_arguments
+      @default_arguments ||= GraphQL::Query::LiteralInput.defaults_for(self.arguments)
+    end
   end
 end
 

data/lib/graphql/execution/directive_checks.rb

@@ -3,6 +3,7 @@ module GraphQL
   module Execution
     # Boolean checks for how an AST node's directives should
     # influence its execution
+    # @api private
     module DirectiveChecks
       SKIP = "skip"
       INCLUDE = "include"

data/lib/graphql/execution/execute.rb

@@ -2,6 +2,7 @@
 module GraphQL
   module Execution
     # A valid execution strategy
+    # @api private
     class Execute
       PROPAGATE_NULL = :__graphql_propagate_null__
 
@@ -26,13 +27,12 @@ module GraphQL
 
         selection_result = SelectionResult.new
 
-        selection.each_selection(type: current_type) do |name, subselection|
-          field = query.get_field(current_type, subselection.definition_name)
+        selection.typed_children[current_type].each do |name, subselection|
           field_result = resolve_field(
             selection_result,
             subselection,
             current_type,
-            field,
+            subselection.definition,
             object,
             query_ctx
           )
@@ -63,7 +63,7 @@ module GraphQL
           selection: selection,
         )
 
-        arguments = query.arguments_for(selection.irep_node, field)
+        arguments = query.arguments_for(selection, field)
         raw_value = begin
           query_ctx.schema.middleware.invoke([parent_type, object, field, arguments, field_ctx])
         rescue GraphQL::ExecutionError => err
@@ -83,11 +83,16 @@ module GraphQL
           continue_resolve_field(selection, parent_type, field, raw_value, field_ctx)
         end
 
-        FieldResult.new(
-          owner: owner,
-          field: field,
-          value: result,
-        )
+        case result
+        when PROPAGATE_NULL, GraphQL::Execution::Lazy, SelectionResult
+          FieldResult.new(
+            owner: owner,
+            field: field,
+            value: result,
+          )
+        else
+          result
+        end
       end
 
       def continue_resolve_field(selection, parent_type, field, raw_value, field_ctx)

data/lib/graphql/execution/field_result.rb

@@ -2,6 +2,7 @@
 module GraphQL
   module Execution
     # This is one key-value pair in a GraphQL response.
+    # @api private
     class FieldResult
       # @return [Any, Lazy] the GraphQL-ready response value, or a {Lazy} instance
       attr_reader :value

data/lib/graphql/execution/lazy.rb

@@ -10,6 +10,7 @@ module GraphQL
     # This is an itty-bitty promise-like object, with key differences:
     # - It has only two states, not-resolved and resolved
     # - It has no error-catching functionality
+    # @api private
     class Lazy
       # Traverse `val`, lazily resolving any values along the way
       # @param val [Object] A data structure containing mixed plain values and `Lazy` instances
@@ -19,16 +20,9 @@ module GraphQL
       end
 
       # Create a {Lazy} which will get its inner value by calling the block
-      # @param target [Object]
-      # @param method_name [Symbol]
       # @param get_value_func [Proc] a block to get the inner value (later)
-      def initialize(target = nil, method_name = nil, &get_value_func)
-        if block_given?
-          @get_value_func = get_value_func
-        else
-          @target = target
-          @method_name = method_name
-        end
+      def initialize(&get_value_func)
+        @get_value_func = get_value_func
         @resolved = false
       end
 
@@ -36,22 +30,19 @@ module GraphQL
       def value
         if !@resolved
           @resolved = true
-          if @get_value_func
-            @value = @get_value_func.call
-          else
-            @value = @target.public_send(@method_name)
+          @value = begin
+            @get_value_func.call
+          rescue GraphQL::ExecutionError => err
+            err
           end
         end
         @value
-      rescue GraphQL::ExecutionError => err
-        @resolved = true
-        @value = err
       end
 
       # @return [Lazy] A {Lazy} whose value depends on another {Lazy}, plus any transformations in `block`
       def then(&block)
         self.class.new {
-          next_val = block.call(value)
+          block.call(value)
         }
       end
     end

data/lib/graphql/execution/lazy/lazy_method_map.rb

@@ -5,6 +5,8 @@ module GraphQL
       # {GraphQL::Schema} uses this to match returned values to lazy resolution methods.
       # Methods may be registered for classes, they apply to its subclasses also.
       # The result of this lookup is cached for future resolutions.
+      # @api private
+      # @see {Schema#lazy?} looks up values from this map
       class LazyMethodMap
         def initialize
           @storage = Hash.new do |h, value_class|

data/lib/graphql/execution/lazy/resolve.rb

@@ -3,6 +3,7 @@ module GraphQL
   module Execution
     class Lazy
       # Helpers for dealing with data structures containing {Lazy} instances
+      # @api private
       module Resolve
         # Mutate `value`, replacing {Lazy} instances in place with their resolved values
         # @return [void]

data/lib/graphql/execution/selection_result.rb

@@ -2,6 +2,7 @@
 module GraphQL
   module Execution
     # A set of key-value pairs suitable for a GraphQL response.
+    # @api private
     class SelectionResult
       def initialize
         @storage = {}

data/lib/graphql/execution/typecast.rb

@@ -1,35 +1,48 @@
 # frozen_string_literal: true
 module GraphQL
   module Execution
-    # GraphQL object `{value, current_type}` can be cast to `potential_type` when:
-    # - `current_type == potential_type`
-    # - `current_type` is a union and it contains `potential_type`
-    # - `potential_type` is a union and it contains `current_type`
-    # - `current_type` is an interface and `potential_type` implements it
-    # - `potential_type` is an interface and `current_type` implements it
+    # @api private
     module Typecast
-      # While `value` is exposed by GraphQL as an instance of `current_type`,
-      # should it _also_ be treated as an instance of `potential_type`?
-      #
-      # This is used for checking whether fragments apply to an object.
-      #
-      # @param current_type [GraphQL::BaseType] the type which GraphQL is using now
-      # @param potential_type [GraphQL::BaseType] can this type be used from here?
-      # @param query_ctx [GraphQL::Query::Context] the context for the current query
-      # @return [Boolean] true if `value` be evaluated as a `potential_type`
-      def self.compatible?(current_type, potential_type, query_ctx)
-        if current_type == potential_type
+      # @return [Boolean]
+      def self.subtype?(parent_type, child_type)
+        if parent_type == child_type
+          # Equivalent types are subtypes
           true
-        elsif current_type.kind.union?
-          current_type.possible_types.include?(potential_type)
-        elsif potential_type.kind.union?
-          potential_type.include?(current_type)
-        elsif current_type.kind.interface? && potential_type.kind.object?
-          potential_type.interfaces.include?(current_type)
-        elsif potential_type.kind.interface? && current_type.kind.object?
-          current_type.interfaces.include?(potential_type)
+        elsif child_type.is_a?(GraphQL::NonNullType)
+          # A non-null type is a subtype of a nullable type
+          # if its inner type is a subtype of that type
+          if parent_type.is_a?(GraphQL::NonNullType)
+            subtype?(parent_type.of_type, child_type.of_type)
+          else
+            subtype?(parent_type, child_type.of_type)
+          end
         else
-          false
+          case parent_type
+          when GraphQL::InterfaceType
+            # A type is a subtype of an interface
+            # if it implements that interface
+            case child_type
+            when GraphQL::ObjectType
+              child_type.interfaces.include?(parent_type)
+            else
+              false
+            end
+          when GraphQL::UnionType
+            # A type is a subtype of that interface
+            # if the union includes that interface
+            parent_type.possible_types.include?(child_type)
+          when GraphQL::ListType
+            # A list type is a subtype of another list type
+            # if its inner type is a subtype of the other inner type
+            case child_type
+            when GraphQL::ListType
+              subtype?(parent_type.of_type, child_type.of_type)
+            else
+              false
+            end
+          else
+            false
+          end
         end
       end
     end

data/lib/graphql/field.rb

@@ -124,16 +124,18 @@ module GraphQL
     accepts_definitions :name, :description, :deprecation_reason,
       :resolve, :lazy_resolve,
       :type, :arguments,
-      :property, :hash_key, :complexity, :mutation,
+      :property, :hash_key, :complexity,
+      :mutation, :function,
       :relay_node_field,
       :relay_nodes_field,
       argument: GraphQL::Define::AssignArgument
 
     ensure_defined(
-      :name, :deprecation_reason, :description, :description=, :property, :hash_key, :mutation, :arguments, :complexity,
+      :name, :deprecation_reason, :description, :description=, :property, :hash_key,
+      :mutation, :arguments, :complexity, :function,
       :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field,
+      :relay_node_field, :relay_nodes_field, :default_arguments
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -172,17 +174,22 @@ module GraphQL
     # @return [Object, nil] The key to access with `obj.[]` to resolve this field (overrides {#name} if present)
     attr_accessor :hash_key
 
+    # @return [Object, GraphQL::Function] The function used to derive this field
+    attr_accessor :function
+
     def initialize
       @complexity = 1
       @arguments = {}
       @resolve_proc = build_default_resolver
       @lazy_resolve_proc = DefaultLazyResolve
       @relay_node_field = false
+      @default_arguments = nil
     end
 
     def initialize_copy(other)
       super
       @arguments = other.arguments.dup
+      @default_arguments = nil
     end
 
     # Get a value for this field
@@ -263,6 +270,11 @@ module GraphQL
       }
     end
 
+    # @return [GraphQL::Query::Arguments] Arguments to use when no args are provided in the query
+    def default_arguments
+      @default_arguments ||= GraphQL::Query::LiteralInput.defaults_for(self.arguments)
+    end
+
     private
 
     def build_default_resolver

data/lib/graphql/field/resolve.rb

@@ -9,7 +9,7 @@ module GraphQL
       # @return [Proc] A resolver for this field, based on its config
       def create_proc(field)
         if field.property
-          MethodResolve.new(field.property.to_sym)
+          MethodResolve.new(field)
         elsif !field.hash_key.nil?
           HashKeyResolve.new(field.hash_key)
         else
@@ -23,8 +23,8 @@ module GraphQL
 
       # Resolve the field by `public_send`ing `@method_name`
       class MethodResolve < BuiltInResolve
-        def initialize(method_name)
-          @method_name = method_name
+        def initialize(field)
+          @method_name = field.property.to_sym
         end
 
         def call(obj, args, ctx)

data/lib/graphql/function.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+module GraphQL
+  # A reusable container for field logic, including arguments, resolve, return type, and documentation.
+  #
+  # Class-level values defined with the DSL will be inherited,
+  # so {GraphQL::Function}s can extend one another.
+  #
+  # It's OK to override the instance methods here in order to customize behavior of instances.
+  #
+  # @example A reusable GraphQL::Function attached as a field
+  #   class FindRecord < GraphQL::Function
+  #     attr_reader :type
+  #
+  #     def initialize(model:, type:)
+  #       @model = model
+  #       @type = type
+  #     end
+  #
+  #     argument :id, GraphQL::ID_TYPE
+  #
+  #     def resolve(obj, args, ctx)
+  #        @model.find(args.id)
+  #     end
+  #   end
+  #
+  #   QueryType = GraphQL::ObjectType.define do
+  #     name "Query"
+  #     field :post, function: FindRecord.new(model: Post, type: PostType)
+  #     field :comment, function: FindRecord.new(model: Comment, type: CommentType)
+  #   end
+  class Function
+    # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
+    def arguments
+      self.class.arguments
+    end
+
+    # @return [GraphQL::BaseType] Return type
+    def type
+      self.class.type
+    end
+
+    # @return [Object] This function's resolver
+    def call(obj, args, ctx)
+      raise NotImplementedError
+    end
+
+    # @return [String, nil]
+    def description
+      self.class.description
+    end
+
+    # @return [String, nil]
+    def deprecation_reason
+      self.class.deprecation_reason
+    end
+
+    # @return [Integer, Proc]
+    def complexity
+      self.class.complexity || 1
+    end
+
+    class << self
+      # Define an argument for this function & its subclasses
+      # @see {GraphQL::Field} same arguments as the `argument` definition helper
+      # @return [void]
+      def argument(*args, **kwargs, &block)
+        argument = GraphQL::Argument.from_dsl(*args, **kwargs, &block)
+        own_arguments[argument.name] = argument
+        nil
+      end
+
+      # @return [Hash<String => GraphQL::Argument>] Arguments for this function class, including inherited arguments
+      def arguments
+        if parent_function?
+          own_arguments.merge(superclass.arguments)
+        else
+          own_arguments.dup
+        end
+      end
+
+      # Get or set the return type for this function class & descendants
+      # @return [GraphQL::BaseType]
+      def type(premade_type = nil, &block)
+        if block_given?
+          @type = GraphQL::ObjectType.define(&block)
+        elsif premade_type
+          @type = premade_type
+        elsif parent_function?
+          @type || superclass.type
+        else
+          @type
+        end
+      end
+
+      # Class-level reader/writer which is inherited
+      # @api private
+      def self.inherited_value(name)
+        self.class_eval <<-RUBY
+          def #{name}(new_value = nil)
+            if new_value
+              @#{name} = new_value
+            elsif parent_function?
+              @#{name} || superclass.#{name}
+            else
+              @#{name}
+            end
+          end
+        RUBY
+      end
+
+      # @!method description(new_value = nil)
+      #   Get or set this class's description
+      inherited_value(:description)
+      # @!method deprecation_reason(new_value = nil)
+      #   Get or set this class's deprecation_reason
+      inherited_value(:deprecation_reason)
+      # @!method complexity(new_value = nil)
+      #   Get or set this class's complexity
+      inherited_value(:complexity)
+
+      private
+
+      # Does this function inherit from another function?
+      def parent_function?
+        superclass <= GraphQL::Function
+      end
+
+      # Arguments defined on this class (not superclasses)
+      def own_arguments
+        @own_arguments ||= {}
+      end
+    end
+  end
+end