graphql 1.8.4 → 1.8.5

data/lib/graphql/language/parser.y

@@ -9,9 +9,13 @@ rule
     | definitions_list definition   { val[0] << val[1] }
 
   definition:
+      executable_definition
+    | type_system_definition
+    | type_system_extension
+
+  executable_definition:
       operation_definition
     | fragment_definition
-    | type_system_definition
 
   operation_definition:
       operation_type operation_name_opt variable_definitions_opt directives_list_opt selection_set {
@@ -293,6 +297,47 @@ rule
     | enum_type_definition
     | input_object_type_definition
 
+  type_system_extension:
+      schema_extension
+    | type_extension
+
+  schema_extension:
+      EXTEND SCHEMA directives_list_opt LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaExtension, position_source: val[0], directives: val[2], **val[4]) }
+    | EXTEND SCHEMA directives_list { return make_node(:SchemaExtension, position_source: val[0], directives: val[2]) }
+
+  type_extension:
+      scalar_type_extension
+    | object_type_extension
+    | interface_type_extension
+    | union_type_extension
+    | enum_type_extension
+    | input_object_type_extension
+
+  scalar_type_extension: EXTEND SCALAR name directives_list { return make_node(:ScalarTypeExtension, name: val[2], directives: val[3], position_source: val[0]) }
+
+  object_type_extension:
+      /* TODO - This first one shouldn't be necessary but parser is getting confused */
+      EXTEND TYPE name implements LCURLY field_definition_list RCURLY { return make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: val[5], position_source: val[0]) }
+    | EXTEND TYPE name implements_opt directives_list_opt LCURLY field_definition_list RCURLY { return make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: val[6], position_source: val[0]) }
+    | EXTEND TYPE name implements_opt directives_list { return make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: val[4], fields: [], position_source: val[0]) }
+    | EXTEND TYPE name implements { return make_node(:ObjectTypeExtension, name: val[2], interfaces: val[3], directives: [], fields: [], position_source: val[0]) }
+
+  interface_type_extension:
+      EXTEND INTERFACE name directives_list_opt LCURLY field_definition_list RCURLY { return make_node(:InterfaceTypeExtension, name: val[2], directives: val[3], fields: val[5], position_source: val[0]) }
+    | EXTEND INTERFACE name directives_list { return make_node(:InterfaceTypeExtension, name: val[2], directives: val[3], fields: [], position_source: val[0]) }
+
+  union_type_extension:
+      EXTEND UNION name directives_list_opt EQUALS union_members { return make_node(:UnionTypeExtension, name: val[2], directives: val[3], types: val[5], position_source: val[0]) }
+    | EXTEND UNION name directives_list { return make_node(:UnionTypeExtension, name: val[2], directives: val[3], types: [], position_source: val[0]) }
+
+  enum_type_extension:
+      EXTEND ENUM name directives_list_opt LCURLY enum_value_definitions RCURLY { return make_node(:EnumTypeExtension, name: val[2], directives: val[3], values: val[5], position_source: val[0]) }
+    | EXTEND ENUM name directives_list { return make_node(:EnumTypeExtension, name: val[2], directives: val[3], values: [], position_source: val[0]) }
+
+  input_object_type_extension:
+      EXTEND INPUT name directives_list_opt LCURLY input_value_definition_list RCURLY { return make_node(:InputObjectTypeExtension, name: val[2], directives: val[3], fields: val[5], position_source: val[0]) }
+    | EXTEND INPUT name directives_list { return make_node(:InputObjectTypeExtension, name: val[2], directives: val[3], fields: [], position_source: val[0]) }
+
   scalar_type_definition: SCALAR name directives_list_opt { return make_node(:ScalarTypeDefinition, name: val[1], directives: val[2], description: get_description(val[0]), position_source: val[0]) }
 
   object_type_definition:
@@ -302,7 +347,10 @@ rule
 
   implements_opt:
       /* none */ { return [] }
-    | IMPLEMENTS AMP interfaces_list { return val[2] }
+    | implements
+
+  implements:
+      IMPLEMENTS AMP interfaces_list { return val[2] }
     | IMPLEMENTS interfaces_list { return val[1] }
     | IMPLEMENTS legacy_interfaces_list { return val[1] }
 

data/lib/graphql/object_type.rb

@@ -102,6 +102,10 @@ module GraphQL
       dirty_ifaces.concat(interfaces)
     end
 
+    def resolve_type_proc
+      nil
+    end
+
     protected
 
     attr_reader :dirty_interfaces, :dirty_inherited_interfaces

data/lib/graphql/query.rb

