rails-graphql 1.0.0.beta → 1.0.0.rc1

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

@@ -39,7 +39,7 @@ module Rails
             stack = [component] + request.stack
             counter = stack.count { |item| !item.is_a?(Numeric) }
             objects = request.strategy.context
-            oidx = -1
+            oid = -1
 
             last_object = suffix = nil
             while (item = stack.shift)
@@ -51,11 +51,13 @@ module Rails
               add = send("row_for_#{item.kind}", data, item, suffix)
 
               if item.kind == :field
-                oidx += 1
-                data[5] ||= oidx == 0 ? '↓' : print_object(objects&.at(oidx - 1))
-                data[3] ||= print_object(objects&.at(oidx))
+                oid += 1
+                data[5] ||= oid == 0 ? '↓' : print_object(objects&.at(oid - 1))
+                data[3] ||= print_object(objects&.at(oid))
               end
 
+              data[4] = clean_arguments(data[4], request) if data[4]
+
               suffix = nil
               counter -= 1
               add_to_table(table, data) if add != false
@@ -67,7 +69,7 @@ module Rails
           # Print the backtrace steps of the error
           def print_backtrace(error, request)
             steps = error.backtrace
-            steps = cleaner.clean(steps) unless cleaner.nil?
+            # steps = cleaner.clean(steps) unless cleaner.nil?
 
             klass = +"(\e[4m#{error.class}\e[24m)"
             stage = +" [#{request.strategy.stage}]" if skip_base_class != StandardError
@@ -122,26 +124,45 @@ module Rails
             object.respond_to?(:to_gql_backtrace) ? object.to_gql_backtrace : object.inspect
           end
 
+          # Make sure to properly parse arguments and filter them
+          def clean_arguments(arguments, request)
+            value = arguments.as_json
+            return '{}' if value.blank?
+
+            request.cache(:backtrace_arguments_filter) do
+              ActiveSupport::ParameterFilter.new(GraphQL.config.filter_parameters)
+            end.filter(value)
+          end
+
           # Visitors
           def row_for_field(data, item, suffix)
             field = item.field
-            name = +"#{field.owner.gql_name}.#{field.gql_name}#{suffix}" unless field.nil?
+            parent =
+              if !field
+                '*'
+              elsif field.owner.is_a?(Helpers::WithSchemaFields)
+                item.request.schema.type_name_for(field.schema_type)
+              else
+                field.owner.gql_name
+              end
+
+            name = +"#{parent}.#{field.gql_name}#{suffix}" unless field.nil?
 
             data.push(name || +"*.#{item.name}")
-            data.push(nil, (item.arguments ? item.arguments.to_json : 'nil'), nil)
+            data.push(nil, item.arguments, nil)
           end
 
           def row_for_fragment(data, item, *)
             type = item.instance_variable_get(:@node)[1]
             object = item.current_object || item.type_klass
-            data.push(+"fragment #{item.name}", type, '')
+            data.push(+"fragment #{item.name}", type, nil)
             data.push(print_object(object))
           end
 
           def row_for_operation(data, item, *)
             data.push(+"#{item.type} #{item.name}".squish)
             data.push('nil')
-            data.push(item.arguments.to_json)
+            data.push(item.variables)
             data.push(item.typename)
           end
 
@@ -150,7 +171,7 @@ module Rails
 
             type = item.instance_variable_get(:@node)[1]
             object = item.current_object || item.type_klass
-            data.push('...', type, '')
+            data.push('...', type, nil)
             data.push(print_object(object))
           end
 

data/lib/rails/graphql/request/component/field.rb

@@ -15,7 +15,7 @@ module Rails
 
         delegate :decorate, to: :type_klass
         delegate :operation, :variables, :request, to: :parent
-        delegate :method_name, :resolver, :performer, :type_klass,:leaf_type?,
+        delegate :method_name, :resolver, :performer, :type_klass, :leaf_type?,
           :dynamic_resolver?, :mutation?, to: :field
 
         attr_reader :name, :alias_name, :parent, :field, :arguments, :current_object
