graphql 1.8.0.pre2 → 1.8.0.pre3

data/lib/graphql/object_type.rb

@@ -32,7 +32,7 @@ module GraphQL
     #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
 
     # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
+    #   @return [GraphQL::Relay::Mutation, nil] The mutation this object type was derived from, if it is an auto-generated payload type.
 
     def initialize
       super

data/lib/graphql/query.rb

@@ -79,7 +79,7 @@ module GraphQL
     def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: {}, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
       @schema = schema
       @filter = schema.default_filter.merge(except: except, only: only)
-      @context = Context.new(query: self, object: root_value, values: context)
+      @context = schema.context_class.new(query: self, object: root_value, values: context)
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil

data/lib/graphql/query/arguments.rb

@@ -35,13 +35,14 @@ module GraphQL
         end
       end
 
-      def initialize(values, context:)
+      def initialize(values, context:, defaults_used:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          arg_defn = self.class.argument_definitions[inner_key.to_s]
-
+          arg_name = inner_key.to_s
+          arg_defn = self.class.argument_definitions[arg_name]
+          arg_default_used = defaults_used.include?(arg_name)
           arg_value = wrap_value(inner_value, arg_defn.type, context)
           string_key = arg_defn.expose_as
-          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn)
+          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn, arg_default_used)
           memo
         end
       end
@@ -60,6 +61,13 @@ module GraphQL
         @argument_values.key?(key_s)
       end
 
+      # @param key [String, Symbol] name of value to access
+      # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+      def default_used?(key)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).default_used?
+      end
+
       # Get the hash of all values, with stringified keys
       # @return [Hash] the stringified hash
       def to_h
@@ -92,20 +100,28 @@ module GraphQL
         self.argument_definitions = []
       end
 
-      NO_ARGS = NoArguments.new({}, context: nil)
+      NO_ARGS = NoArguments.new({}, context: nil, defaults_used: Set.new)
 
       private
 
       class ArgumentValue
         attr_reader :key, :value, :definition
-        def initialize(key, value, definition)
+        attr_writer :default_used
+
+        def initialize(key, value, definition, default_used)
           @key = key
           @value = value
           @definition = definition
+          @default_used = default_used
+        end
+
+        # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+        def default_used?
+          @default_used
         end
       end
 
-      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil)
+      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil, nil)
 
       def wrap_value(value, arg_defn_type, context)
         if value.nil?
@@ -118,7 +134,7 @@ module GraphQL
             wrap_value(value, arg_defn_type.of_type, context)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              arg_defn_type.arguments_class.new(value, context: context)
+              arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
             else
               value
             end

data/lib/graphql/query/context.rb

@@ -268,3 +268,6 @@ module GraphQL
     end
   end
 end
+
+
+GraphQL::Schema::Context = GraphQL::Query::Context

data/lib/graphql/query/literal_input.rb

@@ -49,6 +49,8 @@ module GraphQL
       def self.from_arguments(ast_arguments, argument_owner, variables)
         context = variables ? variables.context : nil
         values_hash = {}
+        defaults_used = Set.new
+
         indexed_arguments = case ast_arguments
         when Hash
           ast_arguments
@@ -93,6 +95,7 @@ module GraphQL
           # then add the default value.
           if arg_defn.default_value? && !values_hash.key?(arg_name)
             value = arg_defn.default_value
+            defaults_used << arg_name
             # `context` isn't present when pre-calculating defaults
             if context
               value = arg_defn.prepare(value, context)
@@ -105,7 +108,7 @@ module GraphQL
           end
         end
 
-        argument_owner.arguments_class.new(values_hash, context: context)
+        argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
       end
     end
   end

data/lib/graphql/railtie.rb

@@ -19,17 +19,40 @@ module GraphQL
               Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
             end
           end
+
+          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
+          puts "Don't forget to create the base objects. For example, you could run:"
+          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
         end
 
         namespace :upgrade do
           task :create_base_objects, [:base_dir] do |t, args|
