graphql 1.8.7 → 1.9.0

data/lib/graphql/schema/resolver.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/schema/resolver/has_payload_type"
 
 module GraphQL
   class Schema
@@ -23,6 +24,8 @@ module GraphQL
       # Really we only need description from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      include Schema::Member::HasPath
+      extend Schema::Member::HasPath
 
       # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
       # @param context [GraphQL::Query::Context]
@@ -72,7 +75,6 @@ module GraphQL
               else
                 authorized?
               end
-              authorized?(loaded_args)
               context.schema.after_lazy(authorized_val) do |(authorized_result, early_return)|
                 # If the `authorized?` returned two values, `false, early_return`,
                 # then use the early return value instead of continuing
@@ -138,10 +140,14 @@ module GraphQL
         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
+            if value.nil?
+              prepared_args[key] = value
+            else
+              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
             end
           else
@@ -194,13 +200,13 @@ module GraphQL
         # See if any object can be found for this ID
         loaded_application_object = object_from_id(lookup_as_type, id, context)
         context.schema.after_lazy(loaded_application_object) do |application_object|
-          begin
-            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)
-            application_object_type = context.schema.resolve_type(lookup_as_type, application_object, 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)
+          resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+          context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
             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)
@@ -224,11 +230,11 @@ module GraphQL
                 application_object
               end
             end
-          rescue LoadApplicationObjectFailedError => err
-            # pass it to a handler
-            load_application_object_failed(err)
           end
         end
+      rescue LoadApplicationObjectFailedError => err
+        # pass it to a handler
+        load_application_object_failed(err)
       end
 
       def load_application_object_failed(err)
@@ -305,7 +311,7 @@ module GraphQL
             type: type_expr,
             description: description,
             extras: extras,
-            method: :resolve_with_support,
+            resolver_method: :resolve_with_support,
             resolver_class: self,
             arguments: arguments,
             null: null,
@@ -323,13 +329,32 @@ module GraphQL
         # @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
+            name_as_string = name.to_s
+
+            inferred_arg_name = case name_as_string
+            when /_id$/
+              name_as_string.sub(/_id$/, "").to_sym
+            when /_ids$/
+              name_as_string.sub(/_ids$/, "")
+                .sub(/([^s])$/, "\\1s")
+                .to_sym
+            else
+              name
+            end
+
+            kwargs[:as] ||= inferred_arg_name
+            own_arguments_loads_as_type[kwargs[:as]] = loads
           end
+
           arg_defn = super(name, type, *rest, **kwargs, &block)
 
-          if loads
+          if loads && arg_defn.type.list?
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def load_#{arg_defn.keyword}(values)
+              GraphQL::Execution::Lazy.all(values.map { |value| load_application_object(:#{arg_defn.keyword}, value) })
+            end
+            RUBY
+          elsif loads
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def load_#{arg_defn.keyword}(value)
               load_application_object(:#{arg_defn.keyword}, value)

data/lib/graphql/schema/subscription.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This class can be extended to create fields on your subscription root.
+    #
+    # It provides hooks for the different parts of the subscription lifecycle:
+    #
+    # - `#authorized?`: called before initial subscription and subsequent updates
+    # - `#subscribe`: called for the initial subscription
+    # - `#update`: called for subsequent update
+    #
+    # Also, `#unsubscribe` terminates the subscription.
+    class Subscription < GraphQL::Schema::Resolver
+      class EarlyTerminationError < StandardError
+      end
+
+      # Raised when `unsubscribe` is called; caught by `subscriptions.rb`
+      class UnsubscribedError < EarlyTerminationError
+      end
+
+      # Raised when `no_update` is returned; caught by `subscriptions.rb`
+      class NoUpdateError < EarlyTerminationError
+      end
+      extend GraphQL::Schema::Resolver::HasPayloadType
+      extend GraphQL::Schema::Member::HasFields
+
+      # The generated payload type is required; If there's no payload,
+      # propagate null.
+      null false
+
+      def initialize(object:, context:)
+        super
+        # Figure out whether this is an update or an initial subscription
+        @mode = context.query.subscription_update? ? :update : :subscribe
+      end
+
+      # Implement the {Resolve} API
+      def resolve(**args)
+        # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
+        # have an unexpected `@mode`
+        public_send("resolve_#{@mode}", args)
+      end
+
+      # Wrap the user-defined `#subscribe` hook
+      def resolve_subscribe(args)
+        ret_val = args.any? ? subscribe(args) : subscribe
+        if ret_val == :no_response
+          context.skip
+        else
+          ret_val
+        end
+      end
+
+      # Default implementation returns the root object.
+      # Override it to return an object or
+      # `:no_response` to return nothing.
+      #
+      # The default is `:no_response`.
+      def subscribe(args)
+        :no_response
+      end
+
+      # Wrap the user-provided `#update` hook
+      def resolve_update(args)
+        ret_val = args.any? ? update(args) : update
+        if ret_val == :no_update
+          raise NoUpdateError
+        else
+          ret_val
+        end
+      end
+
+      # The default implementation returns the root object.
+      # Override it to return `:no_update` if you want to
+      # skip updates sometimes. Or override it to return a different object.
+      def update(args = {})
+        object
+      end
+
+      # If an argument is flagged with `loads:` and no object is found for it,
+      # remove this subscription (assuming that the object was deleted in the meantime,
+      # or that it became inaccessible).
+      def load_application_object_failed(err)
+        if @mode == :update
+          unsubscribe
+        end
+        super
+      end
+
+      # Call this to halt execution and remove this subscription from the system
+      def unsubscribe
+        raise UnsubscribedError
+      end
+    end
+  end
+end

data/lib/graphql/schema/traversal.rb

@@ -21,15 +21,19 @@ module GraphQL
       def initialize(schema, introspection: true)
         @schema = schema
         @introspection = introspection
+        built_in_insts = [
+          GraphQL::Relay::ConnectionInstrumentation,
+          GraphQL::Relay::EdgesInstrumentation,
+          GraphQL::Relay::Mutation::Instrumentation,
+        ]
+
+        if schema.query_execution_strategy != GraphQL::Execution::Interpreter
+          built_in_insts << GraphQL::Schema::Member::Instrumentation
+        end
+
         @field_instrumenters =
           schema.instrumenters[:field] +
-            # Wrap Relay-related objects in wrappers
-            [
-              GraphQL::Relay::ConnectionInstrumentation,
-              GraphQL::Relay::EdgesInstrumentation,
-              GraphQL::Relay::Mutation::Instrumentation,
-              GraphQL::Schema::Member::Instrumentation,
-            ] +
+            built_in_insts +
             schema.instrumenters[:field_after_built_ins]
 
         # These fields have types specified by _name_,