graphql 1.8.0.pre6 → 1.8.0.pre7

data/lib/graphql/language/parser.y

@@ -82,8 +82,7 @@ rule
     | EQUALS literal_value  { return val[1] }
 
   selection_set:
-      LCURLY RCURLY                { return [] }
-    | LCURLY selection_list RCURLY { return val[1] }
+      LCURLY selection_list RCURLY { return val[1] }
 
   selection_set_opt:
       /* none */    { return [] }

data/lib/graphql/query/context.rb

@@ -70,6 +70,32 @@ module GraphQL
         def backtrace
           GraphQL::Backtrace.new(self)
         end
+
+        def execution_errors
+          @execution_errors ||= ExecutionErrors.new(self)
+        end
+      end
+
+      class ExecutionErrors
+        def initialize(ctx)
+          @context = ctx
+        end
+
+        def add(err_or_msg)
+          err = case err_or_msg
+          when String
+            GraphQL::ExecutionError.new(err_or_msg)
+          when GraphQL::ExecutionError
+            err_or_msg
+          else
+            raise ArgumentError, "expected String or GraphQL::ExecutionError, not #{err_or_msg.class} (#{err_or_msg.inspect})"
+          end
+          # This will assign ast_node and path
+          @context.add_error(err)
+        end
+
+        alias :>> :add
+        alias :push :add
       end
 
       include SharedMethods

data/lib/graphql/schema.rb

@@ -613,7 +613,7 @@ module GraphQL
     # @param except [<#call(member, ctx)>]
     # @return [Hash] GraphQL result
     def as_json(only: nil, except: nil, context: {})
-      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context)
+      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
     end
 
     # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
@@ -625,19 +625,32 @@ module GraphQL
 
     class << self
       extend GraphQL::Delegate
-      def_delegators :graphql_definition, :as_json, :to_json
-
-      def method_missing(method_name, *args, &block)
-        if graphql_definition.respond_to?(method_name)
-          graphql_definition.public_send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_name, incl_private = false)
-        graphql_definition.respond_to?(method_name, incl_private) || super
-      end
+      # For compatibility, these methods all:
+      # - Cause the Schema instance to be created, if it hasn't been created yet
+      # - Delegate to that instance
+      # Eventually, the methods will be moved into this class, removing the need for the singleton.
+      def_delegators :graphql_definition,
+        # Schema structure
+        :as_json, :to_json, :to_document, :to_definition,
+        # Execution
+        :execute, :multiplex,
+        :static_validator, :introspection_system,
+        :query_analyzers, :middleware, :tracers, :instrumenters,
+        :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
+        :validate, :multiplex_analyzers, :lazy?, :lazy_method_name,
+        # Configuration
+        :max_complexity=, :max_depth=,
+        :metadata,
+        :default_filter, :redefine,
+        :id_from_object_proc, :object_from_id_proc,
+        :id_from_object=, :object_from_id=, :type_error,
+        :remove_handler,
+        # Members
+        :types, :get_fields, :find,
+        :root_type_for_operation,
+        :union_memberships,
+        :get_field, :root_types, :references_to, :type_from_ast,
+        :possible_types, :get_field
 
       def graphql_definition
         @graphql_definition ||= to_graphql
@@ -653,6 +666,7 @@ module GraphQL
 
       def to_graphql
         schema_defn = self.new
+        schema_defn.raise_definition_error = true
         schema_defn.query = query
         schema_defn.mutation = mutation
         schema_defn.subscription = subscription
@@ -660,16 +674,17 @@ module GraphQL
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
-        if !directives
-          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.type_error = method(:type_error)
         schema_defn.context_class = context_class
-        instrumenters.each do |step, insts|
+        schema_defn.tracers.concat(defined_tracers)
+        schema_defn.query_analyzers.concat(defined_query_analyzers)
+        schema_defn.multiplex_analyzers.concat(defined_multiplex_analyzers)
+        defined_instrumenters.each do |step, insts|
           insts.each do |inst|
             schema_defn.instrumenters[step] << inst
           end
@@ -678,6 +693,12 @@ module GraphQL
         lazy_classes.each do |lazy_class, value_method|
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
+        if @rescues
+          @rescues.each do |err_class, handler|
+            schema_defn.rescue_from(err_class, &handler)
+          end
+        end
+
         if plugins.any?
           schema_plugins = plugins
           # TODO don't depend on .define
@@ -776,6 +797,11 @@ module GraphQL
         end
       end
 
