rails-graphql 0.2.1 → 1.0.0.rc1

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, :extensions, to: :request
         delegate :instance_for, to: :strategy
-        delegate :memo, to: :source
+        delegate :memo, :schema, to: :source
+        delegate :subscription_provider, to: :schema
 
         attr_reader :strategy, :request, :index
 
@@ -33,7 +34,16 @@ module Rails # :nodoc:
           super(name, source, **data)
         end
 
+        # TODO: Implement a faster way to check if if the event is from the
+        # same source by separating exclusive events beforehand
+
+        # 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
+        # TODO: Maybe change this to +current+ to get the value by reference
         def current_value
           resolver&.current_value
         end
@@ -45,6 +55,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 +67,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 +114,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,104 @@
 # 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
+        # TODO: This does not work with the instance
+        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, then search and assign. 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,21 @@ module Rails # :nodoc:
           # Recursive operation that perform the organization step for the
           # selection
           def organize_fields
-            selection.each_value(&:organize!) if selection.any?
+            return unless run_selection?
+            selection.each_value(&:organize!)
           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!)
+            return unless run_selection?
+            selection.each_value(&:prepare!)
           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 run_selection?
 
             items = selection.each_value
             items = items.each_with_object(object) unless object.nil?
@@ -70,15 +98,19 @@ module Rails # :nodoc:
 
         private
 
-          def add_component(kind, node, data)
-            item_name = data.try(:alias).presence || data[:name]
+          def run_selection?
+            selection.present? && !unresolvable?
+          end
+
+          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

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

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # A set of helper methods to write a value to the response
       module ValueWriters
         # TODO: Maybe move this to a setting so it allow extensions
         KIND_WRITERS = {
-          union:     'write_union',
-          interface: 'write_interface',
-          object:    'write_object',
+          union:     :write_union,
+          interface: :write_interface,
+          object:    :write_object,
         }.freeze
 
         # Write a value to the response
         def write_value(value)
           return write_leaf(value) if value.nil?
-          send(KIND_WRITERS[field.kind] || 'write_leaf', value)
+          send(KIND_WRITERS[field.kind] || :write_leaf, value)
         end
 
         # Resolve a given value when it is an array
         def write_array(value, idx = -1, &block)
+          return write_leaf(value) if value.nil?
+
           write_array!(value) do |item|
             stacked(idx += 1) do
               block.call(item, idx)
@@ -30,24 +32,25 @@ module Rails # :nodoc:
               block.call(nil, idx)
               response.next
 
-              format_array_execption(error, idx)
-              request.exception_to_error(error, @node)
+              format_array_exception(error, idx)
+              request.exception_to_error(error, self)
             end
           rescue StandardError => error
-            format_array_execption(error, idx)
+            format_array_exception(error, idx)
             raise
           end
         end
 
         # Helper to start writing as array
+        # TODO: Add the support for `iterator`
         def write_array!(value, &block)
-          raise InvalidValueError, <<~MSG.squish unless value.respond_to?(:each)
+          raise InvalidValueError, (+<<~MSG).squish unless value.respond_to?(:each)
             The #{gql_name} field is excepting an array
             but got an "#{value.class.name}" instead.
           MSG
 
           @writing_array = true
-          response.with_stack(field.gql_name, array: true, plain: leaf_type?) do
+          response.with_stack(gql_name, array: true, plain: leaf_type?) do
             value.each(&block)
           end
         ensure
@@ -55,10 +58,12 @@ module Rails # :nodoc:
         end
 
         # Add the item index to the exception message
-        def format_array_execption(error, idx)
-          real_error = 'The ' + ActiveSupport::Inflector.ordinalize(idx + 1)
-          real_error += " value of the #{gql_name} field"
-          source_error = "The #{gql_name} field value"
+        def format_array_exception(error, idx)
+          real_error = (+<<~MSG).squish
+            The #{ActiveSupport::Inflector.ordinalize(idx + 1)} value of the #{gql_name} field
+          MSG
+
+          source_error = +"The #{gql_name} field value"
 
           message = error.message.gsub(source_error, real_error)
           error.define_singleton_method(:message) { message }