@@ -97,10 +97,11 @@ module Rails
           (try(:current_object) || try(:type_klass))&.gql_name
         end
 
-        # Check if the field is an entry point, meaning that its parent is the
-        # operation and it is associated to a schema field
+        # Check if the field is an entry point, meaning that it is attached to
+        # an owner that has Schema Fields
         def entry_point?
-          parent.kind === :operation
+          return @entry_point if defined?(@entry_point)
+          @entry_point = field.entry_point?
         end
 
         # Fields are assignable because they are actually the selection, so they
@@ -117,6 +118,12 @@ module Rails
           value != false
         end
 
+        # Override this to also check if the key would be added to the response
+        # again
+        def skipped?
+          super || response.key?(gql_name)
+        end
+
         # A little extension of the +is_a?+ method that allows checking it using
         # the underlying +field+
         def of_type?(klass)
@@ -150,6 +157,7 @@ module Rails
         end
 
         # Build the cache object
+        # TODO: Add the arguments into the GID, but the problem is variables
         def cache_dump
           super.merge(field: (field && all_to_gid(field)))
         end
@@ -172,10 +180,10 @@ module Rails
               check_assignment!
 
               parse_directives(@node[3])
-              check_authorization!
-
               parse_arguments(@node[2])
               parse_selection(@node[4])
+
+              check_authorization!
             end
           end
 
@@ -221,8 +229,7 @@ module Rails
           # Check if the field was assigned correctly to an output field
           def check_assignment!
             raise MissingFieldError, (+<<~MSG).squish if field.nil?
-              Unable to find a field named "#{gql_name}" on
-              #{entry_point? ? operation.kind : parent.type_klass.name}.
+              Unable to find a field named "#{gql_name}" on #{parent.typename}.
             MSG
 
             raise FieldError, (+<<~MSG).squish unless field.output_type?

data/lib/rails/graphql/request/component/fragment.rb

@@ -23,6 +23,16 @@ module Rails
           check_duplicated_fragment!
         end
 
+        # Check if all the sub fields are broadcastable
+        def broadcastable?
+          selection.each_value.all?(&:broadcastable?)
+        end
+
+        # Check if the fragment has been prepared already
+        def prepared?
+          defined?(@prepared) && @prepared
+        end
+
         # Return a lazy loaded variable proc
         def variables
           Request::Arguments.lazy
@@ -59,11 +69,6 @@ module Rails
           @current_object = nil
         end
 
-        # Check if all the sub fields are broadcastable
-        def broadcastable?
-          selection.each_value.all?(&:broadcastable?)
-        end
-
         # Build the cache object
         def cache_dump
           super.merge(type_klass: all_to_gid(type_klass))
@@ -105,8 +110,9 @@ module Rails
           def resolve
             return if unresolvable?
 
-            object = @current_object || type_klass
-            resolve_then if type_klass =~ object
+            type = type_klass
+            object = @current_object
+            resolve_then if (object.nil? && type&.operational?) || type =~ object
           end
 
           # This will just trigger the selection resolver

data/lib/rails/graphql/request/component/operation/subscription.rb

@@ -89,14 +89,12 @@ module Rails
 
             # Rewrite this method so that the subscription can be generated in
             # the right place
-            def resolve_then(after_block = nil, &block)
-              subscribe_block = -> do
+            def resolve_then(&block)
+              super do
                 save_subscription
-                trigger_event(:subscribed)
-                after_block.call if after_block.present?
+                trigger_event(:subscribed, subscription: subscription)
+                block.call if block.present?
               end
-
-              super(subscribe_block, &block)
             end
 
             # Save the subscription using the schema subscription provider

data/lib/rails/graphql/request/component/operation.rb

@@ -73,6 +73,13 @@ module Rails
           schema.fields_for(type)
         end
 