@@ -76,7 +76,9 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    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)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
+      # Even if `variables: nil` is passed, use an empty hash for simpler logic
+      variables ||= {}
       @schema = schema
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)

data/lib/graphql/query/variables.rb

@@ -43,7 +43,7 @@ module GraphQL
             elsif value_was_provided
               # Add the variable if a value was provided
               memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
-            elsif default_value
+            elsif default_value != nil
               # Add the variable if it wasn't provided but it has a default value (including `null`)
               memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
             end

data/lib/graphql/schema.rb

@@ -462,6 +462,10 @@ module GraphQL
         object = object.object
       end
 
+      if type.respond_to?(:graphql_definition)
+        type = type.graphql_definition
+      end
+
       # Prefer a type-local function; fall back to the schema-level function
       type_proc = type && type.resolve_type_proc
       type_result = if type_proc
@@ -867,6 +871,10 @@ module GraphQL
       #
       # By default, this hook just replaces the unauthorized object with `nil`.
       #
+      # Whatever value is returned from this method will be used instead of the
+      # unauthorized object (accessible ass `unauthorized_error.object`). If an
+      # error is raised, then `nil` will be used.
+      #
       # If you want to add an error to the `"errors"` key, raise a {GraphQL::ExecutionError}
       # in this hook.
       #
@@ -997,11 +1005,11 @@ module GraphQL
           result = value.public_send(lazy_method)
           # The returned result might also be lazy, so check it, too
           after_lazy(result) do |final_result|
-            yield(final_result)
+            yield(final_result) if block_given?
           end
         end
       else
-        yield(value)
+        yield(value) if block_given?
       end
     end
 

data/lib/graphql/schema/input_object.rb

@@ -27,7 +27,7 @@ module GraphQL
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
-      def_delegators :@ruby_style_hash, :keys, :values, :each, :any?
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :any?, :empty?
 
       def to_h
         @ruby_style_hash.inject({}) do |h, (key, value)|

data/lib/graphql/schema/interface.rb

@@ -61,6 +61,12 @@ module GraphQL
               child_class.extend(interface_defn::DefinitionMethods)
             end
           elsif child_class < GraphQL::Schema::Object
+            # Add all definition methods of this interface and the interfaces it
+            # includes onto the child class.
+            (interfaces + [self] - [GraphQL::Schema::Interface]).each do |interface_defn|
+              child_class.extend(interface_defn::DefinitionMethods)
+            end
+
             # This is being included into an object type, make sure it's using `implements(...)`
             backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}
             if !backtrace_line

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

@@ -17,6 +17,7 @@ module GraphQL
           kwargs[:owner] = self
           arg_defn = self.argument_class.new(*args, **kwargs, &block)
           own_arguments[arg_defn.name] = arg_defn
+          arg_defn
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions

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

@@ -78,8 +78,6 @@ module GraphQL
               ctx.wrapped_object = true
               proxy_to_depth(result, @list_depth, ctx)
             end
-          rescue GraphQL::UnauthorizedError => err
-            ctx.schema.unauthorized_object(err)
           end
 
           private
@@ -88,21 +86,28 @@ module GraphQL
             if depth > 0
               inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }
             else
-              concrete_type = case @inner_return_type
-              when GraphQL::UnionType, GraphQL::InterfaceType
-                ctx.query.resolve_type(@inner_return_type, inner_obj)
-              when GraphQL::ObjectType
-                @inner_return_type
-              else
-                raise "unexpected proxying type #{@inner_return_type} for #{inner_obj} at #{ctx.owner_type}.#{ctx.field.name}"
-              end
+              ctx.schema.after_lazy(inner_obj) do |inner_obj|
+                if inner_obj.nil?
+                  # For lists with nil, we need another nil check here
+                  nil
+                else
+                  concrete_type = case @inner_return_type
+                  when GraphQL::UnionType, GraphQL::InterfaceType
+                    ctx.query.resolve_type(@inner_return_type, inner_obj)
+                  when GraphQL::ObjectType
+                    @inner_return_type
+                  else
+                    raise "unexpected proxying type #{@inner_return_type} for #{inner_obj} at #{ctx.owner_type}.#{ctx.field.name}"
+                  end
 
-              if concrete_type && (object_class = concrete_type.metadata[:type_class])
-                # use the query-level context here, since it won't be field-specific anyways
-                query_ctx = ctx.query.context
-                object_class.authorized_new(inner_obj, query_ctx)
-              else
-                inner_obj
+                  if concrete_type && (object_class = concrete_type.metadata[:type_class])
+                    # use the query-level context here, since it won't be field-specific anyways
+                    query_ctx = ctx.query.context
+                    object_class.authorized_new(inner_obj, query_ctx)
+                  else
+                    inner_obj
+                  end
+                end
               end
             end
           end

