graphql 1.8.0.pre11 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9824961c7be659d7f815105dce1ed73cb0524b8
-  data.tar.gz: '08b3edfb6cc0fa00917cae9faf8c6c166e1cd2a8'
+  metadata.gz: f5283bf51e22ac60f8d9368d9cc19b8c6d038d8b
+  data.tar.gz: 147ec429661a6fbc1aaef685ba94c8a81d87910e
 SHA512:
-  metadata.gz: 69707f9127dddff3f1039b066db1a46f1c2bd8a3b9527d4d73bd109734026da47623eb602a9988c300edef8ddf978ddc12fab355248895fcab6d37397ed7b00b
-  data.tar.gz: 958bb3dd36b858af4273df812cdec568e463e9719efea31b1ba5249fce424259097d80c40ef70ffed61971e27b4d956287c26d82a9274a2e7df34b106fc9e6fe
+  metadata.gz: 06a2a8730fc1c13dc0a0d76a35b19e89dd40ad842e41618abb1b05a7f75b667eede56c106728e3e68bd531e36e29b28050b991319599b7952ac3285fb3f9be3c
+  data.tar.gz: 8231c7696681477decf92b0665f3e4249b308153338c8d7cf5102b7e95133b9ac7aa6156f3dddc026c4178ea9fcb25d7f181f752298d5cf38185141af653a471

data/lib/generators/graphql/templates/schema.erb

@@ -21,7 +21,7 @@
   }
 
   # Object Resolution
