graphql 1.4.5 → 1.5.3

data/lib/generators/graphql/union_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+
+module Graphql
+  module Generators
+    # Generate a union type by name
+    # with the specified member types.
+    #
+    # ```
+    # rails g graphql:union SearchResultType ImageType AudioType
+    # ```
+    class UnionGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::UnionType with the given name and possible types"
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :possible_types,
+        type: :array,
+        default: [],
+        banner: "type type ...",
+        desc: "Possible types for this union (expressed as Ruby or GraphQL)"
+
+      def create_type_file
+        template "union.erb", "app/graphql/types/#{type_file_name}.rb"
+      end
+
+      private
+
+      def normalized_possible_types
+        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby) }
+      end
+    end
+  end
+end

data/lib/graphql.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "delegate"
 require "json"
 require "set"
 require "singleton"
@@ -16,6 +17,14 @@ module GraphQL
       @col = col
       @query = query
     end
+
+    def to_h
+      locations = line ? [{ "line" => line, "column" => col }] : []
+      {
+        "message" => message,
+        "locations" => locations,
+      }
+    end
   end
 
   # Turn a query string into an AST
@@ -85,3 +94,4 @@ require "graphql/static_validation"
 require "graphql/version"
 require "graphql/relay"
 require "graphql/compatibility"
+require "graphql/function"

data/lib/graphql/analysis/analyze_query.rb

@@ -22,7 +22,7 @@ module GraphQL
         reduce_node(op_node, reducer_states)
       end
 
-      reducer_states.map { |r| r.finalize_reducer }
+      reducer_states.map(&:finalize_reducer)
     end
 
     private

data/lib/graphql/analysis/query_complexity.rb

@@ -19,13 +19,10 @@ module GraphQL
       # State for the query complexity calcuation:
       # - `query` is needed for variables, then passed to handler
       # - `complexities_on_type` holds complexity scores for each type in an IRep node
-      # - `skip_depth` increments for each skipped node, then decrements on the way out.
-      #   While it's greater than `0`, we're visiting a skipped part of the query.
       def initial_value(query)
         {
           query: query,
           complexities_on_type: [TypeComplexity.new],
-          skip_depth: 0,
         }
       end
 
@@ -33,22 +30,12 @@ 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 irep_node.skipped?
-              memo[:skip_depth] += 1
-            elsif memo[:skip_depth] == 0
-              memo[:complexities_on_type].push(TypeComplexity.new)
-            end
+            memo[:complexities_on_type].push(TypeComplexity.new)
           else
-            if memo[:skip_depth] > 0
-              if irep_node.skipped?
-                memo[:skip_depth] -= 1
-              end
-            else
-              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.owner_type, own_complexity)
-            end
+            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.owner_type, own_complexity)
           end
         end
         memo
@@ -89,22 +76,7 @@ module GraphQL
 
         # Return the max possible complexity for types in this selection
         def max_possible_complexity
-          max_complexity = 0
-
-          @types.each do |type_defn, own_complexity|
-            type_complexity = @types.reduce(0) do |memo, (other_type, other_complexity)|
-              if types_overlap?(type_defn, other_type)
-                memo + other_complexity
-              else
-                memo
-              end
-            end
-
-            if type_complexity > max_complexity
-              max_complexity = type_complexity
-            end
-          end
-          max_complexity
+          @types.each_value.max || 0
         end
 
         # Store the complexity for the branch on `type_defn`.
@@ -112,22 +84,6 @@ module GraphQL
         def merge(type_defn, complexity)
           @types[type_defn] += complexity
         end
-
-        private
-        # True if:
-        # - type_1 is type_2
-        # - type_1 is a member of type_2's possible types
-        def types_overlap?(type_1, type_2)
-          if type_1 == type_2
-            true
-          elsif type_2.kind.union?
-            type_2.include?(type_1)
-          elsif type_1.kind.object? && type_2.kind.interface?
-            type_1.interfaces.include?(type_2)
-          else
-            false
-          end
-        end
       end
     end
   end

data/lib/graphql/analysis/query_depth.rb

@@ -25,7 +25,7 @@ module GraphQL
       def call(memo, visit_type, irep_node)
         if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
           # Don't validate introspection fields or skipped nodes
-          not_validated_node = GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name) || !irep_node.included?
+          not_validated_node = GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition_name)
           if visit_type == :enter
             if not_validated_node
               memo[:skip_depth] += 1

data/lib/graphql/argument.rb

@@ -53,5 +53,26 @@ module GraphQL
     def expose_as
       @expose_as ||= (@as || @name).to_s
     end
+
+    NO_DEFAULT_VALUE = Object.new
+    # @api private
+    def self.from_dsl(name, type = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, &block)
+      argument = if block_given?
+        GraphQL::Argument.define(&block)
+      else
+        GraphQL::Argument.new
+      end
+
+      argument.name = name.to_s
+      type && argument.type = type
+      description && argument.description = description
+      if default_value != NO_DEFAULT_VALUE
+        argument.default_value = default_value
+      end
+      argument.as = as
+
+
+      argument
+    end
   end
 end