+        # Allow accessing the fake type form the schema. It's used for
+        # inline spreads without a specified type
+        def type_klass
+          return @type_klass if defined?(@type_klass)
+          @type_klass = schema.public_send("#{type}_type")
+        end
+
         # The typename is always based on the fake name used for the set of
         # schema fields
         def typename
@@ -109,7 +116,7 @@ module Rails
           return super unless defined?(@used_fragments)
 
           super ^ used_fragments.reduce(0) do |value, fragment|
-            request.fragments[fragment].hash
+            value ^ request.fragments[fragment].hash
           end
         end
 
@@ -129,8 +136,8 @@ module Rails
 
           # Trigger an specific event with the +type+ of the operation
           def organize
+            trigger_event(type)
             organize_then do
-              trigger_event(type)
               yield if block_given?
               organize_fields
               report_unused_variables
@@ -147,8 +154,8 @@ module Rails
           end
 
           # Resolve all the fields
-          def resolve
-            resolve_then { resolve_fields }
+          def resolve_then(&block)
+            super(block) { resolve_fields }
           end
 
           # Don't stack over response when the operation doesn't have a name

data/lib/rails/graphql/request/component/spread.rb

@@ -95,7 +95,7 @@ module Rails
           def organize_then(&block)
             super(block) do
               if inline?
-                @type_klass = find_type!(@node[1])
+                @type_klass = @node[1].nil? ? parent.type_klass : find_type!(@node[1])
                 parse_directives(@node[2])
                 parse_selection(@node[3])
               else
@@ -111,17 +111,26 @@ module Rails
           # Spread has a special behavior when using a fragment
           def prepare
             return super if inline?
-            raise(+'Prepare with fragment not implemented yet')
+            catch(:fragment_prepared) do
+              return fragment.prepare!
+            end
+
+            invalidate!
+            raise ExecutionError, (+<<~MSG).squish
+              Fields inside the "#{name}" fragment tried to be prepared more than once.
+              This feature is not supported yet.
+            MSG
           end
 
           # Resolve the spread operation
           def resolve
             return if unresolvable?
 
-            object = (defined?(@current_object) && @current_object) || parent.type_klass
+            object = (defined?(@current_object) && @current_object)
+            object ||= parent.type_klass unless parent.kind == :operation
             return run_on_fragment(:resolve_with!, object) unless inline?
 
-            super if type_klass =~ object
+            super if (object.nil? && type_klass&.operational?) || type_klass =~ object
           end
 
           # This will just trigger the selection resolver

data/lib/rails/graphql/request/component/typename.rb

@@ -45,7 +45,7 @@ module Rails
 
         # Write the typename information
         def write_value(value)
-          response.serialize(Type::Scalar::StringScalar, gql_name, value)
+          response.serialize(Type::Scalar::StringScalar, gql_name, value.itself)
         end
 
         # Typename is always broadcastable

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

@@ -111,6 +111,8 @@ module Rails
           # Run a given block and ensure to capture exceptions to set them as
           # errors
           def report_exception(error)
+            return if request.rescue_with_handler(error, source: self) == false
+
             Backtrace.print(error, self, request)
 
             stack_path = request.stack_to_path

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

@@ -43,7 +43,7 @@ module Rails
           at(1)
         end
 
-        # Get the current value, which basically means basically the first item
+        # Get the current value, which basically means the first item
         # on the current stack
         def current_value
           at(0)

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

@@ -10,10 +10,10 @@ module Rails
       class Event < GraphQL::Event
         OBJECT_BASED_READERS = %i[fragment spread].freeze
 
-        delegate :errors, :context, to: :request
+        delegate :errors, :context, :extensions, to: :request
         delegate :instance_for, to: :strategy
         delegate :memo, :schema, to: :source
-        delegate :subscription_field, to: :schema
+        delegate :subscription_provider, to: :schema
 
         attr_reader :strategy, :request, :index
 