-  resolve_type -> (obj, ctx) {
+  resolve_type -> (type, obj, ctx) {
     # TODO: Implement this function
     # to return the correct type for `obj`
     raise(NotImplementedError)

data/lib/graphql/function.rb

@@ -28,6 +28,8 @@ module GraphQL
   #     field :post, function: FindRecord.new(model: Post, type: PostType)
   #     field :comment, function: FindRecord.new(model: Comment, type: CommentType)
   #   end
+  #
+  # @see {GraphQL::Schema::Resolver} for a replacement for `GraphQL::Function`
   class Function
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
     def arguments

data/lib/graphql/railtie.rb

@@ -72,7 +72,7 @@ module GraphQL
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseInterface < GraphQL::Schema::Interface\nend"
+                f.write "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
               end
             end
 

data/lib/graphql/schema.rb

@@ -29,6 +29,7 @@ require "graphql/schema/enum"
 require "graphql/schema/field"
 require "graphql/schema/input_object"
 require "graphql/schema/interface"
+require "graphql/schema/resolver"
 require "graphql/schema/mutation"
 require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/object"

data/lib/graphql/schema/argument.rb

@@ -28,9 +28,10 @@ module GraphQL
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to tranform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
-      def initialize(arg_name, type_expr, desc = nil, required:, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+        arg_name ||= name
         @name = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
-        @type_expr = type_expr
+        @type_expr = type_expr || type
         @description = desc || description
         @null = !required
         @default_value = default_value

data/lib/graphql/schema/build_from_definition.rb

@@ -237,7 +237,7 @@ module GraphQL
               **kwargs,
             )
 
-            argument.ast_node = input_object_type_definition
+            argument.ast_node = input_argument
 
             [
               input_argument.name,

data/lib/graphql/schema/field.rb

@@ -8,7 +8,7 @@ module GraphQL
       include GraphQL::Schema::Member::HasArguments
 
       # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
-      attr_reader :name
+      attr_accessor :name
 
       # @return [String]
       attr_accessor :description
@@ -22,9 +22,55 @@ module GraphQL
       # @return [Class] The type that this field belongs to
       attr_reader :owner
 
-      # @return [Class, nil] The mutation this field was derived from, if there is one
-      def mutation
-        @mutation || @mutation_class
+
+      # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one
+      def resolver
+        @resolver_class
+      end
+
+      alias :mutation :resolver
+
+      # Create a field instance from a list of arguments, keyword arguments, and a block.
+      #
+      # This method implements prioritization between the `resolver` or `mutation` defaults
+      # and the local overrides via other keywords.
+      #
+      # It also normalizes positional arguments into keywords for {Schema::Field#initialize}.
+      # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration
+      # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration
+      # @return [GraphQL::Schema:Field] an instance of `self
+      # @see {.initialize} for other options
+      def self.from_options(name = nil, type = nil, desc = nil, resolver: nil, mutation: nil, **kwargs, &block)
+        if (parent_config = resolver || mutation)
+          # Get the parent config, merge in local overrides
+          kwargs = parent_config.field_options.merge(kwargs)
+          # Add a reference to that parent class
+          kwargs[:resolver_class] = parent_config
+        end
+
+        if name
+          kwargs[:name] = name
+        end
+
+        if !type.nil?
+          if type.is_a?(GraphQL::Field)
+            raise ArgumentError, "A GraphQL::Field was passed as the second argument, use the `field:` keyword for this instead."
+          end
+          if desc
+            if kwargs[:description]
+              raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{kwargs[:description].inspect})"
+            end
+
+            kwargs[:description] = desc
+            kwargs[:type] = type
+          elsif (kwargs[:field] || kwargs[:function] || resolver || mutation) && type.is_a?(String)
+            # The return type should be copied from `field` or `function`, and the second positional argument is the description
+            kwargs[:description] = type
+          else
+            kwargs[:type] = type
+          end
+        end
+        new(**kwargs, &block)
       end
 
       # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
@@ -42,39 +88,29 @@ module GraphQL
       # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
       # @param field [GraphQL::Field, GraphQL::Schema::Field] **deprecated** for compatibility with <1.8.0
       # @param function [GraphQL::Function] **deprecated** for compatibility with <1.8.0
-      # @param mutation [Class] A {Schema::Mutation} class for serving this field
-      # @param mutation_class [Class] (Private) A {Schema::Mutation} which this field was derived from.
-      # @param arguments [{String=>GraphQL::Schema::Arguments}] Arguments for this field (may be added in the block, also)
+      # @param resolver_class [Class] (Private) A {Schema::Resolver} which this field was derived from. Use `resolver:` to create a field with a resolver.
+      # @param arguments [{String=>GraphQL::Schema::Argument, Hash}] Arguments for this field (may be added in the block, also)
       # @param camelize [Boolean] If true, the field name will be camelized when building the schema
       # @param complexity [Numeric] When provided, set the complexity for this field
-      def initialize(name, return_type_expr = nil, desc = nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], mutation: nil, mutation_class: nil, arguments: {}, &definition_block)
-        if (field || function) && desc.nil? && return_type_expr.is_a?(String)
-          # The return type should be copied from `field` or `function`, and the second positional argument is the description
-          desc = return_type_expr
-          return_type_expr = nil
-        end
-        if mutation && (return_type_expr || desc || description || function || field || !null.nil? || deprecation_reason || method || resolve || introspection || hash_key)
-          raise ArgumentError, "when keyword `mutation:` is present, all arguments are ignored, please remove them"
+      # @param subscription_scope [Symbol, String] A key in `context` which will be used to scope subscription payloads
+      def initialize(type: nil, name: nil, owner: nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, hash_key: nil, camelize: true, complexity: 1, extras: [], resolver_class: nil, subscription_scope: nil, arguments: {}, &definition_block)
+
+        if name.nil?
+          raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
-        if !(field || function || mutation)
-          if return_type_expr.nil?
-            raise ArgumentError, "missing positional argument `type`"
+        if !(field || function || mutation || resolver)
+          if type.nil?
+            raise ArgumentError, "missing second `type` argument or keyword `type:`"
           end
           if null.nil?
             raise ArgumentError, "missing keyword argument null:"
           end
         end
-        if (field || function || resolve || resolve) && extras.any?
+        if (field || function || resolve || mutation) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve, please remove `field:`, `function:`, `resolve:`, or `mutation:`"
         end
-        if return_type_expr.is_a?(GraphQL::Field)
-          raise ArgumentError, "A GraphQL::Field was passed as the second argument, use the `field:` keyword for this instead."
-        end
         @name = camelize ? Member::BuildType.camelize(name.to_s) : name.to_s
-        if description && desc
-          raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{description.inspect})"
-        end
-        @description = description || desc
+        @description = description
         if field.is_a?(GraphQL::Schema::Field)
           @field_instance = field
         else
