graphql 1.8.0.pre10 → 1.8.0.pre11

data/lib/graphql/language/parser.y

@@ -276,7 +276,7 @@ rule
    | directive_definition
 
   schema_definition:
-      SCHEMA LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, position_source: val[0], **val[2]) }
+      SCHEMA directives_list_opt LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, position_source: val[0], directives: val[1], **val[3]) }
 
   operation_type_definition_list:
       operation_type_definition

data/lib/graphql/language/printer.rb

@@ -134,11 +134,21 @@ module GraphQL
       def print_schema_definition(schema)
         if (schema.query.nil? || schema.query == 'Query') &&
            (schema.mutation.nil? || schema.mutation == 'Mutation') &&
-           (schema.subscription.nil? || schema.subscription == 'Subscription')
+           (schema.subscription.nil? || schema.subscription == 'Subscription') &&
+           (schema.directives.none?)
           return
         end
 
-        out = "schema {\n".dup
+        out = "schema".dup
+        if schema.directives.any?
+          schema.directives.each do |dir|
+            out << "\n  "
+            out << print_node(dir)
+          end
+          out << "\n{"
+        else
+          out << " {\n"
+        end
         out << "  query: #{schema.query}\n" if schema.query
         out << "  mutation: #{schema.mutation}\n" if schema.mutation
         out << "  subscription: #{schema.subscription}\n" if schema.subscription

data/lib/graphql/non_null_type.rb

@@ -33,7 +33,7 @@ module GraphQL
   #
   class NonNullType < GraphQL::BaseType
     include GraphQL::BaseType::ModifiesAnotherType
-    extend GraphQL::Delegate
+    extend Forwardable
 
     attr_reader :of_type
     def initialize(of_type:)

data/lib/graphql/query.rb

@@ -16,7 +16,7 @@ module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
     include Tracing::Traceable
-    extend GraphQL::Delegate
+    extend Forwardable
 
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)

data/lib/graphql/query/arguments.rb

@@ -5,7 +5,7 @@ module GraphQL
     #
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
-      extend GraphQL::Delegate
+      extend Forwardable
 
       def self.construct_arguments_class(argument_owner)
         argument_definitions = argument_owner.arguments

data/lib/graphql/query/context.rb

@@ -99,7 +99,7 @@ module GraphQL
       end
 
       include SharedMethods
-      extend GraphQL::Delegate
+      extend Forwardable
 
       attr_reader :execution_strategy
       # `strategy` is required by GraphQL::Batch
@@ -189,7 +189,7 @@ module GraphQL
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable
-        extend GraphQL::Delegate
+        extend Forwardable
 
         attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
         alias :selection :irep_node

data/lib/graphql/query/null_context.rb

@@ -22,7 +22,7 @@ module GraphQL
       end
 
       class << self
-        extend GraphQL::Delegate
+        extend Forwardable
 
         def instance
           @instance = self.new

data/lib/graphql/query/result.rb

@@ -6,7 +6,7 @@ module GraphQL
     # It provides the requested data and
     # access to the {Query} and {Query::Context}.
     class Result
-      extend GraphQL::Delegate
+      extend Forwardable
 
       def initialize(query:, values:)
         @query = query

data/lib/graphql/query/variables.rb

@@ -3,7 +3,7 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
-      extend GraphQL::Delegate
+      extend Forwardable
 
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors
@@ -13,7 +13,8 @@ module GraphQL
       def initialize(ctx, ast_variables, provided_variables)
         schema = ctx.schema
         @context = ctx
-        @provided_variables = provided_variables
+
+        @provided_variables = deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           # Find the right value for this variable:
@@ -27,7 +28,7 @@ module GraphQL
             variable_name = ast_variable.name
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
-            value_was_provided = @provided_variables.key?(variable_name)
+            value_was_provided =  @provided_variables.key?(variable_name)
 
             validation_result = variable_type.validate_input(provided_value, ctx)
             if !validation_result.valid?
@@ -45,6 +46,23 @@ module GraphQL
       end
 
       def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
+
+      private
+
+      def deep_stringify(val)
+        case val
+        when Array
+          val.map { |v| deep_stringify(v) }
+        when Hash
+          new_val = {}
+          val.each do |k, v|
+            new_val[k.to_s] = deep_stringify(v)
+          end
+          new_val
+        else
+          val
+        end
+      end
     end
   end
 end

data/lib/graphql/relay.rb

@@ -9,6 +9,7 @@ require 'graphql/relay/base_connection'
 require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'
 require 'graphql/relay/relation_connection'
+require 'graphql/relay/mongo_relation_connection'
 require 'graphql/relay/global_id_resolve'
 require 'graphql/relay/mutation'
 require 'graphql/relay/node'

