rails-graphql 0.2.0 → 1.0.0.beta

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

@@ -1,21 +1,21 @@
 # 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
@@ -31,7 +31,7 @@ module Rails # :nodoc:
               response.next
 
               format_array_execption(error, idx)
-              request.exception_to_error(error, @node)
+              request.exception_to_error(error, self)
             end
           rescue StandardError => error
             format_array_execption(error, idx)
@@ -41,13 +41,13 @@ module Rails # :nodoc:
 
         # Helper to start writing as array
         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
@@ -56,9 +56,11 @@ module Rails # :nodoc:
 
         # 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"
+          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 +70,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.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 = type_klass.all_types&.reverse_each&.find { |t| t.valid_member?(value) }
             object.nil? ? raise_invalid_member! : resolve_fields(object)
           end
 
@@ -105,7 +107,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,98 @@
+# 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,
+          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 =
+            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

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

@@ -1,27 +1,34 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # Helper methods for the authorize step of a request
       module Authorizable
         # Event used to perform an authorization step
         class Event < GraphQL::Event
+          # Same behavior as the request event
+          def same_source?(other)
+            super || (source.try(:kind) == :field && source.field == other)
+          end
+
           # Similar to trigger for object, but with an extra extension for
           # instance methods defined on the given object
           def authorize_using(object, send_args, events = nil)
-            cache = data[:request].cache(name)[object] ||= []
+            @object = object
+
+            cache = data[:request].nested_cache(:authorize, object) { [] }
             return false if cache.present? && cache.none?
             args, xargs = send_args
 
             # Authorize through instance method
             using_object = cache[0] ||= authorize_on_object(object)
             set_on(using_object) do |instance|
-              instance.public_send("#{name}!", self, *args, **xargs)
+              instance.public_send(:authorize!, *args, **xargs)
             end if using_object
 
             # Authorize through events
-            using_events = cache[1] ||= (events || object.all_events[name]).presence
+            using_events = cache[1] ||= (events || object.all_events.try(:[], :authorize))
             using_events&.each { |block| block.call(self, *args, **xargs) }
 
             # Does any authorize process ran
@@ -29,14 +36,14 @@ module Rails # :nodoc:
           end
 
           # Simply unauthorize the operation
-          def unauthorize!(*, message: nil, **)
-            raise UnauthorizedFieldError, message || <<~MSG.squish
+          def unauthorized!(*, message: nil, **)
+            raise UnauthorizedFieldError, message || (+<<~MSG).squish
               Unauthorized access to "#{field.gql_name}" field.
             MSG
           end
 
           # Simply authorize the operation
-          def authorize!(*)
+          def authorized!(*)
             throw :authorized
           end
 
@@ -54,16 +61,18 @@ module Rails # :nodoc:
         end
 
         # Check if the field is correctly authorized to be executed
+        # TODO: Implement reverse order of authorization
         def check_authorization!
           return unless field.authorizable?
           *args, block = field.authorizer
 
           catch(:authorized) do
             event = authorization_event
-            schema_events = request.all_events[:authorize]
+            schema_events = request.all_events.try(:[], :authorize)
             executed = event.authorize_using(schema, args, schema_events)
+            executed = event.authorize_using(self, args) || executed
 
-            element = field
+            element = field&.owner
             while element && element != schema
               executed = event.authorize_using(element, args) || executed
               element = element.try(:owner)
@@ -74,14 +83,14 @@ module Rails # :nodoc:
               executed = true
             end
 
-            event.unauthorize!(message: <<~MSG.squish) unless executed
+            event.unauthorized!(message: (+<<~MSG).squish) unless executed
               Authorization required but unable to be executed
             MSG
           end
         rescue UnauthorizedFieldError => error
           request.rescue_with_handler(error)
-          request.exception_to_error(error, @node)
-          invalidate!
+          request.exception_to_error(error, self, stage: :authorization)
+          invalidate!(:authorization)
         end
 
         private
@@ -89,6 +98,7 @@ module Rails # :nodoc:
           # Build and store the authorization event
           def authorization_event
             Event.new(:authorize, self,
+              context: request.context,
               request: request,
               schema: schema,
               field: field,

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

@@ -1,18 +1,56 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # 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? }
+          organize unless defined?(@organized)
+        rescue => error
+          invalidate!
+          report_exception(error)
+        ensure
+          @organized = true
+        end
+
+        # Build the cache object
+        def cache_dump
+          arguments =
+            if @arguments === EMPTY_HASH
+              nil
+            elsif is_a?(Component::Operation)
+              all_to_gid(@arguments.transform_values)
+            else
+              @arguments.to_h
+            end
+
+          { arguments: arguments }
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          if (args = data[:arguments]).blank?
+              @arguments = EMPTY_HASH
+          elsif is_a?(Component::Operation)
+            @arguments = all_from_gid(args.transform_values)
+
+            unless defined?(@variables)
+              @variables = collect_arguments(self, request.args, var_access: false).freeze
+            end
+          else
+            @arguments = request.build(Request::Arguments, args).freeze
+          end
+
+          # Always trigger the organized event
+          unless unresolvable?
+            strategy.add_listeners_from(self)
+            trigger_event(:organized)
+          end
+
+          # Mark component as organized
+          @organized = true
         end
 
         protected
@@ -31,53 +69,67 @@ module Rails # :nodoc:
           def organize_then(after_block, &block)
             stacked do
               block.call
-              strategy.add_listener(self)
+              strategy.add_listeners_from(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
+          # Default values forces this method to run even without nodes
+          def parse_variables(nodes)
+            if nodes.blank?
+              @variables = EMPTY_HASH
+              @arguments = EMPTY_HASH
+              return
+            end
+
             @arguments = {}
 
-            visitor.collect_variables(*data[:variables]) do |data, node|
-              arg_name = data[:name]
-              raise ExecutionError, <<~MSG.squish if arguments.key?(arg_name)
+            nodes&.each do |node|
+              arg_name, type, value, _directives = node
+              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)
+              # TODO: Move this to a better builder of the type
+              type_name, dimensions, nullability = type
+              xargs = { owner: schema, default: value, array: dimensions > 0 }
+              xargs[:nullable] = (nullability & 0b10) == 0
+              xargs[:null] = (nullability & 0b01) == 0
+
+              # TODO: Follow up with the support for directives
+              item = arguments[arg_name.to_s] = Argument.new(arg_name, type_name, **xargs)
               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
 
+            args = collect_arguments(self, request.args, var_access: false)
+
             @variables = args.freeze
             @arguments.freeze
+          rescue ArgumentsError => error
+            raise ArgumentsError, (+<<~MSG).squish
+              Invalid arguments for #{log_source}: #{error.message}.
+            MSG
           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}."
