rails-graphql 0.2.1 → 1.0.0.beta

data/lib/rails/graphql/request/component/operation/subscription.rb

@@ -1,14 +1,174 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
-      class Component # :nodoc:
+module Rails
+  module GraphQL
+    class Request
+      class Component
         # = GraphQL Request Component Subscription Operation
         #
         # Handles a subscription operation inside a request.
         class Operation::Subscription < Operation
+          UNSUBSCRIBED_PAYLOAD = { 'more' => false }.freeze
+          UNSUBSCRIBED_RESULT = Object.new
+
           redefine_singleton_method(:subscription?) { true }
+
+          def initialize(*)
+            @initial = true
+
+            super
+          end
+
+          # Fetch the subscription only when necessary
+          def subscription
+            return unless defined?(@subscription)
+            return @subscription if @subscription.is_a?(Request::Subscription)
+            @subscription = schema.subscription_provider.fetch(@subscription)
+          end
+
+          # Check if the operation is running in its first iteration, which will
+          # produce a subscription to the field
+          def subscribing?
+            @initial
+          end
+
+          # Check if the current operation is running under broadcasting mode
+          def broadcasting?
+            request.context.broadcasting == true
+          end
+
+          # Check if the operation can be broadcasted
+          def broadcastable?
+            return @broadcastable if defined?(@broadcastable)
+            @broadcastable = selection.each_value.all?(&:broadcastable?)
+          end
+
+          # Either throw back an empty result or skip the operation
+          def no_update!
+            subscribing? ? skip! : throw(:skip_subscription_update, EMPTY_HASH)
+          end
+
+          # If unsubscribe is called during an update, skip and return a proper
+          # result
+          def unsubscribe!
+            if subscribing?
+              schema.remove_subscriptions(subscription.sid) if subscription.present?
+            else
+              throw(:skip_subscription_update, UNSUBSCRIBED_RESULT)
+            end
+          end
+
+          # Build the cache object
+          def cache_dump(initial = true)
+            hash = super()
+            hash[:initial] = initial
+            hash[:broadcastable] = broadcastable?
+
+            unless initial
+              hash[:sid] = @subscription&.sid
+              hash[:variables] = @variables
+            end
+
+            hash
+          end
+
+          # Organize from cache data
+          def cache_load(data)
+            @initial = data[:initial]
+            @broadcastable = data[:broadcastable]
+
+            unless subscribing?
+              @variables = data[:variables]
+              @subscription = data[:sid]
+            end
+
+            super
+          end
+
+          protected
+
+            # Rewrite this method so that the subscription can be generated in
+            # the right place
+            def resolve_then(after_block = nil, &block)
+              subscribe_block = -> do
+                save_subscription
+                trigger_event(:subscribed)
+                after_block.call if after_block.present?
+              end
+
+              super(subscribe_block, &block)
+            end
+
+            # Save the subscription using the schema subscription provider
+            def save_subscription
+              return unless subscribing? && !(invalid? ||skipped?)
+              check_invalid_subscription!
+
+              @subscription = Request::Subscription.new(request, self)
+              request.write_cache_request(subscription.sid, build_subscription_cache)
+              schema.add_subscriptions(subscription)
+
+              request.subscriptions[subscription.sid] = subscription
+            rescue => e
+              if subscription.present?
+                schema.delete_from_cache(subscription.sid)
+                schema.remove_subscriptions(subscription.sid)
+              end
+
+              raise SubscriptionError, (+<<~MSG).squish
+                Unable to proper setup a subscription on #{display_name}: #{e.message}
+              MSG
+            end
+
+            # A subscription is invalid if more than one field was requested or
+            # if the only thing in the selection is a spread
+            def check_invalid_subscription!
+              raise ValidationError, (+<<~MSG).squish if @selection.size != 1
+                It has #{@selection.size} and must have 1 single field on it.
+              MSG
+
+              element = @selection.each_value.first
+              raise ValidationError, (+<<~MSG).squish unless element.kind == :field
+                The only element inside of it must be a field, #{element.kind} found.
+              MSG
+
+              raise ValidationError, (+<<~MSG).squish if element.is_a?(Component::Typename)
+                Unable to subscribe to a __typeName field.
+              MSG
+
+              raise ValidationError, (+<<~MSG).squish if element.unresolvable?
+                Field is unresolvable.
+              MSG
+
+              raise ValidationError, (+<<~MSG).squish unless schema.accepts_subscription?(self)
+                Operation unaccepted.
+              MSG
+            end
+
+            # Very similar to the +cache_dump+ from the request, however this
+            # will chop the parts exclusively for the subscription
+            def build_subscription_cache
+              # Prepare each used fragment to be set on cache and on the document
+              frag_nodes = []
+              fragments = used_fragments.empty? ? nil : begin
+                request.fragments.slice(*used_fragments).transform_values do |frag|
+                  frag_nodes << frag.instance_variable_get(:@node)
+                  frag.try(:cache_dump)
+                end.compact
+              end
+
+              # Return the cache result
+              {
+                strategy: { class: request.strategy.class },
+                operation_name: request.operation_name,
+                type_map_version: request.schema.version,
+                document: [[@node], frag_nodes.presence],
+                errors: request.errors.cache_dump,
+                operations: { name => cache_dump(false) },
+                fragments: fragments,
+              }
+            end
+
         end
       end
     end