@@ -34,12 +34,16 @@ module Rails
           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

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

@@ -29,6 +29,7 @@ module Rails
         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?
 

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

@@ -55,7 +55,7 @@ module Rails
           # 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 iteration and search. Complexity O(n)
+          # through iteration, then search and assign. Complexity O(n)
           def assign_fields!(assigners)
             pending = assigners.map(&:size).reduce(:+) || 0
             return if pending.zero?
@@ -72,19 +72,21 @@ module Rails
           # Recursive operation that perform the organization step for the
           # selection
           def organize_fields
-            selection.each_value(&:organize!) if selection.present?
+            return unless run_selection?
+            selection.each_value(&:organize!)
           end
 
           # Find all the fields that have a prepare step and execute them
           def prepare_fields
-            selection.each_value(&:prepare!) if selection.present?
+            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.present?
+            return unless run_selection?
 
             items = selection.each_value
             items = items.each_with_object(object) unless object.nil?
@@ -96,6 +98,10 @@ module Rails
 
         private
 
+          def run_selection?
+            selection.present? && !unresolvable?
+          end
+
           def add_component(node)
             item_name = node[1] || node[0]
 

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

@@ -20,6 +20,8 @@ module Rails
 
         # 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,16 +32,17 @@ module Rails
               block.call(nil, idx)
               response.next
 
-              format_array_execption(error, idx)
+              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)
             The #{gql_name} field is excepting an array
@@ -55,7 +58,7 @@ module Rails
         end
 
         # Add the item index to the exception message
-        def format_array_execption(error, idx)
+        def format_array_exception(error, idx)
           real_error = (+<<~MSG).squish
             The #{ActiveSupport::Inflector.ordinalize(idx + 1)} value of the #{gql_name} field
           MSG
@@ -70,13 +73,13 @@ module Rails
 
           # 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
 

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

@@ -17,6 +17,7 @@ module Rails
         REPEAT_OPTIONS = {
           true => true,
           false => 1,
+          once: 1,
           cycle: true,
           always: true,
         }.freeze
@@ -55,7 +56,8 @@ module Rails
           @field = field
           @value = value
           @array = value.is_a?(Array) && !field.array?
-          @repeat =
+          @repeat = true if !@array && !value.is_a?(Array)
+          @repeat ||=
             case repeat
             when Numeric then repeat
             when Enumerator then repeat.size

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

@@ -70,8 +70,8 @@ module Rails
             stacked do
               block.call
               strategy.add_listeners_from(self)
-              trigger_event(:organized)
               after_block.call if after_block.present?
+              trigger_event(:organized)
             end
           end
 

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

@@ -36,8 +36,8 @@ module Rails
 
             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/resolvable.rb

@@ -31,8 +31,8 @@ module Rails
 
             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/sequenced_strategy.rb

@@ -16,9 +16,9 @@ module Rails
         def resolve!
           response.with_stack('data') do
             for_each_operation do |op|
-              collect_listeners  { op.organize! }
-              collect_data(true) { op.prepare! }
-              collect_response   { op.resolve! }
+              collect_listeners          { op.organize! }
+              collect_data(op.mutation?) { op.prepare! }
+              collect_response           { op.resolve! }
             end
           end
         end

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

@@ -92,6 +92,7 @@ module Rails
         # Execute the prepare step for the given +field+ and execute the given
         # block using context stack
         def prepare(field, &block)
+          check_fragment_multiple_prepare!(field)
           value = safe_store_data(field) do
             prepared = request.prepared_data_for(field)
             if prepared.is_a?(PreparedData)
@@ -131,7 +132,7 @@ module Rails
 
           if field.try(:dynamic_resolver?)
             prepared = prepared_data_for(field)
-            args << Event.trigger(:resolve, field, self, prepared: prepared, &field.resolver)
+            args << Event.trigger(:resolve, field, self, prepared_data: prepared, &field.resolver)
           elsif field.prepared_data?
             args << prepared_data_for(field)
           else
