rails-graphql 0.2.1 → 1.0.0.rc1

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
@@ -72,6 +73,13 @@ module Rails # :nodoc:
           schema.fields_for(type)
         end
 
+        # Allow accessing the fake type form the schema. It's used for
+        # inline spreads without a specified type
+        def type_klass
+          return @type_klass if defined?(@type_klass)
+          @type_klass = schema.public_send("#{type}_type")
+        end
+
         # The typename is always based on the fake name used for the set of
         # schema fields
         def typename
@@ -88,22 +96,48 @@ 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|
+            value ^ 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
 
           # Trigger an specific event with the +type+ of the operation
           def organize
+            trigger_event(type)
             organize_then do
-              trigger_event(type)
               yield if block_given?
               organize_fields
               report_unused_variables
@@ -113,15 +147,15 @@ 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
 
           # Resolve all the fields
-          def resolve
-            resolve_then { resolve_fields }
+          def resolve_then(&block)
+            super(block) { resolve_fields }
           end
 
           # Don't stack over response when the operation doesn't have a name
@@ -133,42 +167,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,33 +95,42 @@ module Rails # :nodoc:
           def organize_then(&block)
             super(block) do
               if inline?
-                @type_klass = find_type!(data[:type])
-                parse_selection
+                @type_klass = @node[1].nil? ? parent.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'
+            catch(:fragment_prepared) do
+              return fragment.prepare!
+            end
+
+            invalidate!
+            raise ExecutionError, (+<<~MSG).squish
+              Fields inside the "#{name}" fragment tried to be prepared more than once.
+              This feature is not supported yet.
+            MSG
           end
 
           # Resolve the spread operation
           def resolve
-            return if invalid?
+            return if unresolvable?
 
-            object = (defined?(@current_object) && @current_object) || parent.type_klass
+            object = (defined?(@current_object) && @current_object)
+            object ||= parent.type_klass unless parent.kind == :operation
             return run_on_fragment(:resolve_with!, object) unless inline?
 
-            super if type_klass =~ object
+            super if (object.nil? && type_klass&.operational?) || type_klass =~ object
           end
 
           # This will just trigger the selection resolver
@@ -111,7 +141,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
@@ -47,7 +45,24 @@ module Rails # :nodoc:
 
         # Write the typename information
         def write_value(value)
-          response.serialize(Type::Scalar::StringScalar, gql_name, value)
+          response.serialize(Type::Scalar::StringScalar, gql_name, value.itself)
+        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
@@ -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
 

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

@@ -1,80 +1,104 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Component
       #
       # Component is an abstraction of any possible type of object represented
       # by a not of the document of a request. This class helps building
       # cross-component features, like holding event listeners, setting up
-      # commom initializer and providing helpers
+      # common initializer and providing helpers
       class Component
         extend ActiveSupport::Autoload
 
         include Request::Organizable
-        include Request::Prepareable
-        include Request::Resolveable
+        include Request::Preparable
+        include Request::Resolvable
 
         class << self
           # Return the kind of the component
           def kind
             @kind ||= name.demodulize.underscore.to_sym
           end
-
-          # Helper to memoize results from parent delegation
-          def parent_memoize(*methods)
-            methods.each do |method_name|
-              define_method(method_name) do
-                result = parent.public_send(method_name)
-                define_singleton_method(method_name) { result }
-                result
-              end
-            end
-          end
         end
 
-        attr_reader :data
-
-        delegate :schema, :visitor, :response, :strategy, to: :request
+        delegate :visitor, :response, :strategy, to: :request
         delegate :find_type!, :find_directive!, :trigger_event, to: :strategy
-        delegate :memo, to: :operation
+        delegate :memo, :schema, to: :operation
         delegate :kind, to: :class
 
         alias of_type? is_a?
 
         eager_autoload do
           autoload :Field
-          autoload :Fragment
           autoload :Operation