+      def rescue_from(err_class, &handler_block)
+        @rescues ||= {}
+        @rescues[err_class] = handler_block
+      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
@@ -788,6 +814,10 @@ module GraphQL
         raise NotImplementedError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
       end
 
+      def type_error(type_err, ctx)
+        DefaultTypeError.call(type_err, ctx)
+      end
+
       def lazy_resolve(lazy_class, value_method)
         lazy_classes[lazy_class] = value_method
       end
@@ -798,14 +828,27 @@ module GraphQL
         else
           instrument_step
         end
-        instrumenters[step] << instrumenter
+        defined_instrumenters[step] << instrumenter
       end
 
       def directives(new_directives = nil)
         if new_directives
           @directives = new_directives.reduce({}) { |m, d| m[d.name] = d; m }
         end
-        @directives
+
+        @directives ||= directives(DIRECTIVES)
+      end
+
+      def tracer(new_tracer)
+        defined_tracers << new_tracer
+      end
+
+      def query_analyzer(new_analyzer)
+        defined_query_analyzers << new_analyzer
+      end
+
+      def multiplex_analyzer(new_analyzer)
+        defined_multiplex_analyzers << new_analyzer
       end
 
       private
@@ -814,8 +857,20 @@ module GraphQL
         @lazy_classes ||= {}
       end
 
-      def instrumenters
-        @instrumenters ||= Hash.new { |h,k| h[k] = [] }
+      def defined_instrumenters
+        @defined_instrumenters ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      def defined_tracers
+        @defined_tracers ||= []
+      end
+
+      def defined_query_analyzers
+        @defined_query_analyzers ||= []
+      end
+
+      def defined_multiplex_analyzers
+        @defined_multiplex_analyzers ||= []
       end
     end
 

data/lib/graphql/schema/argument.rb

@@ -8,17 +8,25 @@ module GraphQL
 
       attr_reader :name
 
-      def initialize(arg_name, type_expr, desc = nil, required:, default_value: NO_DEFAULT)
+      # @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 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)
         @name = arg_name.to_s
         @type_expr = type_expr
-        @description = desc
+        @description = desc || description
         @null = !required
         @default_value = default_value
+        @camelize = camelize
       end
 
       def to_graphql
         argument = GraphQL::Argument.new
-        argument.name = Member::BuildType.camelize(@name)
+        argument.name = @camelize ? Member::BuildType.camelize(@name) : @name
         argument.type = -> {
           Member::BuildType.parse_type(@type_expr, null: @null)
         }

data/lib/graphql/schema/field.rb

@@ -19,7 +19,28 @@ module GraphQL
       # @return [Symbol]
       attr_reader :method
 
-      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: [], &definition_block)
+      # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API)
+      # @param return_type_expr [Class, GraphQL::BaseType, Array] The return type of this field
+      # @param desc [String] Field description
+      # @param null [Boolean] `true` if this field may return `null`, `false` if it is never `null`
+      # @param description [String] Field description
+      # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message
+      # @param method [Symbol] The method to call to resolve this field (defaults to `name`)
+      # @param hash_key [Object] The hash key to lookup to resolve this field (defaults to `name` or `name.to_s`)
+      # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
+      # @param max_page_size [Integer] For connections, the maximum number of items to return from this field
+      # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
+      # @param resolve [<#call(obj, args, ctx)>] **deprecated** for compatibility with <1.8.0
+      # @param field [GraphQL::Field] **deprecated** for compatibility with <1.8.0
+      # @param function [GraphQL::Function] **deprecated** for compatibility with <1.8.0
+      # @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, 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: [], &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 !(field || function)
           if return_type_expr.nil?
             raise ArgumentError, "missing positional argument `type`"
@@ -40,7 +61,12 @@ module GraphQL
         @function = function
         @resolve = resolve
         @deprecation_reason = deprecation_reason
+        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
+        @complexity = complexity
         @return_type_expr = return_type_expr
         @return_type_null = null
         @connection = connection
@@ -48,6 +74,7 @@ module GraphQL
         @introspection = introspection
         @extras = extras
         @arguments = {}
+        @camelize = camelize
 
         if definition_block
           instance_eval(&definition_block)
@@ -68,9 +95,28 @@ module GraphQL
         end
       end
 