@@ -279,6 +280,9 @@ module Rails
             @context = request.build(Request::Context)
 
             # TODO: Create an orchestrator to allow cross query loading
+            # TODO: We don't need to traverse over the fields, we can
+            # get the ones with such event and use parent to figure out
+            # the stack
             yield if force || listening_to?(:prepare)
           end
 
@@ -290,14 +294,24 @@ module Rails
 
           # Fetch the data for a given field and set as the first element
           # of the returned list
+          # TODO: Maybe implement root value to be returned by entry points
           def data_for(result, field)
             return result << @data_pool[field] if @data_pool.key?(field)
             return if field.entry_point?
 
-            current, key = context.current_value, field.method_name
-            return result << current.public_send(key) if current.respond_to?(key)
+            key = field.method_name
+            if (current = context.current_value).is_a?(::Hash)
+              result << (current.key?(key) ? current[key] : current[field.gql_name])
+            elsif current.respond_to?(key)
+              result << current.public_send(key)
+            end
+          end
 
-            result << current[key] if current.respond_to?(:key?) && current.key?(key)
+          # If the data pool already have data for the given +field+ and there
+          # is a fragment in the stack, we throw back to the fragment
+          def check_fragment_multiple_prepare!(field)
+            return unless @data_pool.key?(field)
+            throw(:fragment_prepared) if request.stack.any?(Component::Fragment)
           end
       end
     end

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

@@ -6,34 +6,36 @@ module Rails
       # = GraphQL Request Subscription
       #
       # A simple object to store information about a generated subscription
-      # TODO: Add a callback for the schema allowing it to prepare the context
-      # before saving it into a subscription
+      # TODO: Maybe add a callback for the schema allowing it to prepare the
+      # context before saving it into a subscription
       class Subscription
         NULL_SCOPE = Object.new.freeze
 
         attr_reader :sid, :schema, :args, :field, :scope, :context, :broadcastable,
-          :origin, :last_updated_at, :operation_id
+          :origin, :created_at, :updated_at, :operation_id
 
         alias broadcastable? broadcastable
+        alias id sid
 
         def initialize(request, operation)
-          entrypoint = operation.selection.each_value.first
+          entrypoint = operation.selection.each_value.first            # Memory Fingerprint
 
-          @schema = request.schema.namespace
-          @origin = request.origin
-          @operation_id = operation.hash
-          @args = entrypoint.arguments.to_h
-          @field = entrypoint.field
-          @context = request.context.to_h
-          @broadcastable = operation.broadcastable?
-          updated!
+          @schema = request.schema.namespace                           # 1 Symbol
+          @origin = request.origin                                     # * HEAVY!
+          @operation_id = operation.hash                               # 1 Integer
+          @args = entrypoint.arguments.to_h                            # 1 Hash of GQL values
+          @field = entrypoint.field                                    # 1 Pointer
+          @context = request.context.to_h                              # 1 Hash +/- heavy
+          @broadcastable = operation.broadcastable?                    # 1 Boolean
+          @created_at = Time.current                                   # 1 Integer
+          updated!                                                     # 1 Integer
 
-          @scope = parse_scope(field.full_scope, request, operation)
-          @sid = request.schema.subscription_id_for(self)
+          @scope = parse_scope(field.full_scope, request, operation)   # 1 Integer after save
+          @sid = request.schema.subscription_id_for(self)              # 1 String
         end
 
         def updated!
-          @last_updated_at = Time.current
+          @updated_at = Time.current
         end
 
         def marshal_dump
@@ -44,7 +46,7 @@ module Rails
           (+<<~INFO).squish << '>'
             #<#{self.class.name}
             #{schema}@#{sid}
-            [#{scope.nil? ? scope.inspect : scope.hash}, #{args.hash}]
+            [#{scope.inspect}, #{args.hash}]
             #{field.inspect}
           INFO
         end