rails-graphql 0.1.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Errors
+      #
+      # This class is inspired by +ActiveModel::Erros+. 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
+        include Enumerable
+
+        delegate :empty?, :size, :each, :to_json, :last, :first, to: :@items
+
+        def initialize(request)
+          @request = request
+          @items   = []
+        end
+
+        def reset!
+          @items = []
+        end
+
+        # Return a deep duplicated version of the items
+        def to_a
+          @items.deep_dup
+        end
+
+        # Add +message+ to the list of errors. Any other keywork argument will
+        # be used on set on the +:extensions+ part.
+        #
+        # ==== Options
+        #
+        # * <tt>:line</tt> - The line associated with the error.
+        # * <tt>:col</tt> - The column associated with the error.
+        # * <tt>:path</tt> - The path of the field that generated the error.
+        def add(message, line: nil, col: nil, path: nil, **extra)
+          item = { 'message' => message }
+
+          item['locations'] = extra.delete(:locations)
+          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['extensions'] = extra.deep_stringify_keys if extra.present?
+          item['locations'].map!(&:stringify_keys)
+
+          @items << item
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = 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
+
+        delegate :schema, :errors, :context, to: :request
+        delegate :instance_for, to: :strategy
+        delegate :memo, to: :source
+
+        attr_reader :strategy, :request, :index
+
+        # Enhance the trigger settings based on the default for a request event
+        def self.trigger(event_name, object, *args, **xargs, &block)
+          xargs[:phase] ||= :execution
+          xargs[:fallback_trigger!] ||= :trigger_all unless block.present?
+          super(event_name, object, *args, **xargs, &block)
+        end
+
+        def initialize(name, strategy, source = nil, **data)
+          @request = strategy.request
+          @strategy = strategy
+
+          source ||= request.stack.first
+          @index, source = source, request.stack[1] if source.is_a?(Numeric)
+
+          super(name, source, **data)
+        end
+
+        # Provide a way to access the current field value
+        def current_value
+          resolver&.current_value
+        end
+
+        alias current current_value
+
+        # Provide a way to set the current value
+        def current_value=(value)
+          resolver&.override_value(value)
+        end
+
+        # Return the strategy context as the resolver
+        def resolver
+          strategy.context
+        end
+
+        # Return the actual field when the source is a request field
+        def field
+          source.field if source.try(:kind) === :field
+        end
+
+        # Check if the event source is of the given +type+
+        def for?(type)
+          source.of_type?(type)
+        end
+
+        # Check if the current +object+ is of the given +item+
+        def on?(item)
+          object.of_type?(item)
+        end
+
+        # Provide access to field arguments
+        def argument(name)
+          args_source.try(:[], name.to_sym)
+        end
+
+        # A combined helper for +instance_for+ and +set_on+
+        def on_instance(klass, &block)
+          set_on(klass.is_a?(Class) ? instance_for(klass) : klass, &block)
+        end
+
+        alias arg argument
+
+        protected
+
+          # When performing an event under a field object, the keyed-based
+          # parameters of a proc callback will be associated with actual field
+          # arguments
+          def args_source
+            source.arguments if source.try(:kind) === :field
+          end
+
+        private
+
+          # Check for object based readers
+          def respond_to_missing?(method_name, include_private = false)
+            OBJECT_BASED_READERS.include?(method_name) ||
+              current_value&.respond_to?(method_name, include_private) ||
+              super
+          end
+
+          # If the +method_name+ matches the kind of the current +object+, then
+          # 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
+            elsif current_value&.respond_to?(method_name)
+              current_value&.public_send(method_name, *args, **xargs, &block)
+            else
+              super
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # Helper module to collect the directives from fragments, operations, and
+      # fields.
+      module Directives
+        # Get the list of listeners from all directives
+        def all_listeners
+          directives.map(&:all_listeners).reduce(:+) || Set.new
+        end
+
+        # Get the list of events from all directives and caches it by request
+        def all_events
+          @all_events ||= directives.map(&:all_events).inject({}) do |lhash, rhash|
+            Helpers.merge_hash_array(lhash, rhash)
+          end
+        end
+
+        protected
+
+          # Make sure to always return a set
+          def directives
+            @directives || Set.new
+          end
+
+          alias all_directives directives
+
+          # 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])
+
+              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}."
+              end
+
+              list << instance.new(request.build(Request::Arguments, args))
+            end unless data[:directives].blank?
+
+            if list.present?
+              event = Event.new(:attach, strategy, self, phase: :execution)
+              list = GraphQL.directives_to_set(list, [], event, location: location || kind)
+            end
+
+            @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
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # Helper module to collect the fields from fragments, operations, and also
+      # other fields.
+      module SelectionSet
+        attr_reader :selection
+
+        protected
+
+          # Helper parser for selection fields that also asssign the actual
+          # field defined under the schema structure
+          def parse_selection
+            @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?
+
+            assing_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)
+            pending = assigners.map(&:size).reduce(:+) || 0
+            return if pending.zero?
+
+            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)
+              break if (pending -= items.size) === 0
+            end
+          end
+
+          # Recursive operation that perform the organization step for the
+          # selection
+          def organize_fields
+            selection.each_value(&:organize!) if selection.any?
+          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!)
+          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?
+
+            items = selection.each_value
+            items = items.each_with_object(object) unless object.nil?
+            iterator = object.nil? ? :resolve! : :resolve_with!
+
+            return items.each(&iterator) unless stacked_selection?
+            response.with_stack(gql_name) { items.each(&iterator) }
+          end
+
+        private
+
+          def add_component(kind, node, data)
+            item_name = data.try(:alias).presence || data[:name]
+
+            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)
+            else
+              selection[item_name] ||= request.build(Component::Field, self, node, data)
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # 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',
+        }.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)
+        end
+
+        # Resolve a given value when it is an array
+        def write_array(value, idx = -1, &block)
+          write_array!(value) do |item|
+            stacked(idx += 1) do
+              block.call(item, idx)
+              response.next
+            rescue StandardError => error
+              raise if item.nil?
+
+              block.call(nil, idx)
+              response.next
+
+              format_array_execption(error, idx)
+              request.exception_to_error(error, @node)
+            end
+          rescue StandardError => error
+            format_array_execption(error, idx)
+            raise
+          end
+        end
+
+        # Helper to start writing as array
+        def write_array!(value, &block)
+          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
+            value.each(&block)
+          end
+        ensure
+          @writing_array = nil
+        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"
+
+          message = error.message.gsub(source_error, real_error)
+          error.define_singleton_method(:message) { message }
+        end
+
+        protected
+
+          # 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.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.nil? ? raise_invalid_member! : resolve_fields(object)
+          end
+
+          # Write a value based on a Object type
+          def write_object(value)
+            type_klass.valid_member?(value) ? resolve_fields : raise_invalid_member!
+          end
+
+          # Write a value with the correct serialize mode. Validate the output
+          # but do not use array mode because this method will be called
+          # multiple times inside of an array.
+          def write_leaf(value)
+            validate_output!(value)
+            return response.safe_add(gql_name, nil) if value.nil?
+
+            # Necessary call #itself to loose the dynamic reference
+            response.serialize(type_klass, gql_name, value.itself)
+          end
+
+          # Trigger the plain field output validation
+          def validate_output!(value)
+            checker = defined?(@writing_array) && @writing_array ? :nullable? : :null?
+            field&.validate_output!(value, checker: checker, array: false)
+          end
+
+        private
+
+          # 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)
+              The #{gql_name} field result is not a member of #{type_klass.gql_name}.
+            MSG
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/steps/organizable.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # Helper methods for the organize step of a request
+      module Organizable
+        # Check if it is already organized
+        def organized?
+          data.nil?
+        end
+
+        # Organize the object if it is not already organized
+        def organize!
+          capture_exception(:organize, true) { organize unless organized? }
+        end
+
+        protected
+
+          # Normally, fields come from the +type_klass+
+          def fields_source
+            type_klass.fields
+          end
+
+          # Normal mode of the organize step
+          def organize
+            organize_then { organize_fields }
+          end
+
+          # The actual process that organizes the object
+          def organize_then(after_block, &block)
+            stacked do
+              block.call
+              strategy.add_listener(self)
+              trigger_event(:organized)
+              after_block.call if after_block.present?
+            end
+          ensure
+            @data = nil
+          end
+
+          # Helper parser for request arguments (operation variables) that
+          # collect necessary arguments from the request
+          def parse_variables
+            @arguments = {}
+
+            visitor.collect_variables(*data[:variables]) do |data, node|
+              arg_name = data[:name]
+              raise ExecutionError, <<~MSG.squish if arguments.key?(arg_name)
+                The "#{arg_name}" argument is already defined for this #{kind}.
+              MSG
+
+              extra = data.to_h.except(:name, :type).merge(owner: schema)
+              item = arguments[arg_name] = Argument.new(arg_name, data[:type], **extra)
+              item.node = node
+              item.validate!
+            end unless data[:variables].blank?
+
+            args = request.sanitized_arguments
+            args = collect_arguments(self, args, var_access: false) do |errors|
+              "Invalid arguments for #{log_source}: #{errors}."
+            end
+
+            @variables = args.freeze
+            @arguments.freeze
+          end
+
+          # Helper parser for arguments that also collect necessary variables
+          def parse_arguments
+            args = {}
+            visitor.collect_arguments(*data[:arguments]) do |data|
+              args[data[:name]] = variable = data[:variable]
+              args[data[:name]] = data[:value] if variable.nil? || variable.null?
+            end unless data[:arguments].blank?
+
+            args = collect_arguments(self, args) do |errors|
+              "Invalid arguments for #{gql_name} #{kind}: #{errors}."
+            end
+
+            @arguments = request.build(Request::Arguments, args).freeze
+          end
+
+          # Build a hash that collect validated values for a set of arguments.
+          # The +source+ can either be the list of arguments or an object that
+          # responds to +all_arguments+. The +block+ is called when something
+          # goes wrong to collect a formatted message.
+          def collect_arguments(source, values, var_access: true, &block)
+            op_vars = nil
+
+            errors = []
+            source = source.all_arguments if source.respond_to?(:all_arguments)
+            result = source.each_pair.each_with_object({}) do |(key, argument), hash|
+              next unless values.key?(key)
+              value = values[key]
+
+              # Pointer means operation variable
+              if value.is_a?(::FFI::Pointer)
+                var_name = visitor.node_name(value)
+                raise ArgumentError, <<~MSG.squish unless var_access
+                  Unable to use variable "$#{var_name}" in the current scope
+                MSG
+
+                op_vars ||= operation.all_arguments
+                raise ArgumentError, <<~MSG.squish unless (op_var = op_vars[var_name]).present?
+                  The #{operation.log_source} does not define the $#{var_name} variable
+                MSG
+
+                # When arguments are not equivalent, they can ended up with
+                # invalid values, so this already ensures that whatever the
+                # variable value ended up being, it will be valid due to this
+                raise ArgumentError, <<~MSG.squish unless op_var =~ argument
+                  The $#{var_name} variable on #{operation.log_source} is not compatible
+                  with "#{key}" argument
+                MSG
+
+                operation.used_variables << var_name
+                next unless variables.key?(op_var.name)
+                value = variables[op_var.name]
+              else
+                # Only when the given value is an actual value that we check if
+                # it is valid
+                raise ArgumentError, <<~MSG.squish unless argument.valid?(value)
+                  Invalid value provided to "#{key}" argument
+                MSG
+
+                value = argument.deserialize(value)
+              end
+
+              hash[argument.name] = value
+            rescue ArgumentError => error
+              errors << error.message
+            end
+
+            # Checks for any required arugment that was not provided
+            source.each_value do |argument|
+              next if result.key?(argument.name) || argument.null?
+              errors << "The \"#{argument.gql_name}\" argument can not be null"
+            end
+
+            return result if errors.blank?
+            raise ArgumentError, block.call(errors.to_sentence)
+          end
+      end
+    end
+  end
+end