+      def complexity(new_complexity)
+        case new_complexity
+        when Proc
+          if new_complexity.parameters.size != 3
+            fail(
+              "A complexity proc should always accept 3 parameters: ctx, args, child_complexity. "\
+              "E.g.: complexity ->(ctx, args, child_complexity) { child_complexity * args[:limit] }"
+            )
+          else
+            @complexity = new_complexity
+          end
+        when Numeric
+          @complexity = new_complexity
+        else
+          raise("Invalid complexity: #{new_complexity.inspect} on #{@name}")
+        end
+
+      end
+
       # @return [GraphQL::Field]
       def to_graphql
-        method_name = @method || Member::BuildType.underscore(@name)
+        method_name = @method || @hash_key || Member::BuildType.underscore(@name)
 
         field_defn = if @field
           @field.dup
@@ -80,7 +126,7 @@ module GraphQL
           GraphQL::Field.new
         end
 
-        field_defn.name = Member::BuildType.camelize(name)
+        field_defn.name = @camelize ? Member::BuildType.camelize(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
@@ -116,6 +162,7 @@ module GraphQL
         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

data/lib/graphql/schema/input_object.rb

@@ -9,6 +9,12 @@ module GraphQL
         @context = context
       end
 
+      # @return [GraphQL::Query::Context] The context for this query
+      attr_reader :context
+
+      # @return [GraphQL::Query::Arguments] The underlying arguments instance
+      attr_reader :arguments
+
       # A lot of methods work just like GraphQL::Arguments
       def_delegators :@arguments, :[], :key?, :to_h
       def_delegators :to_h, :keys, :values, :each, :any?

data/lib/graphql/schema/interface.rb

@@ -6,7 +6,6 @@ module GraphQL
       field_class GraphQL::Schema::Field
 
       class << self
-
         # When this interface is added to a `GraphQL::Schema::Object`,
         # it calls this method. We add methods to the object by convention,
         # a nested module named `Implementation`

data/lib/graphql/schema/member.rb

@@ -29,31 +29,17 @@ module GraphQL
       # @example
       #   field :isDraft, Boolean, null: false
       #   field :id, ID, null: false
+      #   field :score, Int, null: false
       module GraphQLTypeNames
         Boolean = "Boolean"
         ID = "ID"
+        Int = "Int"
       end
 
       include GraphQLTypeNames
       class << self
         include CachedGraphQLDefinition
         include GraphQL::Relay::TypeExtensions
-        # Delegate to the derived type definition if possible.
-        # This is tricky because missing methods cause the definition to be built & cached.
-        def method_missing(method_name, *args, &block)
-          if graphql_definition.respond_to?(method_name)
-            graphql_definition.public_send(method_name, *args, &block)
-          else
-            super
-          end
-        end
-
-        # Check if the derived type definition responds to the method
-        # @return [Boolean]
-        def respond_to_missing?(method_name, incl_private = false)
-          graphql_definition.respond_to?(method_name, incl_private) || super
-        end
-
         # Call this with a new name to override the default name for this schema member; OR
         # call it without an argument to get the name of this schema member
         #

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

@@ -37,6 +37,10 @@ module GraphQL
           end
         end
 
+        def global_id_field(field_name)
+          field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
+        end
+
         private
 
         # @return [Array<GraphQL::Schema::Field>] Fields defined on this class _specifically_, not parent classes

data/lib/graphql/schema/object.rb

@@ -3,12 +3,17 @@
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
+      # @return [Object] the application object this type is wrapping
       attr_reader :object
 
+      # @return [GraphQL::Query::Context] the context instance for this query
+      attr_reader :context
+
       def initialize(object, context)
         @object = object
         @context = context
       end
+
       extend GraphQL::Schema::Member::HasFields
       field_class GraphQL::Schema::Field
 
@@ -56,10 +61,6 @@ module GraphQL
 
           obj_type
         end
-
-        def global_id_field(field_name)
-          field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
-        end
       end
     end
   end

data/lib/graphql/schema/union.rb

@@ -2,11 +2,6 @@
 module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
-      def initialize(obj, ctx)
-        @object = obj
-        @context = ctx
-      end
-
       class << self
         def possible_types(*types)
           if types.any?
@@ -23,13 +18,6 @@ module GraphQL
           @own_possible_types ||= []
         end
 
-        # The class resolves type by:
-        # - make an instance
-        # - call the instance method
-        def resolve_type(value, ctx)
-          self.new(value, ctx).resolve_type
-        end
-
         def to_graphql
           type_defn = GraphQL::UnionType.new
           type_defn.name = graphql_name