rails-graphql 0.2.0 → 1.0.0.beta

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,28 @@ 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)
+            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
 
+        # Find the parent object
+        def parent
+          at(1)
+        end
+
         # Get the current value, which basically means basically the first item
-        # on the current stafck
+        # on the current stack
         def current_value
-          @stack[0]
+          at(0)
         end
 
         # Change the current value, either form hits or the actual value

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Errors
       #
-      # This class is inspired by +ActiveModel::Erros+. The idea is to hold all
+      # This class is inspired by +ActiveModel::Errors+. The idea is to hold all
       # the errors that happened during the execution of a request. It also
       # helps to export such information to the result object.
       class Errors
@@ -27,7 +27,7 @@ module Rails # :nodoc:
           @items.deep_dup
         end
 
-        # Add +message+ to the list of errors. Any other keywork argument will
+        # Add +message+ to the list of errors. Any other keyword argument will
         # be used on set on the +:extensions+ part.
         #
         # ==== Options
@@ -42,12 +42,22 @@ module Rails # :nodoc:
           item['locations'] ||= [{ line: line.to_i, column: col.to_i }] \
             if line.present? && col.present?
 
-          item['path'] = path if path.present? && path.is_a?(Array)
+          item['path'] = path if path.present? && path.is_a?(::Array)
           item['extensions'] = extra.deep_stringify_keys if extra.present?
           item['locations']&.map!(&:stringify_keys)
 
           @items << item.compact
         end
+
+        # Dump the necessary information from errors to a cached operation
+        def cache_dump
+          @items.select { |item| item.dig('extensions', 'stage') == 'organize' }
+        end
+
+        # Load the necessary information from a cached request data
+        def cache_load(data)
+          @items += data
+        end
       end
     end
   end

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

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQL Request Event
       #
       # A small extension of the original event to support extra methods and
       # helpers when performing events during a request
       class Event < GraphQL::Event
-        OBJECT_BASED_READERS = %i[fragment operation spread].freeze
+        OBJECT_BASED_READERS = %i[fragment spread].freeze
 
-        delegate :schema, :errors, :context, to: :request
+        delegate :errors, :context, to: :request
         delegate :instance_for, to: :strategy
-        delegate :memo, to: :source
+        delegate :memo, :schema, to: :source
+        delegate :subscription_field, to: :schema
 
         attr_reader :strategy, :request, :index
 
@@ -33,6 +34,11 @@ module Rails # :nodoc:
           super(name, source, **data)
         end
 
+        # If the source is a field, than also compare to the actual field
+        def same_source?(other)
+          super || (source.try(:kind) == :field && source.field == other)
+        end
+
         # Provide a way to access the current field value
         def current_value
           resolver&.current_value
@@ -45,6 +51,11 @@ module Rails # :nodoc:
           resolver&.override_value(value)
         end
 
+        # Get the operation for the current source
+        def operation
+          (object.kind == :operation) ? object : source.operation
+        end
+
         # Return the strategy context as the resolver
         def resolver
           strategy.context
@@ -52,7 +63,7 @@ module Rails # :nodoc:
 
         # Return the actual field when the source is a request field
         def field
-          source.field if source.try(:kind) === :field
+          source.field if source.try(:kind) == :field
         end
 
         # Check if the event source is of the given +type+
@@ -99,7 +110,7 @@ module Rails # :nodoc:
           # it will return the object
           def method_missing(method_name, *args, **xargs, &block)
             if OBJECT_BASED_READERS.include?(method_name)
-              object if object.kind === method_name
+              object if object.kind == method_name
             elsif current_value&.respond_to?(method_name)
               current_value&.public_send(method_name, *args, **xargs, &block)
             else

data/lib/rails/graphql/request/helpers/directives.rb

@@ -1,62 +1,103 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # Helper module to collect the directives from fragments, operations, and
       # fields.
       module Directives
         # Get the list of listeners from directives set during the request only
