rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/request/component/field.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 Field
       #
       # This class holds information about a given field that should be
@@ -14,61 +14,73 @@ module Rails # :nodoc:
         include Directives
 
         delegate :decorate, to: :type_klass
-        delegate :operation, :variables, to: :parent
+        delegate :operation, :variables, :request, to: :parent
         delegate :method_name, :resolver, :performer, :type_klass, :leaf_type?,
-          :dynamic_resolver?, to: :field
-
-        parent_memoize :request
+          :dynamic_resolver?, :mutation?, to: :field
 
         attr_reader :name, :alias_name, :parent, :field, :arguments, :current_object
 
         alias args arguments
 
-        def initialize(parent, node, data)
+        def initialize(parent, node)
           @parent = parent
 
-          @name = data[:name]
-          @alias_name = data[:alias]
-
-          super(node, data)
-        end
+          @name = node[0]
+          @alias_name = node[1]
 
-        # Return both the field directives and the request directives
-        def all_directives
-          field.all_directives + super
+          super(node)
         end
 
         # Override that considers the requested field directives and also the
         # definition field events, both from itself and its directives events
         def all_listeners
-          (request.cache(:listeners)[field] ||= field.all_listeners) + super
+          request.nested_cache(:listeners, field) do
+            if !field.listeners?
+              directive_listeners
+            elsif !directives?
+              field.all_listeners
+            else
+              local = directive_listeners
+              local.empty? ? field.all_listeners : field.all_listeners + local
+            end
+          end
         end
 
         # Override that considers the requested field directives and also the
         # definition field events, both from itself and its directives events
         def all_events
-          @all_events ||= Helpers.merge_hash_array(
-            (request.cache(:events)[field] ||= field.all_events),
-            super,
-          )
+          request.nested_cache(:events, field) do
+            if !field.events?
+              directive_events
+            elsif !directives?
+              field.all_events
+            else
+              Helpers.merge_hash_array(field.all_events, directive_events)
+            end
+          end
         end
 
         # Get and cache all the arguments for the field
         def all_arguments
-          request.cache(:arguments)[field] ||= begin
-            if (result = field.all_arguments).any?
-              result.each_value.map(&:gql_name).zip(result.each_value).to_h
-            else
-              {}
+          return unless field.arguments?
+
+          request.nested_cache(:arguments, field) do
+            field.all_arguments.each_value.with_object({}) do |argument, hash|
+              hash[argument.gql_name] = argument
             end
           end
         end
 
+        # Check if the field is using a directive
+        def using?(item_or_symbol)
+          super || field.using?(item_or_symbol)
+        end
+
         # Assign a given +field+ to this class. The field must be an output
         # field, which means that +output_type?+ must be true. It also must be
         # called exactly once per field.
-        def assing_to(field)
-          raise ArgumentError, <<~MSG.squish if defined?(@assigned)
+        def assign_to(field)
+          raise ArgumentError, (+<<~MSG).squish if defined?(@assigned)
             The "#{gql_name}" field is already assigned to #{@field.inspect}.
           MSG
 
@@ -85,10 +97,11 @@ module Rails # :nodoc:
           (try(:current_object) || try(:type_klass))&.gql_name
         end
 
-        # Check if the field is an entry point, meaning that its parent is the
-        # operation and it is associated to a schema field
+        # Check if the field is an entry point, meaning that it is attached to
+        # an owner that has Schema Fields
         def entry_point?
-          parent.kind === :operation
+          return @entry_point if defined?(@entry_point)
+          @entry_point = field.entry_point?
         end
 
         # Fields are assignable because they are actually the selection, so they
@@ -97,6 +110,20 @@ module Rails # :nodoc:
           true
         end
 
+        # Check if all the sub fields are broadcastable
+        # TODO: Maybe check for interfaces and if all types allow broadcast
+        def broadcastable?
+          value = field.broadcastable?
+          value = schema.config.default_subscription_broadcastable if value.nil?
+          value != false
+        end
+
+        # Override this to also check if the key would be added to the response
+        # again
+        def skipped?
+          super || response.key?(gql_name)
+        end
+
         # A little extension of the +is_a?+ method that allows checking it using
         # the underlying +field+
         def of_type?(klass)
@@ -106,7 +133,7 @@ module Rails # :nodoc:
         # When the field is invalid, there's no much to do
         # TODO: Maybe add a invalid event trigger here
         def resolve_invalid(error = nil)
-          request.exception_to_error(error, @node) if error.present?
+          request.exception_to_error(error, self) if error.present?
 
           validate_output!(nil)
           response.safe_add(gql_name, nil)
@@ -118,26 +145,45 @@ module Rails # :nodoc:
         # field needs to be redirected to the one from the actual resolved
         # +object+ type
         def resolve_with!(object)