@@ -68,13 +73,13 @@ module Rails # :nodoc:
 
           # Write a value based on a Union type
           def write_union(value)
-            object = type_klass.all_members.reverse_each.find { |t| t.valid_member?(value) }
+            object = type_klass.type_for(value, request)
             object.nil? ? raise_invalid_member! : resolve_fields(object)
           end
 
           # Write a value based on a Interface type
           def write_interface(value)
-            object = type_klass.all_types.reverse_each.find { |t| t.valid_member?(value) }
+            object = type_klass.type_for(value, request)
             object.nil? ? raise_invalid_member! : resolve_fields(object)
           end
 
@@ -105,7 +110,7 @@ module Rails # :nodoc:
           # A problem when an object-based value is not a valid member of the
           # +type_klass+ of this field
           def raise_invalid_member!
-            raise(FieldError, <<~MSG.squish)
+            raise FieldError, (+<<~MSG).squish
               The #{gql_name} field result is not a member of #{type_klass.gql_name}.
             MSG
           end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Request
+      # = GraphQL Request Bypass Data
+      #
+      # This class works in collaboration with the prepare stage of a request
+      # execution. In that stage, the strategy must check if the request already
+      # have a prepared data for the field. The field can result in a instance
+      # of this class, which than bypasses the prepare stage by grabbing the
+      # next value from here
+      class PreparedData
+        SCHEMA_BASED = Helpers::WithSchemaFields::TYPE_FIELD_CLASS.keys.freeze
+        NULL = Object.new.freeze
+
+        REPEAT_OPTIONS = {
+          true => true,
+          false => 1,
+          once: 1,
+          cycle: true,
+          always: true,
+        }.freeze
+
+        # Look up the given +field+ using the request as a reference. It accepts
+        # any +Rails::GraphQL::Field+ or a string where +"query.create_user"+
+        # means a query field on the request schema with +create_user+ as name,
+        # or +create_user+ as gql_name, and "User.devices" will use the schema
+        # of the request to lookup the type +"User"+ and then pick the field
+        # +devices+
+        def self.lookup(request, field)
+          return field if field.is_a?(GraphQL::Field)
+
+          source, name = field.to_s.split('.')
+          return if source.nil? || name.nil?
+
+          if SCHEMA_BASED.any? { |item| item.to_s == source }
+            request.schema.find_field!(source.to_sym, name)
+          elsif (type = request.schema.find_type!(source)).is_a?(Helpers::WithFields)
+            type.find_field!(name)
+          else
+            field
+          end
+        rescue NotFoundError
+          # Return the original value, maybe it will be resolved somewhere else
+          field
+        end
+
+        def initialize(field, value, repeat: 1)
+          # Check if it has a valid field
+          raise ::ArgumentError, (+<<~MSG).squish unless field.is_a?(GraphQL::Field)
+            Unable to setup a prepared data for "#{field.inspect}".
+            You must provide a valid field.
+          MSG
+
+          @field = field
+          @value = value
+          @array = value.is_a?(Array) && !field.array?
+          @repeat = true if !@array && !value.is_a?(Array)
+          @repeat ||=
+            case repeat
+            when Numeric then repeat
+            when Enumerator then repeat.size
+            else REPEAT_OPTIONS[repeat]
+            end
+        end
+
+        # Add one more item to the list of data
+        def push(*values)
+          return @value += values if @array
+          @value = [@value, *values]
+        end
+
+        # The the whole value, because the prepare stage always deal with all
+        # the information available
+        def all
+          @field.array? ? Array.wrap(@value) : @value
+        end
+
+        # Get the enumerable of the whole value
+        def enum
+          @enum ||= (@array ? @value.to_enum : @value.then)
+        end
+
+        # Get the next value, take into consideration the value on repeat
+        def next
+          value = enum.next
+          @field.array? ? Array.wrap(value) : value
+        rescue StopIteration
+          if @repeat == true || (@repeat != false && (@repeat -= 1) > 0)
+            enum.rewind
+            self.next
+          else
+            NULL
+          end
+        end
+      end
+    end
+  end
+end