-        def all_listeners
-          directives.map(&:all_listeners).reduce(:+) || Set.new
+        def directive_listeners
+          return unless directives?
+          return @directive_listeners if defined?(@directive_listeners)
+          @directive_listeners = directives.map(&:all_listeners).compact.reduce(:+)
         end
 
+        alias all_listeners directive_listeners
+
         # Get the list of events from directives set during the request only and
         # then caches it by request
-        def all_events
-          @all_events ||= directives.map(&:all_events).inject({}) do |lhash, rhash|
-            Helpers.merge_hash_array(lhash, rhash)
+        def directive_events
+          return unless directives?
+          @directive_events ||= begin
+            directives.map(&:all_events).compact.inject({}) do |lhash, rhash|
+              Helpers.merge_hash_array(lhash, rhash)
+            end
           end
         end
 
+        alias all_events directive_events
+
+        # Check if the current component is using a directive
+        def using?(item)
+          return false unless directives?
+
+          directive = (item.is_a?(Symbol) || item.is_a?(String)) ? find_directive!(item) : item
+          (directive < GraphQL::Directive) && directives.any?(directive)
+        end
+
+        # Build the cache object
+        def cache_dump
+          return super unless defined?(@directives)
+
+          super.merge(directives: all_to_gid(@directives.transform_values))
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          return super unless data.key?(:directives)
+
+          @directives = all_from_gid(data[:directives].transform_values).freeze
+
+          super
+        end
+
         protected
 
           # Make sure to always return a set
           def directives
-            @directives || Set.new
+            @directives if directives?
           end
 
-          alias all_directives directives
+          # Check if any execution directive was added
+          def directives?
+            defined?(@directives)
+          end
 
           # Helper parser for directives that also collect necessary variables
-          def parse_directives(location = nil)
-            list = []
-
-            visitor.collect_directives(*data[:directives]) do |data|
-              instance = find_directive!(data[:name])
+          def parse_directives(nodes, location = nil)
+            return if nodes.nil?
 
-              args = directive_arguments(instance)
-              args = collect_arguments(args, data[:arguments]) do |errors|
-                "Invalid arguments for @#{instance.gql_name} directive" \
-                  " added to #{gql_name} #{kind}: #{errors}."
+            list = nil
+            nodes.each do |(name, arguments)|
+              instance = find_directive!(name.to_s)
+              values = arguments&.each_with_object({}) do |(name, value, var_name), hash|
+                hash[name.to_s] = var_name.nil? ? value : var_name
               end
 
-              list << instance.new(request.build(Request::Arguments, args))
-            end unless data[:directives].blank?
+              args = directive_arguments(instance)
+              args = collect_arguments(args, values)
 
-            if list.present?
-              event = Event.new(:attach, strategy, self, phase: :execution)
-              list = GraphQL.directives_to_set(list, [], event, location: location || kind)
+              (list ||= []) << instance.new(request.build(Request::Arguments, args))
+            rescue ArgumentsError => error
+              raise ArgumentsError, (+<<~MSG).squish
+                Invalid arguments for @#{instance.gql_name} directive
+                added to #{gql_name} #{kind}: #{error.message}.
+              MSG
             end
 
+            event = Event.new(:attach, strategy, self, phase: :execution)
+            list = GraphQL.directives_to_set(list, [], event, location: location || kind)
+
             @directives = list.freeze
           end
 
           # Get and cache all the arguments for this given +directive+
           def directive_arguments(directive)
-            request.cache(:arguments)[directive] ||= begin
-              result = directive.all_arguments
-              result.each_value.map(&:gql_name).zip(result.each_value).to_h
+            request.nested_cache(:arguments, directive) do
+              directive.all_arguments&.each_value&.with_object({}) do |directive, hash|
+                hash[directive.gql_name] = directive
+              end
             end
           end
       end

data/lib/rails/graphql/request/helpers/selection_set.rb