@@ -93,17 +129,26 @@ module GraphQL
         @method_str = method_name.to_s
         @method_sym = method_name.to_sym
         @complexity = complexity
-        @return_type_expr = return_type_expr
+        @return_type_expr = type
         @return_type_null = null
         @connection = connection
         @max_page_size = max_page_size
         @introspection = introspection
         @extras = extras
-        @mutation = mutation
-        @mutation_class = mutation_class
+        @resolver_class = resolver_class
+
         # Override the default from HasArguments
-        @own_arguments = arguments
+        @own_arguments = {}
+        arguments.each do |name, arg|
+          if arg.is_a?(Hash)
+            argument(name: name, **arg)
+          else
+            @own_arguments[name] = arg
+          end
+        end
+
         @owner = owner
+        @subscription_scope = subscription_scope
 
         if definition_block
           instance_eval(&definition_block)
@@ -142,9 +187,6 @@ module GraphQL
         # this field was previously defined and passed here, so delegate to it
         if @field_instance
           return @field_instance.to_graphql
-        elsif @mutation
-          field_inst = @mutation.graphql_field
-          return field_inst.to_graphql
         end
 
 
@@ -181,8 +223,11 @@ module GraphQL
           field_defn.deprecation_reason = @deprecation_reason
         end
 
-        if @mutation_class
-          field_defn.mutation = @mutation_class
+        if @resolver_class
+          if @resolver_class < GraphQL::Schema::Mutation
+            field_defn.mutation = @resolver_class
+          end
+          field_defn.metadata[:resolver] = @resolver_class
         end
 
         field_defn.resolve = self.method(:resolve_field)
@@ -190,6 +235,7 @@ module GraphQL
         field_defn.connection_max_page_size = @max_page_size
         field_defn.introspection = @introspection
         field_defn.complexity = @complexity
+        field_defn.subscription_scope = @subscription_scope
 
         # apply this first, so it can be overriden below
         if @connection
@@ -207,6 +253,15 @@ module GraphQL
           field_defn.arguments[arg_graphql.name] = arg_graphql
         end
 
+        # Support a passed-in proc, one way or another
+        @resolve_proc = if @resolve
+          @resolve
+        elsif @function
+          @function
+        elsif @field
+          @field.resolve_proc
+        end
+
         # Ok, `self` isn't a class, but this is for consistency with the classes
         field_defn.metadata[:type_class] = self
 
@@ -223,22 +278,14 @@ module GraphQL
       #
       # Eventually, we might hook up field instances to execution in another way. TBD.
       def resolve_field(obj, args, ctx)
-        if @resolve || @function || @field
-          # Support a passed-in proc, one way or another
-          prev_resolve = if @resolve
-            @resolve
-          elsif @function
-            @function
-          elsif @field
-            @field.resolve_proc
-          end
-
+        if @resolve_proc
           # Might be nil, still want to call the func in that case
           inner_obj = obj && obj.object
-          prev_resolve.call(inner_obj, args, ctx)
-        elsif @mutation_class
-          mutation_inst = @mutation_class.new(object: obj, arguments: args, context: ctx.query.context)
-          public_send_field(mutation_inst, args, ctx)
+          @resolve_proc.call(inner_obj, args, ctx)
+        elsif @resolver_class
+          inner_obj = obj && obj.object
+          singleton_inst = @resolver_class.new(object: inner_obj, context: ctx.query.context)
+          public_send_field(singleton_inst, args, ctx)
         else
           public_send_field(obj, args, ctx)
         end

data/lib/graphql/schema/interface.rb

@@ -22,12 +22,22 @@ module GraphQL
           if !child_class.is_a?(Class)
             # In this case, it's been included into another interface.
             # This is how interface inheritance is implemented