data/lib/graphql/schema/mutation.rb

@@ -17,7 +17,7 @@ module GraphQL
     #    argument :post_id, ID, required: true
     #
     #    field :comment, Types::Comment, null: true
-    #    field :error_messages, [String], null: false
+    #    field :errors, [String], null: false
     #
     #    def resolve(body:, post_id:)
     #      post = Post.find(post_id)

data/lib/graphql/schema/object.rb

@@ -39,7 +39,13 @@ module GraphQL
             if is_authorized
               self.new(object, context)
             else
-              raise GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
+              # It failed the authorization check, so go to the schema's authorized object hook
+              err = GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
+              # If a new value was returned, wrap that instead of the original value
+              new_obj = context.schema.unauthorized_object(err)
+              if new_obj
+                self.new(new_obj, context)
+              end
             end
           end
         end
@@ -94,7 +100,6 @@ module GraphQL
           obj_type.interfaces = interfaces
           obj_type.introspection = introspection
           obj_type.mutation = mutation
-
           fields.each do |field_name, field_inst|
             field_defn = field_inst.to_graphql
             obj_type.fields[field_defn.name] = field_defn

data/lib/graphql/schema/possible_types.rb

@@ -31,7 +31,7 @@ module GraphQL
         when GraphQL::BaseType
           [type_defn]
         else
-          raise "Unexpected possible_types object: #{type_defn}"
+          raise "Unexpected possible_types object: #{type_defn.inspect}"
         end
       end
     end

data/lib/graphql/schema/resolver.rb

@@ -29,6 +29,12 @@ module GraphQL
       def initialize(object:, context:)
         @object = object
         @context = context
+        # Since this hash is constantly rebuilt, cache it for this call
+        @arguments_by_keyword = {}
+        self.class.arguments.each do |name, arg|
+          @arguments_by_keyword[arg.keyword] = arg
+        end
+        @arguments_loads_as_type = self.class.arguments_loads_as_type
       end
 
       # @return [Object] The application object this field is being resolved on
@@ -37,12 +43,170 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
+      # This method is _actually_ called by the runtime,
+      # it does some preparation and then eventually calls
+      # the user-defined `#resolve` method.
+      # @api private
+      def resolve_with_support(**args)
+        # First call the before_prepare hook which may raise
+        before_prepare_val = if args.any?
+          before_prepare(**args)
+        else
+          before_prepare
+        end
+        context.schema.after_lazy(before_prepare_val) do
+          # Then call each prepare hook, which may return a different value
+          # for that argument, or may return a lazy object
+          load_arguments_val = load_arguments(args)
+          context.schema.after_lazy(load_arguments_val) do |loaded_args|
+            # Then validate each argument, which may raise or may return a lazy object
+            validate_arguments_val = validate_arguments(loaded_args)
+            context.schema.after_lazy(validate_arguments_val) do |validated_args|
+              # Finally, all the hooks have passed, so resolve it
+              if validated_args.any?
+                public_send(self.class.resolve_method, **validated_args)
+              else
+                public_send(self.class.resolve_method)
+              end
+            end
+          end
+        end
+      end
+
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
         raise NotImplementedError, "#{self.class.name}#resolve should execute the field's logic"
       end
 