+          # Default values forces this method to run even without nodes
+          def parse_arguments(nodes)
+            return @arguments = EMPTY_HASH if nodes.blank?
+
+            args = nodes.each.with_object({}) do |(name, value, var_name), hash|
+              hash[name.to_s] = var_name.nil? ? value : var_name
             end
 
+            args = collect_arguments(self, args)
             @arguments = request.build(Request::Arguments, args).freeze
+          rescue ArgumentsError => error
+            raise ArgumentsError, (+<<~MSG).squish
+              Invalid arguments for #{gql_name} #{kind}: #{error.message}.
+            MSG
           end
 
           # Build a hash that collect validated values for a set of arguments.
@@ -89,41 +141,51 @@ module Rails # :nodoc:
 
             errors = []
             source = source.all_arguments if source.respond_to?(:all_arguments)
+            return unless source.present?
+
             result = source.each_pair.each_with_object({}) do |(key, argument), hash|
-              next unless values.key?(key)
-              value = values[key]
+              value = values && 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
+              # A token means the name of a variable
+              if value.is_a?(::GQLParser::Token) && value.of_type?(:variable)
+                var_name = value.to_s
+                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?
+                op_var = (op_vars ||= operation.all_arguments).try(:[], var_name)
+                raise ArgumentError, (+<<~MSG).squish unless op_var.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
+                raise ArgumentError, (+<<~MSG).squish unless op_var =~ argument
                   The $#{var_name} variable on #{operation.log_source} is not compatible
                   with "#{key}" argument
                 MSG
 
+                # Mark the variable as used and grab the value
                 operation.used_variables << var_name
-                next unless variables.key?(op_var.name)
                 value = variables[op_var.name]
-              else
+              elsif !value.nil?
                 # 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
+                raise ArgumentError, (+<<~MSG).squish unless argument.valid?(value)
+                  Invalid value "#{value.to_s}" provided to
+                  #{argument.node ? "$#{argument.name} variable" : "#{key} argument"}
+                  on #{argument.node ? operation.log_source : gql_name}
                 MSG
 
                 value = argument.deserialize(value)
+              elsif argument.default_value?
+                # Ensure to always import arguments that have default values but
+                # were not included in the field
+                value = argument.deserialize
+              else
+                # Otherwise, simply just skip the argument
+                next
               end
 
               hash[argument.name] = value
@@ -131,14 +193,14 @@ module Rails # :nodoc:
               errors << error.message
             end
 
-            # Checks for any required arugment that was not provided
+            # Checks for any required argument 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"
+              errors << +"the \"#{argument.gql_name}\" argument can not be null"
             end
 
             return result if errors.blank?
-            raise ArgumentError, block.call(errors.to_sentence)
+            raise ArgumentsError, errors.to_sentence
           end
       end
     end

data/lib/rails/graphql/request/steps/{prepareable.rb → preparable.rb}

@@ -1,26 +1,39 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # Helper methods for the prepare step of a request
-      module Prepareable
+      module Preparable
         # Prepare the object
         def prepare!
-          capture_exception(:prepare) { prepare }
+          prepare
+        rescue => error
+          report_exception(error)
+        end
+
+        # Marks that the field has prepared data that came outside from the
+        # request
+        def prepared_data!
+          @prepared_data = true
+        end
+
+        # Checks if the field has prepared data
+        def prepared_data?
+          defined?(@prepared_data) && @prepared_data
         end
 
         protected
 
           # Normal mode of the prepare step
           def prepare
-            return if invalid?
             prepare_then { prepare_fields }
           end
 
           # The actual process that prepare the object
           def prepare_then(after_block = nil, &block)
-            return if invalid?
+            return if unresolvable?
+
             stacked do
               block.call if block.present?
               trigger_event(:prepared)

data/lib/rails/graphql/request/steps/{resolveable.rb → resolvable.rb}

@@ -1,25 +1,34 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # Helper methods for the resolve step of a request
-      module Resolveable
+      module Resolvable
         # Resolve the object
         def resolve!
-          capture_exception(:resolve) { resolve }
+          resolve
+        rescue => error
+          report_exception(error)
         end
 
         protected
 
           # Normal mode of the resolve step
+          # TODO: Field a way to cache the resolved result, mostly for
+          # performance improvement in recursion
           def resolve
+            return if skipped?
             invalid? ? try(:resolve_invalid) : resolve_then
+          rescue
+            try(:resolve_invalid)
+            raise
           end
 
           # The actual process that resolve the object
           def resolve_then(after_block = nil, &block)
-            return if invalid?
+            return if unresolvable?
+
             stacked do
               block.call if block.present?
               trigger_event(:finalize)