@@ -1,43 +1,70 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # Helper module to collect the fields from fragments, operations, and also
       # other fields.
       module SelectionSet
         attr_reader :selection
 
+        # Build the cache object
+        def cache_dump
+          return super unless defined?(@selection)
+
+          selection = @selection.transform_values do |field|
+            field.cache_dump.merge(type: field.class)
+          end
+
+          super.merge(selection: selection)
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          return super unless data.key?(:selection)
+
+          @selection = data[:selection].transform_values do |data|
+            component = request.build_from_cache(data[:type])
+            component.instance_variable_set(:@parent, self)
+            component.cache_load(data)
+            component
+          end.freeze
+
+          super
+        end
+
         protected
 
-          # Helper parser for selection fields that also asssign the actual
+          # Helper parser for selection fields that also assign the actual
           # field defined under the schema structure
-          def parse_selection
+          def parse_selection(nodes)
+            return if nodes.nil?
+
             @selection = {}
             assigners = Hash.new { |h, k| h[k] = [] }
 
-            visitor.collect_fields(*data[:selection]) do |kind, node, data|
-              component = add_component(kind, node, data)
-              assigners[component.name] << component if component.assignable?
-            end unless data[:selection].nil? || data[:selection].null?
+            nodes.each do |node|
+              component = add_component(node)
+              assigners[component.name.to_s] << component if component.assignable?
+            end
 
-            assing_fields!(assigners)
+            assign_fields!(assigners)
             @selection.freeze
           end
 
           # Using +fields_source+, find the needed ones to be assigned to the
           # current requested fields. As shown by benchmark, since the index is
           # based on Symbols, the best way to find +gql_name+ based fields is
-          # through interation and search. Complexity O(n)
-          def assing_fields!(assigners)
+          # through iteration and search. Complexity O(n)
+          def assign_fields!(assigners)
             pending = assigners.map(&:size).reduce(:+) || 0
             return if pending.zero?
 
-            fields_source.each_value do |field|
+            fields_source&.each_value do |field|
               next unless assigners.key?(field.gql_name)
 
               items = assigners[field.gql_name]
-              items.each_with_object(field).each(&:assing_to)
+              items.each_with_object(field).each(&:assign_to)
               break if (pending -= items.size) === 0
             end
           end
@@ -45,20 +72,19 @@ module Rails # :nodoc:
           # Recursive operation that perform the organization step for the
           # selection
           def organize_fields
-            selection.each_value(&:organize!) if selection.any?
+            selection.each_value(&:organize!) if selection.present?
           end
 
           # Find all the fields that have a prepare step and execute them
           def prepare_fields
-            return unless selection.any?
-            (strategy.listeners[:prepare] & selection.values).each(&:prepare!)
+            selection.each_value(&:prepare!) if selection.present?
           end
 
           # Trigger the process of resolving the value of all the fields. Since
           # complex object may or may not be inside an array, this helps to
           # decide if a new stack should be started or not
           def resolve_fields(object = nil)
-            return unless selection.any?
+            return unless selection.present?
 
             items = selection.each_value
             items = items.each_with_object(object) unless object.nil?
@@ -70,15 +96,15 @@ module Rails # :nodoc:
 
         private
 
-          def add_component(kind, node, data)
-            item_name = data.try(:alias).presence || data[:name]
+          def add_component(node)
+            item_name = node[1] || node[0]
 
-            if kind === :spread
-              selection[selection.size] = request.build(Component::Spread, self, node, data)
-            elsif data[:name] === '__typename'
-              selection[item_name] ||= request.build(Component::Typename, self, node, data)
+            if node.of_type?(:spread)
+              selection[selection.size] = request.build(Component::Spread, self, node)
+            elsif node[0] === '__typename'
+              selection[item_name] ||= request.build(Component::Typename, self, node)
             else
-              selection[item_name] ||= request.build(Component::Field, self, node, data)
+              selection[item_name] ||= request.build(Component::Field, self, node)
             end
           end
       end