rails-graphql 0.2.1 → 1.0.0.rc1

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)
-              trigger_event(:organized)
+              strategy.add_listeners_from(self)
               after_block.call if after_block.present?
+              trigger_event(:organized)
             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,30 +1,43 @@
 # 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)
               after_block.call if after_block.present?
+              trigger_event(:prepared)
             end
           end
       end

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

@@ -1,29 +1,38 @@
 # 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)
               after_block.call if after_block.present?
+              trigger_event(:finalize)
             end
           end
       end

data/lib/rails/graphql/request/strategy/cached_strategy.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Request
+      # = GraphQl Cached Strategy
+      #
+      # This strategy will process hard cached operations. Soft cached
+      # operations are those that only the document is cached in the server and
+      # processed via its unique identifier (UUID). Whereas, hard cached
+      # operations pretty muchy skips the organize step since that is what is
+      # cached.
+      #
+      # Beware, if the version in the cache is different from the version in the
+      # type map, it won't be able to process it.
+      class Strategy::CachedStrategy < Strategy
+        self.priority = 100
+
+        class << self
+
+          # Resolve whenever it has a cache directive on any of the operations
+          def can_resolve?(request)
+            false
+            # request.operations.each_value.any? do |op|
+            #   op.data&.directives&.any? { |dir| directive_name(dir) == 'cached' }
+            # end
+          end
+
+          private
+
+            def directive_name(obj)
+              Native.node_name(Native.directive_name(obj))
+            end
+        end
+
+        # Executes the strategy in the normal mode
+        def resolve!
+          response.with_stack('data') do
+            for_each_operation { |op| collect_listeners { op.organize! } }
+            for_each_operation { |op| collect_data      { op.prepare!  } }
+            for_each_operation { |op| collect_response  { op.resolve!  } }
+
+            # collect_data(true) { op.prepare! }
+            # collect_response   { op.resolve! }
+
+            # operations.each_value do |op|
+            #   collect_listeners  { op.organize! }
+            #   collect_data(true) { op.prepare! }
+            #   collect_response   { op.resolve! }
+            # end
+          end
+        end
+
+        private
+
+          # Execute a given block for each defined operation
+          def for_each_operation(&block)
+            operations.each_value(&block)
+          end
+
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/strategy/dynamic_instance.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 Strategy Dynamic Instance
       #
       # When an event is call on non-object types, this class allows both
@@ -16,18 +16,18 @@ module Rails # :nodoc:
 
         private
 
-          def respond_to_missing?(method_name, include_private = false) # :nodoc:
+          def respond_to_missing?(method_name, include_private = false)
             __current_object__&.respond_to?(method_name, include_private) || super
           end
 
-          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+          def method_missing(method_name, *args, **xargs, &block)
             object = __current_object__
 
             return super unless object&.respond_to?(method_name)
             object.public_send(method_name, *args, **xargs, &block)
           end
 
-          def __current_object__ # :nodoc:
+          def __current_object__
             return unless __getobj__.instance_variable_defined?(:@event)
 
             event = __getobj__.instance_variable_get(:@event)

data/lib/rails/graphql/request/strategy/multi_query_strategy.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 Multi Query Strategy
       #
       # This is a resolution strategy to solve requests that only contain
@@ -11,25 +11,18 @@ module Rails # :nodoc:
       class Strategy::MultiQueryStrategy < Strategy
         self.priority = 10
 
-        def self.can_resolve?(request) # :nodoc:
-          request.operations.values.all?(&:query?)
+        def self.can_resolve?(request)
+          request.operations.each_value.all? { |op| op.of_type?(:query) }
         end
 
         # Executes the strategy in the normal mode
         def resolve!
-          response.with_stack(:data) do
+          response.with_stack('data') do
             for_each_operation { |op| collect_listeners { op.organize! } }
             for_each_operation { |op| collect_data      { op.prepare!  } }
             for_each_operation { |op| collect_response  { op.resolve!  } }
           end
         end
-
-        private
-
-          # Execute a given block for each defined operation
-          def for_each_operation
-            operations.each_value { |op| yield op }
-          end
       end
     end
   end

data/lib/rails/graphql/request/strategy/sequenced_strategy.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Request # :nodoc:
+module Rails
+  module GraphQL
+    class Request
       # = GraphQl Sequenced Strategy
       #
       # This is the default resolution strategy, where each operation is
       # performed in sequece, and they don't relate to each other in any way.
       class Strategy::SequencedStrategy < Strategy
-        def self.can_resolve?(_) # :nodoc:
+        def self.can_resolve?(_)
           true
         end
 
         # Executes the strategy in the normal mode
         def resolve!
-          response.with_stack(:data) do
-            operations.each_value do |op|
-              collect_listeners { op.organize! }
-              collect_data      { op.prepare! }
-              collect_response  { op.resolve! }
+          response.with_stack('data') do
+            for_each_operation do |op|
+              collect_listeners          { op.organize! }
+              collect_data(op.mutation?) { op.prepare! }
+              collect_response           { op.resolve! }
             end
           end
         end