+      # Called before arguments are prepared.
+      # Implement this hook to make checks before doing any work.
+      #
+      # If it returns a lazy object (like a promise), it will be synced by GraphQL
+      # (but the resulting value won't be used).
+      #
+      # @param args [Hash] The input arguments, if there are any
+      # @raise [GraphQL::ExecutionError] To add an error to the response
+      # @raise [GraphQL::UnauthorizedError] To signal an authorization failure
+      def before_prepare(**args)
+      end
+
+      private
+
+      def load_arguments(args)
+        prepared_args = {}
+        prepare_lazies = []
+
+        args.each do |key, value|
+          arg_defn = @arguments_by_keyword[key]
+          if arg_defn
+            prepped_value = prepared_args[key] = load_argument(key, value)
+            if context.schema.lazy?(prepped_value)
+              prepare_lazies << context.schema.after_lazy(prepped_value) do |finished_prepped_value|
+                prepared_args[key] = finished_prepped_value
+              end
+            end
+          else
+            # These are `extras: [...]`
+            prepared_args[key] = value
+          end
+        end
+
+        # Avoid returning a lazy if none are needed
+        if prepare_lazies.any?
+          GraphQL::Execution::Lazy.all(prepare_lazies).then { prepared_args }
+        else
+          prepared_args
+        end
+      end
+
+      def load_argument(name, value)
+        public_send("load_#{name}", value)
+      end
+
+      # TODO dedup with load_arguments
+      def validate_arguments(args)
+        validate_lazies = []
+        args.each do |key, value|
+          arg_defn = @arguments_by_keyword[key]
+          if arg_defn
+            validate_return = validate_argument(key, value)
+            if context.schema.lazy?(validate_return)
+              validate_lazies << context.schema.after_lazy(validate_return).then { "no-op" }
+            end
+          end
+        end
+
+        # Avoid returning a lazy if none are needed
+        if validate_lazies.any?
+          GraphQL::Execution::Lazy.all(validate_lazies).then { args }
+        else
+          args
+        end
+      end
+
+      def validate_argument(name, value)
+        public_send("validate_#{name}", value)
+      end
+
+      class LoadApplicationObjectFailedError < GraphQL::ExecutionError
+        # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
+        attr_reader :argument
+        # @return [String] The ID provided by the client
+        attr_reader :id
+        # @return [Object] The value found with this ID
+        attr_reader :object
+        def initialize(argument:, id:, object:)
+          @id = id
+          @argument = argument
+          @object = object
+          super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
+        end
+      end
+
+      def load_application_object(arg_kwarg, id)
+        argument = @arguments_by_keyword[arg_kwarg]
+        # See if any object can be found for this ID
+        application_object = context.schema.object_from_id(id, context)
+        if application_object.nil?
+          raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+        end
+        # Double-check that the located object is actually of this type
+        # (Don't want to allow arbitrary access to objects this way)
+        lookup_as_type = @arguments_loads_as_type[arg_kwarg]
+        application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+        possible_object_types = context.schema.possible_types(lookup_as_type)
+        if !possible_object_types.include?(application_object_type)
+          raise LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+        else
+          # This object was loaded successfully
+          # and resolved to the right type,
+          # now apply the `.authorized?` class method if there is one
+          if (class_based_type = application_object_type.metadata[:type_class])
+            context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
+              if authed
+                application_object
+              else
+                raise GraphQL::UnauthorizedError.new(
+                  object: application_object,
+                  type: class_based_type,
+                  context: context,
+                )
+              end
+            end
+          else
+            application_object
+          end
+        end
+      rescue LoadApplicationObjectFailedError => err
+        # pass it to a handler
+        load_application_object_failed(err)
+      end
+
+      def load_application_object_failed(err)
+        raise err
+      end
+
       class << self
         # Default `:resolve` set below.
         # @return [Symbol] The method to call on instances of this object to resolve the field
@@ -113,7 +277,7 @@ module GraphQL
             type: type_expr,
             description: description,
             extras: extras,
-            method: resolve_method,
+            method: :resolve_with_support,
             resolver_class: self,
             arguments: arguments,
             null: null,
@@ -125,6 +289,51 @@ module GraphQL
         def type_expr
           @type_expr || (superclass.respond_to?(:type_expr) ? superclass.type_expr : nil)
         end
+
+        # Add an argument to this field's signature, but
+        # also add some preparation hook methods which will be used for this argument
+        # @see {GraphQL::Schema::Argument#initialize} for the signature
+        def argument(name, type, *rest, loads: nil, **kwargs, &block)
+          if loads
+            arg_keyword = name.to_s.sub(/_id$/, "").to_sym
+            kwargs[:as] = arg_keyword
+            own_arguments_loads_as_type[arg_keyword] = loads
+          end
+          arg_defn = super(name, type, *rest, **kwargs, &block)
+
+          if loads
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def load_#{arg_defn.keyword}(value)
+              load_application_object(:#{arg_defn.keyword}, value)
+            end
+            RUBY
+          else
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def load_#{arg_defn.keyword}(value)
+              value
+            end
+            RUBY
+          end
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def validate_#{arg_defn.keyword}(value)
+            # No-op
+          end
+          RUBY
+          arg_defn
+        end
+
+        # @api private
+        def arguments_loads_as_type
+          inherited_lookups = superclass.respond_to?(:arguments_loads_as_type) ? superclass.arguments_loads_as_type : {}
+          inherited_lookups.merge(own_arguments_loads_as_type)
+        end
+
+        private
+
+        def own_arguments_loads_as_type
+          @own_arguments_loads_as_type ||= {}
+        end
       end
     end
   end