data/lib/graphql/compatibility/execution_specification/counter_schema.rb

@@ -10,7 +10,7 @@ module GraphQL
           has_count_interface = GraphQL::InterfaceType.define do
             name "HasCount"
             field :count, types.Int
-            field :counter, ->{ counter_type }
+            field :counter, ->{ has_count_interface }
           end
 
           counter_type = GraphQL::ObjectType.define do
@@ -29,7 +29,7 @@ module GraphQL
 
           has_counter_interface = GraphQL::InterfaceType.define do
             name "HasCounter"
-            field :counter, counter_type
+            field :counter, has_count_interface
           end
 
           query_type = GraphQL::ObjectType.define do
@@ -41,7 +41,7 @@ module GraphQL
           schema = GraphQL::Schema.define(
             query: query_type,
             resolve_type: ->(o, c) { o == :counter ? counter_type : nil },
-            orphan_types: [alt_counter_type],
+            orphan_types: [alt_counter_type, counter_type],
             query_execution_strategy: execution_strategy,
           )
           schema.metadata[:count] = 0

data/lib/graphql/define.rb

@@ -3,6 +3,7 @@ require "graphql/define/assign_argument"
 require "graphql/define/assign_connection"
 require "graphql/define/assign_enum_value"
 require "graphql/define/assign_global_id_field"
+require "graphql/define/assign_mutation_function"
 require "graphql/define/assign_object_field"
 require "graphql/define/defined_object_proxy"
 require "graphql/define/instance_definable"

data/lib/graphql/define/assign_argument.rb

@@ -3,25 +3,9 @@ module GraphQL
   module Define
     # Turn argument configs into a {GraphQL::Argument}.
     module AssignArgument
-      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, :as]
-        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
-        rest.key?(:default_value) && argument.default_value = rest[:default_value]
-        argument.as = rest[:as]
-
-        target.arguments[name.to_s] = argument
+      def self.call(target, *args, **kwargs, &block)
+        argument = GraphQL::Argument.from_dsl(*args, **kwargs, &block)
+        target.arguments[argument.name] = argument
       end
     end
   end

data/lib/graphql/define/assign_mutation_function.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module GraphQL
+  module Define
+    module AssignMutationFunction
+      def self.call(target, function)
+        # TODO: get all this logic somewhere easier to test
+
+        if !function.type.is_a?(GraphQL::ObjectType)
+          raise "Mutation functions must return object types (not #{function.type.unwrap})"
+        end
+
+        target.return_type = function.type.redefine {
+          name(target.name + "Payload")
+          field :clientMutationId, types.String, "A unique identifier for the client performing the mutation.", property: :client_mutation_id
+        }
+
+        target.arguments = function.arguments
+        target.description = function.description
+        target.resolve = ->(o, a, c) {
+          res = function.call(o, a, c)
+          ResultProxy.new(res, a[:clientMutationId])
+        }
+      end
+
+      class ResultProxy < SimpleDelegator
+        attr_reader :client_mutation_id
+        def initialize(target, client_mutation_id)
+          @client_mutation_id = client_mutation_id
+          super(target)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/define/assign_object_field.rb

@@ -3,31 +3,43 @@ 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(owner_type, name, type_or_field = nil, desc = nil, field: nil, **kwargs, &block)
+      def self.call(owner_type, name, type_or_field = nil, desc = nil, function: nil, field: nil, relay_mutation_function: nil, **kwargs, &block)
         name_s = name.to_s
 
-        # Move some possitional definitions into keyword defns:
-        kwargs[:description] ||= desc
-        kwargs[:name] ||= name_s
+        # Move some positional args into keywords if they're present
+        desc && kwargs[:description] ||= desc
+        name && kwargs[:name] ||= name_s
 
         if !type_or_field.nil? && !type_or_field.is_a?(GraphQL::Field)
+          # Maybe a string, proc or BaseType
           kwargs[:type] = type_or_field
         end
 
-        # Figure out how to find or initialize the field instance:
-        if type_or_field.is_a?(GraphQL::Field)
-          field = type_or_field
-          field = field.redefine(name: name_s)
-        elsif block_given?
-          field = GraphQL::Field.define(kwargs, &block)
-        elsif field.nil?
-          field = GraphQL::Field.define(kwargs)
+        base_field = if type_or_field.is_a?(GraphQL::Field)
+          type_or_field.redefine(name: name_s)
+        elsif function
+          GraphQL::Field.define(
+            arguments: function.arguments,
+            complexity: function.complexity,
+            name: name_s,
+            type: function.type,
+            resolve: function,
+            description: function.description,
+            deprecation_reason: function.deprecation_reason,
+          )
         elsif field.is_a?(GraphQL::Field)
-          field = field.redefine(name: name_s)
+          field.redefine(name: name_s)
         else
-          raise("Couldn't find a field argument, received: #{field || type_or_field}")
+          nil
         end
 