-          autoload :Spread
-          autoload :Typename
         end
 
-        def initialize(node, data)
+        autoload :Fragment
+        autoload :Spread
+        autoload :Typename
+
+        def initialize(node)
           @node = node
-          @data = data
         end
 
         # Check if the component is in a invalid state
         def invalid?
-          defined?(@invalid) && @invalid
+          defined?(@invalid) && @invalid.present?
+        end
+
+        # Check if the component is marked as skipped
+        def skipped?
+          defined?(@skipped) && @skipped
+        end
+
+        # Just a fancy name for invalid or skipped
+        def unresolvable?
+          invalid? || skipped?
         end
 
         # Mark the component as invalid
-        def invalidate!
-          @invalid = true
+        def invalidate!(type = true)
+          @invalid = type
+        end
+
+        # Skip the component
+        def skip!
+          @skipped = true
         end
 
-        # Normaly, components are not assignable, only fields are
+        # Normally, components are not assignable, only fields are
         def assignable?
           false
         end
 
+        # Get an identifier of the component
+        def hash
+          @node.hash
+        end
+
+        # Build the cache object
+        def cache_dump
+          hash = { node: @node }
+          hash[:invalid] = @invalid if defined?(@invalid) && @invalid != :authorization
+          hash[:skipped] = @skipped if defined?(@skipped) && @skipped
+          hash.merge!(super)
+          hash
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @node = data[:node]
+          @invalid = data[:invalid] if data.key?(:invalid)
+          @skipped = data[:skipped] if data.key?(:skipped)
+          super
+        end
+
         protected
 
           # It's extremely important to have a way to access the current request
-          # since not all objects stores s direct pointer to it
+          # since not all objects stores a direct pointer to it
           def request
             raise NotImplementedError
           end
@@ -86,13 +110,30 @@ module Rails # :nodoc:
 
           # Run a given block and ensure to capture exceptions to set them as
           # errors
-          def capture_exception(stage, invalidate = false)
-            yield
-          rescue StandardError => error
-            invalidate! if invalidate
+          def report_exception(error)
+            return if request.rescue_with_handler(error, source: self) == false
+
+            Backtrace.print(error, self, request)
+
             stack_path = request.stack_to_path
             stack_path << gql_name if respond_to?(:gql_name) && gql_name.present?
-            request.exception_to_error(error, @node, path: stack_path, stage: stage.to_s)
+            request.exception_to_error(error, self, path: stack_path, stage: strategy.stage.to_s)
+          end
+
+        private
+
+          # Properly transform values to string gid
+          def all_to_gid(enum)
+            (enum.is_a?(Enumerable) ? enum : enum.then).each do |item|
+              item.to_gid.to_s
+            end
+          end
+
+          # Properly recover values from gid string
+          def all_from_gid(enum)
+            (enum.is_a?(Enumerable) ? enum : enum.then).each do |item|
+              GraphQL::GlobalID.find(item)
+            end
           end
       end
     end

data/lib/rails/graphql/request/context.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 Context
       #
       # This class is used as context for the response while processing fields,
@@ -23,9 +23,14 @@ module Rails # :nodoc:
           @stack.shift
         end
 
-        # Find the parent object
-        def parent
-          @stack[1]
+        # Return a duplicated version of the stack, for safety
+        def stack
+          @stack.dup
+        end
+
+        # Get a value at the given +index+
+        def at(index)
+          @stack[index]
         end
 
         # Get all ancestors objects
@@ -33,10 +38,15 @@ module Rails # :nodoc:
           @stack[1..-1]
         end
 
-        # Get the current value, which basically means basically the first item
-        # on the current stafck
+        # Find the parent object
+        def parent
+          at(1)
+        end
+
+        # Get the current value, which basically means the first item
+        # on the current stack
         def current_value
-          @stack[0]
+          at(0)
         end
 
         # Change the current value, either form hits or the actual value