-            child_class.const_set(:DefinitionMethods, Module.new)
-            child_class.extend(child_class::DefinitionMethods)
+
+            # Use an instance variable to tell whether it's been included previously or not;
+            # You can't use constant detection because constants are brought into scope
+            # by `include`, which has already happened at this point.
+            if !child_class.instance_variable_defined?(:@_definition_methods)
+              defn_methods_module = Module.new
+              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
+              child_class.const_set(:DefinitionMethods, defn_methods_module)
+              child_class.extend(child_class::DefinitionMethods)
+            end
+
             # We need this before we can call `own_interfaces`
             child_class.extend(Schema::Interface::DefinitionMethods)
+
             child_class.own_interfaces << self
-            child_class.own_interfaces.each do |interface_defn|
+            child_class.interfaces.each do |interface_defn|
               child_class.extend(interface_defn::DefinitionMethods)
             end
           elsif child_class < GraphQL::Schema::Object
@@ -76,12 +86,20 @@ module GraphQL
         def own_interfaces
           @own_interfaces ||= []
         end
+
+        def interfaces
+          own_interfaces + (own_interfaces.map { |i| i.own_interfaces }).flatten
+        end
       end
 
       # Extend this _after_ `DefinitionMethods` is defined, so it will be used
       extend GraphQL::Schema::Member::AcceptsDefinition
 
       extend DefinitionMethods
+
+      def unwrap
+        self
+      end
     end
   end
 end

data/lib/graphql/schema/list.rb

@@ -23,6 +23,10 @@ module GraphQL
       def kind
         GraphQL::TypeKinds::LIST
       end
+
+      def unwrap
+        @of_type.unwrap
+      end
     end
   end
 end

data/lib/graphql/schema/member/accepts_definition.rb

@@ -69,7 +69,7 @@ module GraphQL
                 if args.any?
                   instance_variable_set(ivar_name, args)
                 end
-                instance_variable_get(ivar_name)
+                instance_variable_get(ivar_name) || (superclass.respond_to?(name) ? superclass.public_send(name) : nil)
               end
 
               define_method(name) do |*args|
@@ -86,7 +86,7 @@ module GraphQL
                   if args.any?
                     instance_variable_set(ivar_name, args)
                   end
-                  instance_variable_get(ivar_name)
+                  instance_variable_get(ivar_name) || ((int = interfaces.first { |i| i.respond_to?()}) && int.public_send(name))
                 end
               end
             end

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -76,6 +76,10 @@ module GraphQL
           @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
         end
 
+        def unwrap
+          self
+        end
+
         private
 
         def find_inherited_method(method_name, default_value)

data/lib/graphql/schema/member/build_type.rb

@@ -101,13 +101,15 @@ module GraphQL
           when Array
             to_type_name(something.first)
           when Module
-            if something < GraphQL::Schema::Member
+            if something.respond_to?(:graphql_name)
               something.graphql_name
             else
-              something.name.split("::").last
+              to_type_name(something.name)
             end
           when String
             something.gsub(/\]\[\!/, "").split("::").last
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            to_type_name(something.unwrap)
           else
             raise "Unhandled to_type_name input: #{something} (#{something.class})"
           end

data/lib/graphql/schema/member/has_fields.rb

@@ -49,7 +49,7 @@ module GraphQL
         # @see {GraphQL::Schema::Field#initialize} for method signature
         # @return [void]
         def field(*args, **kwargs, &block)
-          field_defn = build_field(*args, **kwargs, &block)
+          field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
           add_field(field_defn)
           nil
         end
@@ -103,13 +103,6 @@ module GraphQL
         end
 
         private
-
-        # Initialize a field with this class's field class, but don't attach it.
-        def build_field(*args, **kwargs, &block)
-          kwargs[:owner] = self
-          field_class.new(*args, **kwargs, &block)
-        end
-
         # Find the magic module for holding super methods,
         # and add a field named `method_name` for implementing the field
         # called `field_name`.