data/lib/rails/graphql/request/component/operation.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Component Operation
       #
       # This class holds information about a given operation. This will guide
@@ -16,9 +16,9 @@ module Rails # :nodoc:
         class << self
           alias type kind
 
-          # Helper method to initialize an operation given the data
-          def build(request, node, data)
-            request.build(const_get(data[:kind].classify), request, node, data)
+          # Helper method to initialize an operation given the node
+          def build(request, node)
+            request.build(const_get(node.type.to_s.classify), request, node)
           end
 
           # Rewrite the kind to always return +:operation+
@@ -49,6 +49,7 @@ module Rails # :nodoc:
         autoload :Subscription
 
         delegate :type, :query?, :mutation?, :subscription?, to: :class
+        delegate :schema, to: :strategy
 
         attr_reader :name, :variables, :arguments, :request
 
@@ -57,11 +58,11 @@ module Rails # :nodoc:
         alias vars variables
         alias all_arguments arguments
 
-        def initialize(request, node, data)
-          @name = data[:name]
+        def initialize(request, node)
+          @name = node[1]
           @request = request
 
-          super(node, data)
+          super(node)
 
           check_invalid_operation!
         end
@@ -88,14 +89,40 @@ module Rails # :nodoc:
           response.safe_add(name, nil) if stacked_selection?
         end
 
-        # Stores all the used arguments to report not used ones
+        # Stores all the used variables to report not used ones
         def used_variables
           @used_variables ||= Set.new
         end
 
+        # Stores all the used fragments
+        def used_fragments
+          @used_fragments ||= Set.new
+        end
+
         # A fast way to access the correct display name for log or errors
         def log_source
-          @log_source ||= name.blank? ? type : "#{name} #{type}"
+          @log_source ||= name.blank? ? type : +"#{name} #{type}"
+        end
+
+        # The hash of operations must take into consideration the used fragments
+        def hash
+          return super unless defined?(@used_fragments)
+
+          super ^ used_fragments.reduce(0) do |value, fragment|
+            request.fragments[fragment].hash
+          end
+        end
+
+        # Build the cache object
+        def cache_dump
+          super.merge(type: self.class)
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][1]
+
+          super
         end
 
         protected
@@ -113,9 +140,9 @@ module Rails # :nodoc:
           # Perform the organization step
           def organize_then(&block)
             super(block) do
-              parse_variables
-              parse_directives(type)
-              parse_selection
+              parse_variables(@node[2])
+              parse_directives(@node[3], type)
+              parse_selection(@node[4])
             end
           end
 
@@ -133,42 +160,47 @@ module Rails # :nodoc:
 
           # Name used for debug purposes
           def display_name
-            @display_name ||= "#{type.to_s.titlecase} #{name.presence || '__default__'}"
+            @display_name ||= +"#{type.to_s.titlecase} #{name.presence || '__default__'}"
           end
 
-          # Add an error for each not used variable and then clean up some data
+          # Add an error for each not used variable
           def report_unused_variables
+            return if arguments.nil?
+
             (arguments.keys - used_variables.to_a).each do |key|
               argument = arguments[key]