data/lib/graphql/relay/mongo_relation_connection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # A connection implementation to expose MongoDB collection objects.
+    # It works for:
+    # - `Mongoid::Criteria`
+    class MongoRelationConnection < RelationConnection
+      private
+
+      def relation_offset(relation)
+        relation.options.skip
+      end
+
+      def relation_limit(relation)
+        relation.options.limit
+      end
+
+      def relation_count(relation)
+        # Must perform query (hence #to_a) to count results https://jira.mongodb.org/browse/MONGOID-2325
+        relation.to_a.count
+      end
+
+      def limit_nodes(sliced_nodes, limit)
+        if limit == 0
+          if sliced_nodes.respond_to?(:none) # added in Mongoid 4.0
+            sliced_nodes.without_options.none
+          else
+            sliced_nodes.where(id: nil) # trying to simulate #none for 3.1.7
+          end
+        else
+          sliced_nodes.limit(limit)
+        end
+      end
+    end
+
+    if defined?(Mongoid::Criteria)
+      BaseConnection.register_connection_implementation(Mongoid::Criteria, MongoRelationConnection)
+    end
+  end
+end

data/lib/graphql/scalar_type.rb

@@ -56,7 +56,7 @@ module GraphQL
   # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
   #
   # @example custom error response
-  # {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
+  #   {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
   #
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
@@ -109,7 +109,19 @@ module GraphQL
     end
 
     def coerce_non_null_input(value, ctx)
-      @coerce_input_proc.call(value, ctx)
+      @coerce_input_proc.call(raw_coercion_input(value), ctx)
+    end
+
+    def raw_coercion_input(value)
+      if value.is_a?(GraphQL::Language::Nodes::InputObject)
+        value.to_h
+      elsif value.is_a?(Array)
+        value.map { |element| raw_coercion_input(element) }
+      elsif value.is_a?(GraphQL::Language::Nodes::Enum)
+        value.name
+      else
+        value
+      end
     end
 
     def validate_non_null_input(value, ctx)

data/lib/graphql/schema.rb

@@ -21,6 +21,8 @@ require "graphql/schema/build_from_definition"
 
 
 require "graphql/schema/member"
+require "graphql/schema/list"
+require "graphql/schema/non_null"
 require "graphql/schema/argument"
 require "graphql/schema/enum_value"
 require "graphql/schema/enum"
@@ -632,7 +634,7 @@ module GraphQL
     end
 
     class << self
-      extend GraphQL::Delegate
+      extend Forwardable
       # For compatibility, these methods all:
       # - Cause the Schema instance to be created, if it hasn't been created yet
       # - Delegate to that instance
@@ -656,6 +658,7 @@ module GraphQL
         # Members
         :types, :get_fields, :find,
         :root_type_for_operation,
+        :subscriptions,
         :union_memberships,
         :get_field, :root_types, :references_to, :type_from_ast,
         :possible_types, :get_field
@@ -692,6 +695,7 @@ module GraphQL
         schema_defn.cursor_encoder = cursor_encoder
         schema_defn.tracers.concat(defined_tracers)
         schema_defn.query_analyzers.concat(defined_query_analyzers)
+        schema_defn.middleware.concat(defined_middleware)
         schema_defn.multiplex_analyzers.concat(defined_multiplex_analyzers)
         defined_instrumenters.each do |step, insts|
           insts.each do |inst|
@@ -863,6 +867,14 @@ module GraphQL
         defined_query_analyzers << new_analyzer
       end
 
+      def middleware(new_middleware = nil)
+        if new_middleware
+          defined_middleware << new_middleware
+        else
+          graphql_definition.middleware
+        end
+      end
+
       def multiplex_analyzer(new_analyzer)
         defined_multiplex_analyzers << new_analyzer
       end
@@ -885,6 +897,10 @@ module GraphQL
         @defined_query_analyzers ||= []
       end
 
+      def defined_middleware
+        @defined_middleware ||= []
+      end
+
       def defined_multiplex_analyzers
         @defined_multiplex_analyzers ||= []
       end

data/lib/graphql/schema/argument.rb

@@ -7,26 +7,37 @@ module GraphQL
 
       NO_DEFAULT = :__no_default__
 
+      # @return [String] the GraphQL name for this argument, camelized unless `camelize: false` is provided
       attr_reader :name
 
       # @return [GraphQL::Schema::Field, Class] The field or input object this argument belongs to
       attr_reader :owner
 
+      # @return [Symbol] A method to call to transform this value before sending it to field resolution method
+      attr_reader :prepare
+
+      # @return [Symbol] This argument's name in Ruby keyword arguments
+      attr_reader :keyword
+
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
       # @param required [Boolean] if true, this argument is non-null; if false, this argument is nullable
       # @param description [String]
       # @param default_value [Object]