+        field = if base_field
+          base_field.redefine(kwargs, &block)
+        else
+          GraphQL::Field.define(kwargs, &block)
+        end
+
+
         # Attach the field to the type
         owner_type.fields[name_s] = field
       end

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,16 +1,37 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
+    # This object delegates most methods to a dictionary of functions, {@dictionary}.
+    # {@target} is passed to the specified function, along with any arguments and block.
+    # This allows a method-based DSL without adding methods to the defined class.
     class DefinedObjectProxy
+      # The object which will be defined by definition functions
+      attr_reader :target
+
       def initialize(target)
         @target = target
         @dictionary = target.class.dictionary
       end
 
+      # Provides shorthand access to GraphQL's built-in types
       def types
         GraphQL::Define::TypeDefiner.instance
       end
 
+      # Allow `plugin` to perform complex initialization on the definition.
+      # Calls `plugin.use(defn, **kwargs)`.
+      # @param plugin [<#use(defn, **kwargs)>] A plugin object
+      # @param kwargs [Hash] Any options for the plugin
+      def use(plugin, **kwargs)
+        # https://bugs.ruby-lang.org/issues/10708
+        if kwargs == {}
+          plugin.use(self)
+        else
+          plugin.use(self, **kwargs)
+        end
+      end
+
+      # Lookup a function from the dictionary and call it if it's found.
       def method_missing(name, *args, &block)
         definition = @dictionary[name]
         if definition

data/lib/graphql/define/instance_definable.rb

@@ -21,19 +21,23 @@ module GraphQL
     #
     # @example Make a class definable
     #   class Car
-    #     attr_accessor :make, :model
+    #     include GraphQL::Define::InstanceDefinable
+    #     attr_accessor :make, :model, :doors
     #     accepts_definitions(
     #       # These attrs will be defined with plain setters, `{attr}=`
     #       :make, :model,
     #       # This attr has a custom definition which applies the config to the target
     #       doors: ->(car, doors_count) { doors_count.times { car.doors << Door.new } }
     #     )
+    #     ensure_defined(:make, :model, :doors)
     #
     #     def initialize
     #       @doors = []
     #     end
     #   end
     #
+    #   class Door; end;
+    #
     #   # Create an instance with `.define`:
     #   subaru_baja = Car.define do
     #     make "Subaru"
@@ -57,6 +61,27 @@ module GraphQL
     #   # Access it from metadata
     #   subaru_baja.metadata[:all_wheel_drive] # => true
     #
+    # @example Extending the definition of a class via a plugin
+    #   # A plugin is any object that responds to `.use(definition)`
+    #   module SubaruCar
+    #     extend self
+    #
+    #     def use(defn)
+    #       # `defn` has the same methods as within `.define { ... }` block
+    #       defn.make "Subaru"
+    #       defn.doors 4
+    #     end
+    #   end
+    #
+    #   # Use the plugin within a `.define { ... }` block
+    #   subaru_baja = Car.define do
+    #     use SubaruCar
+    #     model 'Baja'
+    #   end
+    #
+    #   subaru_baja.make # => "Subaru"
+    #   subaru_baja.doors # => [<Door>, <Door>, <Door>, <Door>]
+    #
     # @example Making a copy with an extended definition
     #   # Create an instance with `.define`:
     #   subaru_baja = Car.define do
@@ -91,6 +116,18 @@ module GraphQL
       def define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
+
+        method_names = self.class.ensure_defined_method_names
+        @pending_methods = method_names.map { |n| self.class.instance_method(n) }
+        self.singleton_class.class_eval do
+          method_names.each do |method_name|
+            define_method(method_name) { |*args, &block|
+              ensure_defined
+              self.send(method_name, *args, &block)
+            }
+          end
+        end
+
         @pending_definition = Definition.new(kwargs, block)
         nil
       end
@@ -119,8 +156,18 @@ module GraphQL
       # @return [void]
       def ensure_defined
         if @pending_definition
+
           defn = @pending_definition
           @pending_definition = nil
+
+          pending_methods = @pending_methods
+          self.singleton_class.class_eval {
+            pending_methods.each do |method|
+              define_method(method.name, method)
+            end
+          }
+          @pending_methods = nil
+
           defn_proxy = DefinedObjectProxy.new(self)
           # Apply definition from `define(...)` kwargs
           defn.define_keywords.each do |keyword, value|
@@ -130,6 +177,8 @@ module GraphQL
           if defn.define_proc
             defn_proxy.instance_eval(&defn.define_proc)
           end
+
+
         end
         nil
       end
@@ -171,19 +220,20 @@ module GraphQL
         end
 
         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
-          }
-          self.prepend(ensure_defined_module)
+          @ensure_defined_method_names ||= []
+          @ensure_defined_method_names.concat(method_names)
           nil
         end
 
+        def ensure_defined_method_names
+          own_method_names = @ensure_defined_method_names || []
+          if superclass.respond_to?(:ensure_defined_method_names)
+            superclass.ensure_defined_method_names + own_method_names
+          else
+            own_method_names
+          end
+        end
+
         # @return [Hash] combined definitions for self and ancestors
         def dictionary
           if superclass.respond_to?(:dictionary)