-              request.report_node_error(<<~MSG.squish, argument.node || @node)
-                Unused variable $#{argument.gql_name} on #{log_source}.
+              request.report_node_error((+<<~MSG).squish, argument.node)
+                Variable $#{argument.gql_name} was provided to #{log_source} but not used.
               MSG
             end
 
-            @arguments = nil
+            # Report all used variables to the request for greater scope
+            request.instance_variable_get(:@used_variables).merge(arguments.keys)
+
+            # Clear anything that is not necessary anymore
             @used_variables = nil
           end
 
           # If there is another operation with the same name already defined,
           # raise an error. If an anonymous was started, then any other
-          # operatios is invalid.
+          # operations is invalid.
           def check_invalid_operation!
-            if request.operations.key?(nil)
-              invalidate!
+            other = request.document[0].find do |other|
+              other != @node && name == other[1]
+            end
+
+            return if other.nil?
+            invalidate!
 
-              request.report_node_error(<<~MSG.squish, @node)
+            if name.nil?
+              request.report_node_error((+<<~MSG).squish, self)
                 Unable to process the operation #{display_name} when the document
                 contain multiple anonymous operations.
               MSG
-            elsif request.operations.key?(name)
-              invalidate!
-
-              other_node = request.operations[name].instance_variable_get(:@node)
-              location = GraphQL::Native.get_location(other_node)
-
-              request.report_node_error(<<~MSG.squish, @node)
+            else
+              request.report_node_error((+<<~MSG).squish, self)
                 Duplicated operation named "#{name}" defined on
-                line #{location.begin_line}:#{location.begin_column}.
+                line #{other.begin_line}:#{other.begin_column}.
               MSG
             end
           end

data/lib/rails/graphql/request/component/spread.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Component Spread
       #
       # This class holds information about a given spread that should be
@@ -11,20 +11,18 @@ module Rails # :nodoc:
         include SelectionSet
         include Directives
 
-        delegate :operation, :typename, to: :parent
+        delegate :operation, :typename, :request, to: :parent
         delegate :variables, to: :operation
 
-        parent_memoize :request
+        attr_reader :name, :parent, :fragment, :current_object, :type_klass
 
-        attr_reader :name, :parent, :fragment, :type_klass
-
-        def initialize(parent, node, data)
+        def initialize(parent, node)
           @parent = parent
 
-          @name = data[:name]
-          @inline = data[:inline]
+          @name = node[0]
+          @inline = name.nil?
 
-          super(node, data)
+          super(node)
         end
 
         # Check if the object is an inline spread
@@ -32,9 +30,14 @@ module Rails # :nodoc:
           @inline.present?
         end
 
+        # Check if all the sub fields or the fragment is broadcastable
+        def broadcastable?
+          inline? ? selection.each_value.all?(&:broadcastable?) : fragment.broadcastable?
+        end
+
         # Redirect to the fragment or check the inline type before resolving
         def resolve_with!(object)
-          return if invalid?
+          return if unresolvable?
 
           @current_object = object
           resolve!
@@ -42,6 +45,25 @@ module Rails # :nodoc:
           @current_object = nil
         end
 
+        # Build the cache object
+        def cache_dump
+          inline? ? super.merge(type_klass: all_to_gid(type_klass)) : super
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][0]
+          @inline = name.nil?
+
+          if inline?
+            @type_klass = all_from_gid(data[:type_klass])
+          else
+            collect_fragment
+          end
+
+          super
+        end
+
         protected
 
           # Spread always resolve inline selection unstacked on response,
@@ -51,13 +73,13 @@ module Rails # :nodoc:
           end
 
           # Just provide the correct location for directives
-          def parse_directives
-            super(inline? ? :inline_fragment : :fragment_spread)
+          def parse_directives(nodes)
+            super(nodes, (inline? ? :inline_fragment : :fragment_spread))
           end
 
           # Scope the arguments whenever stacked within a spread
           def stacked(*)
-            Request::Arguments.scoped(operation) { super }
+            Arguments.scoped(operation) { super }
           end
 
           # Normal mode of the organize step