+      # @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, camelize: true, owner:, &definition_block)
-        @name = arg_name.to_s
+      def initialize(arg_name, type_expr, desc = nil, required:, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+        @name = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
         @type_expr = type_expr
         @description = desc || description
         @null = !required
         @default_value = default_value
-        @camelize = camelize
         @owner = owner
+        @as = as
+        @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
+        @prepare = prepare
 
         if definition_block
           instance_eval(&definition_block)
@@ -43,17 +54,38 @@ module GraphQL
 
       def to_graphql
         argument = GraphQL::Argument.new
-        argument.name = @camelize ? Member::BuildType.camelize(@name) : @name
-        argument.type = -> {
-          Member::BuildType.parse_type(@type_expr, null: @null)
-        }
+        argument.name = @name
+        argument.type = -> { type }
         argument.description = @description
         argument.metadata[:type_class] = self
+        argument.as = @as
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end
         argument
       end
+
+      def type
+        @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
+      rescue StandardError => err
+        raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+      end
+
+      # Apply the {prepare} configuration to `value`, using methods from `obj`.
+      # Used by the runtime.
+      # @api private
+      def prepare_value(obj, value)
+        case @prepare
+        when nil
+          value
+        when Symbol, String
+          obj.public_send(@prepare, value)
+        when Proc
+          @prepare.call(value, obj.context)
+        else
+          raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/enum.rb

@@ -23,6 +23,9 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
 
       class << self
+        extend Forwardable
+        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
+
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
         # @param description [String], the GraphQL description for this value, present in documentation
@@ -65,6 +68,10 @@ module GraphQL
           @enum_value_class || (superclass <= GraphQL::Schema::Enum ? superclass.enum_value_class : nil)
         end
 
+        def kind
+          GraphQL::TypeKinds::ENUM
+        end
+
         private
 
         def own_values

data/lib/graphql/schema/field.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 # test_via: ../object.rb
-require "graphql/schema/field/dynamic_resolve"
-require "graphql/schema/field/unwrapped_resolve"
 module GraphQL
   class Schema
     class Field
@@ -9,14 +7,17 @@ module GraphQL
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasArguments
 
-      # @return [String]
+      # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided
       attr_reader :name
 
       # @return [String]
       attr_accessor :description
 
-      # @return [Symbol]
-      attr_reader :method
+      # @return [Symbol] Method or hash key to look up
+      attr_reader :method_sym
+
+      # @return [String] Method or hash key to look up
+      attr_reader :method_str
 
       # @return [Class] The type that this field belongs to
       attr_reader :owner
@@ -52,7 +53,7 @@ module GraphQL
           desc = return_type_expr
           return_type_expr = nil
         end
-        if mutation && (return_type_expr || desc || description || function || field || null || deprecation_reason || method || resolve || introspection || hash_key)
+        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"
         end
         if !(field || function || mutation)
@@ -66,7 +67,10 @@ module GraphQL
         if (field || function || resolve || resolve) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve, please remove `field:`, `function:`, `resolve:`, or `mutation:`"
         end
-        @name = name.to_s
+        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
@@ -82,8 +86,12 @@ module GraphQL
         if method && hash_key
           raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
         end
-        @method = method
-        @hash_key = hash_key
+
+        # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
+        method_name = method || hash_key || Member::BuildType.underscore(name.to_s)
+
+        @method_str = method_name.to_s
+        @method_sym = method_name.to_sym
         @complexity = complexity
         @return_type_expr = return_type_expr
         @return_type_null = null
@@ -91,7 +99,6 @@ module GraphQL
         @max_page_size = max_page_size
         @introspection = introspection
         @extras = extras
-        @camelize = camelize
         @mutation = mutation
         @mutation_class = mutation_class
         # Override the default from HasArguments
@@ -140,7 +147,6 @@ module GraphQL
           return field_inst.to_graphql
         end
 
-        method_name = @method || @hash_key || Member::BuildType.underscore(@name)
 
         field_defn = if @field
           @field.dup
@@ -150,22 +156,21 @@ module GraphQL
           GraphQL::Field.new
         end
 
-        field_defn.name = @camelize ? Member::BuildType.camelize(name) : name
+        field_defn.name = @name
         if @return_type_expr
-          return_type_name = Member::BuildType.to_type_name(@return_type_expr)
-          connection = @connection.nil? ? return_type_name.end_with?("Connection") : @connection
-          field_defn.type = -> {
-            begin
-              Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
-            rescue
-              raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: #{$!.message}", $!.backtrace
-            end
-          }
-        elsif @connection.nil? && (@field || @function)
-          return_type_name = Member::BuildType.to_type_name(field_defn.type)
-          connection = return_type_name.end_with?("Connection")
-        else
-          connection = @connection
+          field_defn.type = -> { type }
+        end
+
+        if @connection.nil?
+          # Provide default based on type name
+          return_type_name = if @field || @function
+            Member::BuildType.to_type_name(field_defn.type)
+          elsif @return_type_expr
+            Member::BuildType.to_type_name(@return_type_expr)
+          else
+            raise "No connection info possible"
+          end
+          @connection = return_type_name.end_with?("Connection")
         end
 
         if @description
@@ -180,24 +185,14 @@ module GraphQL
           field_defn.mutation = @mutation_class
         end
 
-        field_defn.resolve = if @resolve || @function || @field
-          prev_resolve = @resolve || field_defn.resolve_proc
-          UnwrappedResolve.new(inner_resolve: prev_resolve)
-        else
-          DynamicResolve.new(
-            method_name: method_name,
-            connection: connection,
-            extras: @extras
-          )
-        end
-
-        field_defn.connection = connection
+        field_defn.resolve = self.method(:resolve_field)
+        field_defn.connection = @connection
         field_defn.connection_max_page_size = @max_page_size
         field_defn.introspection = @introspection
         field_defn.complexity = @complexity
 
         # apply this first, so it can be overriden below
-        if connection
+        if @connection
           # TODO: this could be a bit weird, because these fields won't be present
           # after initialization, only in the `to_graphql` response.
           # This calculation _could_ be moved up if need be.
@@ -212,8 +207,119 @@ module GraphQL
           field_defn.arguments[arg_graphql.name] = arg_graphql
         end
 
+        # Ok, `self` isn't a class, but this is for consistency with the classes
+        field_defn.metadata[:type_class] = self
+
         field_defn
       end
+
+      def type
+        @type ||= Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+      rescue
+        raise ArgumentError, "Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: #{$!.message}", $!.backtrace
+      end
+
+      # Implement {GraphQL::Field}'s resolve API.
+      #
+      # 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
+
+          # 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)
+        else
+          public_send_field(obj, args, ctx)
+        end
+      end
+
+      # Find a way to resolve this field, checking:
+      #
+      # - Hash keys, if the wrapped object is a hash;
+      # - A method on the wrapped object;
+      # - Or, raise not implemented.
+      #
+      # This can be overridden by defining a method on the object type.
+      # @param obj [GraphQL::Schema::Object]
+      # @param ruby_kwargs [Hash<Symbol => Object>]
+      # @param ctx [GraphQL::Query::Context]
+      def resolve_field_method(obj, ruby_kwargs, ctx)
+        if obj.object.is_a?(Hash)
+          inner_object = obj.object
+          if inner_object.key?(@method_sym)
+            inner_object[@method_sym]
+          else
+            inner_object[@method_str]
+          end
+        elsif obj.object.respond_to?(@method_sym)
+          if ruby_kwargs.any?
+            obj.object.public_send(@method_sym, **ruby_kwargs)
+          else
+            obj.object.public_send(@method_sym)
+          end
+        else
+          raise <<-ERR
+        Failed to implement #{@owner.graphql_name}.#{@name}, tried:
+
+        - `#{obj.class}##{@method_sym}`, which did not exist
+        - `#{obj.object.class}##{@method_sym}`, which did not exist
+        - Looking up hash key `#{@method_sym.inspect}` or `#{@method_str.inspect}` on `#{obj.object}`, but it wasn't a Hash
+
+        To implement this field, define one of the methods above (and check for typos)
+        ERR
+        end
+      end
+
+      private
+
+      NO_ARGS = {}.freeze
+
+      def public_send_field(obj, graphql_args, field_ctx)
+        if graphql_args.any? || @extras.any?
+          # Splat the GraphQL::Arguments to Ruby keyword arguments
+          ruby_kwargs = graphql_args.to_kwargs
+          # Apply any `prepare` methods. Not great code organization, can this go somewhere better?
+          arguments.each do |name, arg_defn|
+            ruby_kwargs_key = arg_defn.keyword
+            if ruby_kwargs.key?(ruby_kwargs_key) && arg_defn.prepare
+              ruby_kwargs[ruby_kwargs_key] = arg_defn.prepare_value(obj, ruby_kwargs[ruby_kwargs_key])
+            end
+          end
+
+          if @connection
+            # Remove pagination args before passing it to a user method
+            ruby_kwargs.delete(:first)
+            ruby_kwargs.delete(:last)
+            ruby_kwargs.delete(:before)
+            ruby_kwargs.delete(:after)
+          end
+
+          @extras.each do |extra_arg|
+            # TODO: provide proper tests for `:ast_node`, `:irep_node`, `:parent`, others?
+            ruby_kwargs[extra_arg] = field_ctx.public_send(extra_arg)
+          end
+        else
+          ruby_kwargs = NO_ARGS
+        end
+
+
+        if ruby_kwargs.any?
+          obj.public_send(@method_sym, **ruby_kwargs)
+        else
+          obj.public_send(@method_sym)
+        end
+      end
     end
   end
 end