-            base_dir = args.base_dir
+            unless (base_dir = args[:base_dir])
+              fail 'You have to give me a directory where your GraphQL types live. ' \
+                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
+            end
+
+            destination_file = File.join(base_dir, "types", "base_scalar.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_input_object.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
+              end
+            end
 
             destination_file = File.join(base_dir, "types", "base_enum.rb")
             unless File.exists?(destination_file)
               FileUtils.mkdir_p(File.dirname(destination_file))
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseEnum < GraphQL::Schema::Enum; end"
+                f.write "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
               end
             end
 
@@ -37,7 +60,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::BaseUnion < GraphQL::Schema::Union; end"
+                f.write "class Types::BaseUnion < GraphQL::Schema::Union\nend"
               end
             end
 
@@ -45,14 +68,14 @@ 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; end"
+                f.write "class Types::BaseInterface < GraphQL::Schema::Interface\nend"
               end
             end
 
             destination_file = File.join(base_dir, "types", "base_object.rb")
             unless File.exists?(destination_file)
               File.open(destination_file, 'w') do |f|
-                f.write "class Types::BaseObject < GraphQL::Schema::Object; end"
+                f.write "class Types::BaseObject < GraphQL::Schema::Object\nend"
               end
             end
           end
@@ -80,4 +103,3 @@ module GraphQL
     end
   end
 end
-

data/lib/graphql/schema.rb

@@ -4,6 +4,8 @@ require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
 require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
+require "graphql/schema/introspection_system"
+require "graphql/schema/late_bound_type"
 require "graphql/schema/middleware_chain"
 require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
@@ -91,7 +93,7 @@ module GraphQL
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
-      :raise_definition_error
+      :raise_definition_error, :introspection_namespace
 
     # Single, long-lived instance of the provided subscriptions class, if there is one.
     # @return [GraphQL::Subscriptions]
@@ -104,6 +106,10 @@ module GraphQL
     # @see {Query.new} for query-specific filters with `except:`
     attr_accessor :default_mask
 
+    # @see {GraphQL::Query::Context} The parent class of these classes
+    # @return [Class] Instantiated for each query
+    attr_accessor :context_class
+
     class << self
       attr_accessor :default_execution_strategy
     end
@@ -148,6 +154,9 @@ module GraphQL
       @subscription_execution_strategy = self.class.default_execution_strategy
       @default_mask = GraphQL::Schema::NullMask
       @rebuilding_artifacts = false
+      @context_class = GraphQL::Query::Context
+      @introspection_namespace = nil
+      @introspection_system = nil
     end
 
     def initialize_copy(other)
@@ -175,6 +184,7 @@ module GraphQL
       # This will be rebuilt when it's requested
       # or during a later `define` call
       @types = nil
+      @introspection_system = nil
     end
 
     def rescue_from(*args, &block)
@@ -250,6 +260,14 @@ module GraphQL
       end
     end
 
+    # @api private
+    def introspection_system
+      @introspection_system ||= begin
+        rebuild_artifacts
+        @introspection_system
+      end
+    end
+
     # Returns a list of Arguments and Fields referencing a certain type
     # @param type_name [String]
     # @return [Hash]
@@ -331,12 +349,10 @@ module GraphQL
         defined_field = @instrumented_field_map[parent_type_name][field_name]
         if defined_field
           defined_field
-        elsif field_name == "__typename"
-          GraphQL::Introspection::TypenameField
-        elsif field_name == "__schema" && parent_type == query
-          GraphQL::Introspection::SchemaField
-        elsif field_name == "__type" && parent_type == query
-          GraphQL::Introspection::TypeByNameField
+        elsif parent_type == query && (entry_point_field = introspection_system.entry_point(name: field_name))
+          entry_point_field
+        elsif (dynamic_field = introspection_system.dynamic_field(name: field_name))
+          dynamic_field
         else
           nil
         end
@@ -632,9 +648,11 @@ module GraphQL
           directives(DIRECTIVES)
         end
         schema_defn.directives = directives
+        schema_defn.introspection_namespace = introspection
         schema_defn.resolve_type = method(:resolve_type)
         schema_defn.object_from_id = method(:object_from_id)
         schema_defn.id_from_object = method(:id_from_object)
+        schema_defn.context_class = context_class
         instrumenters.each do |step, insts|
           insts.each do |inst|
             schema_defn.instrumenters[step] << inst
@@ -686,6 +704,14 @@ module GraphQL
         end
       end
 
+      def introspection(new_introspection_namespace = nil)
+        if new_introspection_namespace
+          @introspection = new_introspection_namespace
+        else
+          @introspection
+        end
+      end
+
       def default_max_page_size(new_default_max_page_size = nil)
         if new_default_max_page_size
           @default_max_page_size = new_default_max_page_size
@@ -718,6 +744,14 @@ module GraphQL
         end
       end
 
+      def context_class(new_context_class = nil)
+        if new_context_class
+          @context_class = new_context_class
+        else
+          @context_class || GraphQL::Query::Context
+        end
+      end
+
       def resolve_type(type, obj, ctx)
         raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
       end
@@ -805,6 +839,7 @@ module GraphQL
         raise CyclicalDefinitionError, "Part of the schema build process re-triggered the schema build process, causing an infinite loop. Avoid using Schema#types, Schema#possible_types, and Schema#get_field during schema build."
       else
         @rebuilding_artifacts = true
+        @introspection_system = Schema::IntrospectionSystem.new(self)
         traversal = Traversal.new(self)
         @types = traversal.type_map
         @root_types = [query, mutation, subscription]

data/lib/graphql/schema/enum.rb

@@ -54,6 +54,7 @@ module GraphQL
           enum_type = GraphQL::EnumType.new
           enum_type.name = graphql_name
           enum_type.description = description
+          enum_type.introspection = introspection
           values.each do |val|
             enum_value = GraphQL::EnumType::EnumValue.new
             enum_value.name = val.name

data/lib/graphql/schema/field.rb

@@ -13,7 +13,7 @@ module GraphQL
       # @return [String]
       attr_reader :description
 
-      def initialize(name, return_type_expr = nil, desc = nil, null: nil, field: nil, function: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, &args_block)
+      def initialize(name, return_type_expr = nil, desc = nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, extras: [], &args_block)
         if !(field || function)
           if return_type_expr.nil?
             raise ArgumentError, "missing positional argument `type`"
@@ -22,8 +22,14 @@ module GraphQL
             raise ArgumentError, "missing keyword argument null:"
           end
         end
+        if (field || function || resolve) && extras.any?
+          raise ArgumentError, "keyword `extras:` may only be used with method-based resolve, please remove `field:`, `function:`, or `resolve:`"
+        end
         @name = name.to_s
-        @description = desc
+        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
         @field = field
         @function = function
         @resolve = resolve
@@ -34,6 +40,8 @@ module GraphQL
         @args_block = args_block
         @connection = connection
         @max_page_size = max_page_size
+        @introspection = introspection
+        @extras = extras
       end
 
       # @return [GraphQL::Field]
@@ -49,7 +57,6 @@ module GraphQL
         end
 
         field_defn.name = Member::BuildType.camelize(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
@@ -75,11 +82,16 @@ module GraphQL
           prev_resolve = @resolve || field_defn.resolve_proc
           UnwrappedResolve.new(inner_resolve: prev_resolve)
         else
-          DynamicResolve.new(method_name: method_name, connection: connection)
+          DynamicResolve.new(
+            method_name: method_name,
+            connection: connection,
+            extras: @extras
+          )
         end
 
         field_defn.connection = connection
         field_defn.connection_max_page_size = @max_page_size
+        field_defn.introspection = @introspection
 
         field_proxy = FieldProxy.new(field_defn, argument_class: self.class.argument_class)
         # apply this first, so it can be overriden below
@@ -122,7 +134,16 @@ module GraphQL
         # This is the `argument(...)` DSL for class-based field definitons
         def argument(*args)
           arg = @argument_class.new(*args)
-          @field.arguments[arg.name] = arg.graphql_definition
+          graphql_arg = arg.graphql_definition
+          @field.arguments[graphql_arg.name] = graphql_arg
+        end
+
+        def description(text)
+          if @field.description
+            fail "You're overriding the description of #{@field.name} in the provided block!"
+          else
+            @field.description = text
+          end
         end
       end
     end

data/lib/graphql/schema/field/dynamic_resolve.rb

@@ -4,16 +4,17 @@ module GraphQL
   class Schema
     class Field
       class DynamicResolve
-        def initialize(method_name:, connection:)
+        def initialize(method_name:, connection:, extras:)
           @method_name = method_name
           @connection = connection
+          @extras = extras
         end
 
         def call(obj, args, ctx)
           if obj.respond_to?(@method_name)
-            public_send_field(obj, @method_name, args)
+            public_send_field(obj, @method_name, args, ctx)
           elsif obj.object.respond_to?(@method_name)
-            public_send_field(obj.object, @method_name, args)
+            public_send_field(obj.object, @method_name, args, ctx)
           elsif obj.is_a?(Hash)
             obj[@method_name]
           else
@@ -31,8 +32,10 @@ ERR
 
         private
 
-        def public_send_field(obj, method_name, graphql_args)
-          if graphql_args.any?
+        NO_ARGS = {}.freeze
+
+        def public_send_field(obj, method_name, graphql_args, field_ctx)
+          if graphql_args.any? || @extras.any?
             # Splat the GraphQL::Arguments to Ruby keyword arguments
             ruby_kwargs = {}
 
@@ -48,11 +51,17 @@ ERR
               ruby_kwargs.delete(:after)
             end
 
-            if ruby_kwargs.any?
-              obj.public_send(method_name, ruby_kwargs)
-            else
-              obj.public_send(method_name)
+            @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_name, ruby_kwargs)
           else
             obj.public_send(method_name)
           end