+          return if skipped?
           return resolve! if invalid?
 
           old_field, @field = @field, object[@field.name]
+          request.nested_cache(:listeners, field) { strategy.add_listeners_from(self) }
           @current_object = object
           resolve!
         ensure
           @field, @current_object = old_field, nil
         end
 
+        # Build the cache object
+        # TODO: Add the arguments into the GID, but the problem is variables
+        def cache_dump
+          super.merge(field: (field && all_to_gid(field)))
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][0]
+          @alias_name = data[:node][1]
+          @field = all_from_gid(data[:field])
+          super
+
+          check_authorization! unless unresolvable?
+        end
+
         protected
 
           # Perform the organization step
           def organize_then(&block)
             super(block) do
               check_assignment!
-              check_authorization!
 
-              parse_arguments
-              parse_directives
-              parse_selection
+              parse_directives(@node[3])
+              parse_arguments(@node[2])
+              parse_selection(@node[4])
+
+              check_authorization!
             end
           end
 
@@ -149,8 +195,7 @@ module Rails # :nodoc:
           # Perform the resolve step
           def resolve_then(&block)
             stacked do
-              strategy.perform(self) if field.mutation?
-              send(field.array? ? 'resolve_many' : 'resolve_one', &block)
+              send((field.array? ? :resolve_many : :resolve_one), &block)
             rescue StandardError => error
               resolve_invalid(error)
             end
@@ -181,46 +226,29 @@ module Rails # :nodoc:
             end
           end
 
-          # This override allows reasigned fields to perform events. This
-          # happens when fields are originally organized from interfaces. If
-          # the event is stopped for the object, then it doesn't proceed to the
-          # strategy implementation, ensuring compatibility
-          def trigger_event(event_name, **xargs)
-            return super if !defined?(@current_object) || @current_object.nil?
-
-            listeners = request.cache(:listeners)[field] ||= field.all_listeners
-            return super unless listeners.include?(event_name)
-
-            callbacks = request.cache(:events)[field] ||= field.all_events
-            old_events, @all_events = @all_events, callbacks
-            super
-          ensure
-            @all_events = old_events
-          end
-
           # Check if the field was assigned correctly to an output field
           def check_assignment!
-            raise MissingFieldError, <<~MSG.squish if field.nil?
-              Unable to find a field named "#{gql_name}" on
-              #{entry_point? ? operation.kind : parent.type_klass.name}.
+            raise MissingFieldError, (+<<~MSG).squish if field.nil?
+              Unable to find a field named "#{gql_name}" on #{parent.typename}.
             MSG
 
-            raise FieldError, <<~MSG.squish unless field.output_type?
+            raise FieldError, (+<<~MSG).squish unless field.output_type?
               The "#{gql_name}" was assigned to a non-output type of field: #{field.inspect}.
             MSG
 
-            empty_selection = data[:selection].nil? || data[:selection].null?
-            raise FieldError, <<~MSG.squish if field.leaf_type? && !empty_selection
-              The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
-              is a leaf type and does not have nested fields.
-            MSG
-
-            raise FieldError, <<~MSG.squish if !field.leaf_type? && empty_selection
-              The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
-              is not a leaf type and requires a selection of fields.
-            MSG
+            if @node[4].nil?
+              raise FieldError, (+<<~MSG).squish if !field.leaf_type?
+                The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
+                is not a leaf type and requires a selection of fields.
+              MSG
+            else
+              raise FieldError, (+<<~MSG).squish if field.leaf_type?
+                The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
+                is a leaf type and does not have nested fields.
+              MSG
+            end
 
-            raise DisabledFieldError, <<~MSG.squish if field.disabled?
+            raise DisabledFieldError, (+<<~MSG).squish if field.disabled?
               The "#{gql_name}" was found but it is marked as disabled.
             MSG
           end

data/lib/rails/graphql/request/component/fragment.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 Fragment
       #
       # This class holds information about a given fragment defined using the
@@ -12,19 +12,28 @@ module Rails # :nodoc:
         include SelectionSet
         include Directives
 
-        attr_reader :name, :type_klass, :request
+        attr_reader :name, :type_klass, :request, :current_object
 
-        def initialize(request, node, data)
-          @name = data[:name]
+        def initialize(request, node)
+          @name = node[0]
           @request = request
 
-          super(node, data)
+          super(node)
 
           check_duplicated_fragment!
         end
 
+        # Check if all the sub fields are broadcastable
+        def broadcastable?
+          selection.each_value.all?(&:broadcastable?)
+        end
+
+        # Check if the fragment has been prepared already
+        def prepared?
+          defined?(@prepared) && @prepared
+        end
+
         # Return a lazy loaded variable proc