data/lib/graphql/schema/mutation.rb

@@ -58,51 +58,16 @@ module GraphQL
     #  }
     #  GRAPHQL
     #
-    class Mutation < GraphQL::Schema::Member
+    class Mutation < GraphQL::Schema::Resolver
       extend GraphQL::Schema::Member::HasFields
-      extend GraphQL::Schema::Member::HasArguments
-
-      # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
-      # @param context [GraphQL::Query::Context]
-      def initialize(object:, context:, arguments:)
-        @object = object
-        @context = context
-      end
-
-      # @return [Object] the root value of the operation
-      attr_reader :object
-
-      # @return [GraphQL::Query::Context]
-      attr_reader :context
-
-      # Do the work. Everything happens here.
-      # @return [Hash] A key for each field in the return type
-      # @return [Object] An object corresponding to the return type
-      def resolve(**args)
-        raise NotImplementedError, "#{self.class.name}#resolve should execute side effects and return a Symbol-keyed hash"
-      end
-
-      # This is a hook for classes to intercept resolution.
-      # @see RelayClassicMutation for usage
-      def resolve_mutation(args)
-        resolve(args)
-      end
 
       class << self
-        def inherited(base)
-          base.null(null)
-          super
-        end
-
-        # Override the method from HasFields to support `field: Mutation.field`, for backwards compat.
-        #
-        # If called without any arguments, returns a `GraphQL::Field`.
-        # @see {GraphQL::Schema::Member::HasFields.field} for default behavior
+        # Override this method to handle legacy-style usages of `MyMutation.field`
         def field(*args, &block)
-          if args.none? && !block_given?
-            graphql_field.graphql_definition
+          if args.none?
+            raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
           else
-            super(*args, &block)
+            super
           end
         end
 
@@ -118,20 +83,8 @@ module GraphQL
           @payload_type ||= generate_payload_type
         end
 
-        # @return [GraphQL::Schema::Field] The generated field instance for this mutation
-        # @see {GraphQL::Schema::Field}'s `mutation:` option, don't call this directly
-        def graphql_field
-          @graphql_field ||= generate_field
-        end
-
-        # @param new_name [String, nil] if present, override the class name to set this value
-        # @return [String] The name of this mutation in the GraphQL schema (used for naming derived types and fields)
-        def graphql_name(new_name = nil)
-          if new_name
-            @graphql_name = new_name
-          end
-          @graphql_name ||= self.name.split("::").last
-        end
+        alias :type :payload_type
+        alias :type_expr :payload_type
 
         # An object class to use for deriving payload types
         # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
@@ -143,23 +96,22 @@ module GraphQL
           @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
         end
 
-        # Additional info injected into {#resolve}
-        # @see {GraphQL::Schema::Field#extras}
-        def extras(new_extras = nil)
-          if new_extras
-            @extras = new_extras
+        def field_class(new_class = nil)
+          if new_class
+            @field_class = new_class
+          else
+            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
           end
-          @extras || []
         end
 
-        # Specifies whether or not the mutation is nullable. Defaults to `true`
-        # @param allow_null [Boolean] Whether or not the response can be null
-        def null(allow_null = nil)
-          unless allow_null.nil?
-            @null = allow_null
+        # An object class to use for deriving return types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            @object_class = new_class
           end
-
-          @null.nil? ? true : @null
+          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
         end
 
         private
@@ -180,27 +132,6 @@ module GraphQL
             end
           end
         end
-
-        # This name will be used for the {.graphql_field}.
-        def field_name
-          graphql_name.sub(/^[A-Z]/, &:downcase)
-        end
-
-        # Build an instance of {.field_class} which will be used to execute this mutation.
-        # To customize field generation, override this method.
-        def generate_field
-          # TODO support deprecation_reason
-          self.field_class.new(
-            field_name,
-            payload_type,
-            description,
-            extras: extras,
-            method: :resolve_mutation,
-            mutation_class: self,
-            arguments: arguments,
-            null: null,
-          )
-        end
       end
     end
   end