@@ -66,7 +88,6 @@ module Rails # :nodoc:
           def organize
             inline? ? organize_then { organize_fields } : organize_then do
               run_on_fragment(:organize!)
-              # Ensure necessary variables
             end
           end
 
@@ -74,28 +95,28 @@ module Rails # :nodoc:
           def organize_then(&block)
             super(block) do
               if inline?
-                @type_klass = find_type!(data[:type])
-                parse_selection
+                @type_klass = find_type!(@node[1])
+                parse_directives(@node[2])
+                parse_selection(@node[3])
               else
-                @fragment = request.fragments[name]
-                raise ArgumentError, <<~MSG.squish if @fragment.nil?
+                parse_directives(@node[2])
+                @fragment = collect_fragment
+                raise ArgumentError, (+<<~MSG).squish if @fragment.nil?
                   The "#{name}" fragment is not defined in this request.
                 MSG
               end
-
-              parse_directives
             end
           end
 
           # Spread has a special behavior when using a fragment
           def prepare
             return super if inline?
-            raise 'Prepare with fragment not implemented yet'
+            raise(+'Prepare with fragment not implemented yet')
           end
 
           # Resolve the spread operation
           def resolve
-            return if invalid?
+            return if unresolvable?
 
             object = (defined?(@current_object) && @current_object) || parent.type_klass
             return run_on_fragment(:resolve_with!, object) unless inline?
@@ -111,7 +132,29 @@ module Rails # :nodoc:
           # Most of the things that are redirected to the fragment needs to run
           # inside a arguments scoped
           def run_on_fragment(method_name, *args)
-            Request::Arguments.scoped(operation) { fragment.public_send(method_name, *args) }
+            Arguments.scoped(operation) { fragment.public_send(method_name, *args) }
+          end
+
+          # Only initialize the fragment once and only when requested for the
+          # first time. It also reports to the operation the used variables
+          # within the fragment
+          def collect_fragment
+            node = request.fragments[name]
+
+            if node.is_a?(Component::Fragment)
+              unless (used_variables = node.used_variables).nil?
+                operation.used_variables.merge(used_variables)
+              end
+
+              unless (used_fragments = node.used_fragments).nil?
+                operation.used_fragments.merge(used_fragments)
+              end
+
+              node
+            else
+              operation.used_fragments << name
+              request.fragments[name] = request.build(Component::Fragment, request, node)
+            end
           end
       end
     end

data/lib/rails/graphql/request/component/typename.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Component Typename
       #
       # Extra component which simulates a field that its only purpose is to
@@ -11,11 +11,9 @@ module Rails # :nodoc:
         include ValueWriters
         include Directives
 
-        delegate :operation, to: :parent
+        delegate :operation, :request, to: :parent
         delegate :variables, to: :operation
 
-        parent_memoize :request
-
         attr_reader :name, :alias_name, :parent
 
         # Rewrite the kind to always return +:field+
@@ -23,13 +21,13 @@ module Rails # :nodoc:
           :field
         end
 
-        def initialize(parent, node, data)
+        def initialize(parent, node)
           @parent = parent
 
-          @name = data[:name]
-          @alias_name = data[:alias]
+          @name = node[0]
+          @alias_name = node[1]
 
-          super(node, data)
+          super(node)
         end
 
         # Set the value that the field will be resolved as
@@ -50,6 +48,23 @@ module Rails # :nodoc:
           response.serialize(Type::Scalar::StringScalar, gql_name, value)
         end
 
+        # Typename is always broadcastable
+        def broadcastable?
+          true
+        end
+
+        # Prepare is not necessary for this field
+        def prepare!
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][0]
+          @alias_name = data[:node][1]
+
+          super
+        end
+
         protected
 
           # Normal mode of the organize step
@@ -59,14 +74,14 @@ module Rails # :nodoc:
 
           # Perform the organization step
           def organize_then(&block)
-            super(block) { parse_directives(:field) }
+            super(block) { parse_directives(@node[3], :field) }
           end
 
           # Go through the right flow to write the value
           def resolve_then
             super do
               typename = @typename || parent.typename
-              raise InvalidValueError, <<~MSG.squish if typename.blank?
+              raise InvalidValueError, (+<<~MSG).squish if typename.blank?
                 The #{gql_name} field value cannot be null.
               MSG