-        # TODO: Mark all the dependent variables
         def variables
           Request::Arguments.lazy
         end
@@ -34,6 +43,16 @@ module Rails # :nodoc:
           Request::Arguments.operation
         end
 
+        # Stores all the used variables
+        def used_variables
+          return @used_variables if defined?(@used_variables)
+        end
+
+        # Stores all the used nested fragments
+        def used_fragments
+          return @used_fragments if defined?(@used_fragments)
+        end
+
         # Spread should always be performed with a current object, thus the
         # typename comes from it
         def typename
@@ -42,7 +61,7 @@ module Rails # :nodoc:
 
         # Only resolve if the +type_klass+ is equivalent to the given +object+
         def resolve_with!(object)
-          return if invalid?
+          return if unresolvable?
 
           @current_object = object
           resolve!
@@ -50,6 +69,19 @@ module Rails # :nodoc:
           @current_object = nil
         end
 
+        # Build the cache object
+        def cache_dump
+          super.merge(type_klass: all_to_gid(type_klass))
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][0]
+          @type_klass = all_from_gid(data[:type_klass])
+
+          super
+        end
+
         protected
 
           # Fragments always resolve selection unstacked on response, meaning
@@ -58,23 +90,29 @@ module Rails # :nodoc:
             false
           end
 
+          # Wrap the field organization with the collection of variables
+          def organize
+            organize_then { collect_usages { organize_fields } }
+          end
+
           # Perform the organization step
           def organize_then(&block)
             super(block) do
-              @type_klass = find_type!(data[:type])
-              parse_directives(:fragment_definition)
+              @type_klass = find_type!(@node[1])
+              parse_directives(@node[2], :fragment_definition)
 
               check_assignment!
-              parse_selection
+              parse_selection(@node[3])
             end
           end
 
           # Resolve the spread operation
           def resolve
-            return if invalid?
+            return if unresolvable?
 
-            object = @current_object || type_klass
-            resolve_then if type_klass =~ object
+            type = type_klass
+            object = @current_object
+            resolve_then if (object.nil? && type&.operational?) || type =~ object
           end
 
           # This will just trigger the selection resolver
@@ -86,32 +124,48 @@ module Rails # :nodoc:
 
           # Check if the field was assigned correctly to an output field
           def check_assignment!
-            raise ExecutionError, <<~MSG.squish unless type_klass.output_type?
-              Unable to assing #{type_klass.gql_name} to "#{name}" fragment because
+            raise ExecutionError, (+<<~MSG).squish unless type_klass.output_type?
+              Unable to assign #{type_klass.gql_name} to "#{name}" fragment because
               it is not a output type.
             MSG
 
-            raise ExecutionError, <<~MSG.squish if type_klass.leaf_type?
-              Unable to assing #{type_klass.gql_name} to "#{name}" fragment because
-              a "#{type_klass.kind}" type can not be the source of a fragmnet.
+            raise ExecutionError, (+<<~MSG).squish if type_klass.leaf_type?
+              Unable to assign #{type_klass.gql_name} to "#{name}" fragment because
+              a "#{type_klass.kind}" type can not be the source of a fragment.
             MSG
           end
 
           # If there is another fragment with the same name already defined,
           # raise an error
           def check_duplicated_fragment!
-            return unless request.fragments.key?(name)
+            other = request.document[1].find do |other|
+              other != @node && name == other[0]
+            end
 
+            return if other.nil?
             invalidate!
 
-            other_node = request.fragments[name].instance_variable_get(:@node)
-            location = GraphQL::Native.get_location(other_node)
-
-            request.report_node_error(<<~MSG.squish, @node)
+            request.report_node_error((+<<~MSG).squish, self)
               Duplicated fragment named "#{name}" defined on
-              line #{location.begin_line}:#{location.begin_column}
+              line #{other.begin_line}:#{other.begin_column}
             MSG
           end
+
+          # Use the information on the operation to collect all the variables
+          # and nested fragments that were used inside a fragment
+          def collect_usages
+            vars_total = operation.used_variables.size
+            frag_total = operation.used_fragments.size
+            yield
+          ensure
+            if operation.used_variables.size > vars_total
+              @used_variables = Set.new(operation.used_variables.to_enum.drop(vars_total))
+            end
+
+            if operation.used_fragments.size > frag_total
+              @used_fragments = Set.new(operation.used_fragments.to_enum.drop(frag_total))
+            end
+          end
       end
     end
   end

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

@@ -1,14 +1,172 @@
 # 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(&block)
+              super do
+                save_subscription
+                trigger_event(:subscribed, subscription: subscription)
+                block.call if block.present?
+              end
+            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