rails-graphql 0.2.0 → 1.0.0.beta

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Request
+      # = GraphQL Request Backtrace
+      #
+      # Display any request errors in a nice way. By default, it won't display
+      # anything that is internal of this gem, but
+      module Backtrace
+        COL_MAX_WIDTH = 100
+
+        mattr_accessor :skip_base_class, instance_accessor: false,
+          default: Rails::GraphQL::StandardError
+
+        extend self
+
+        # Check if the given +error+ should be skipped
+        # TODO: Maybe check +cause+ to proper evaluate the skip
+        def skip?(error)
+          error.class <= skip_base_class
+        end
+
+        # Display the provided +error+ from the provided +request+
+        def print(error, component, request)
+          return if skip?(error)
+
+          table = print_table(error, component, request)
+          info = print_backtrace(error, request)
+
+          request.schema.logger.error(+"#{table}\n\n#{info}")
+        end
+
+        protected
+
+          # Organize and print a table of the place where the error occurred
+          def print_table(error, component, request)
+            table = begin_table
+            stack = [component] + request.stack
+            counter = stack.count { |item| !item.is_a?(Numeric) }
+            objects = request.strategy.context
+            oidx = -1
+
+            last_object = suffix = nil
+            while (item = stack.shift)
+              next suffix = +"[#{item}]" if item.is_a?(Numeric)
+              location = request.location_of(item)
+              location = location[0].values.join(':') if location
+
+              data = [counter, location]
+              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))
+              end
+
+              suffix = nil
+              counter -= 1
+              add_to_table(table, data) if add != false
+            end
+
+            stringify_table(table)
+          end
+
+          # Print the backtrace steps of the error
+          def print_backtrace(error, request)
+            steps = error.backtrace
+            steps = cleaner.clean(steps) unless cleaner.nil?
+
+            klass = +"(\e[4m#{error.class}\e[24m)"
+            stage = +" [#{request.strategy.stage}]" if skip_base_class != StandardError
+
+            +"\e[1m#{error.message} #{klass}#{stage}\e[0m\n#{steps.join("\n")}"
+          end
+
+          # Add new information to the table and update headers sizes
+          def add_to_table(table, data)
+            data = data.map(&:to_s)
+            table[:header].each.with_index do |(header, size), idx|
+              length = data[idx].length
+              if length > COL_MAX_WIDTH
+                table[:header][header] = COL_MAX_WIDTH
+                data[idx] = data[idx][0..COL_MAX_WIDTH][0..-5] + '...'
+              elsif length > size
+                table[:header][header] = length
+              end
+            end
+
+            table[:body] << data
+          end
+
+          # Build the string of the given table
+          def stringify_table(table)
+            sizes = table[:header].values
+            headers = table[:header].keys
+
+            # Add a little banner
+            table[:body][-1][1] = "\e[1m\e[35m#{'GQL'.ljust(sizes[1])}\e[0m"
+
+            # Build all the lines
+            lines = table[:body].reverse.prepend(headers).map do |row|
+              +' ' << row.map.with_index do |col, idx|
+                col.ljust(sizes[idx])
+              end.join(' | ') << ' '
+            end
+
+            # Add a divider between headers and values
+            divider = sizes.map { |val| '-' * val }.join('-+-')
+            divider = +'-' << divider << '-'
+            lines.insert(1, divider)
+
+            # Bold the header and join the lines
+            lines[0] = +"\e[1m#{lines[0]}\e[0m"
+            lines.join("\n")
+          end
+
+          # Better display records and other objects that might be to big to
+          # show in here
+          def print_object(object)
+            object.respond_to?(:to_gql_backtrace) ? object.to_gql_backtrace : object.inspect
+          end
+
+          # Visitors
+          def row_for_field(data, item, suffix)
+            field = item.field
+            name = +"#{field.owner.gql_name}.#{field.gql_name}#{suffix}" unless field.nil?
+
+            data.push(name || +"*.#{item.name}")
+            data.push(nil, (item.arguments ? item.arguments.to_json : 'nil'), 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(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.typename)
+          end
+
+          def row_for_spread(data, item, *)
+            return false unless item.inline?
+
+            type = item.instance_variable_get(:@node)[1]
+            object = item.current_object || item.type_klass
+            data.push('...', type, '')
+            data.push(print_object(object))
+          end
+
+          def row_for_schema(data, item, *)
+            data.push('schema', item.namespace.inspect, nil, item.name)
+          end
+
+        private
+
+          # The headers and sizes plus the rows for the table structure
+          def begin_table
+            {
+              header: {
+                ' ' => 1,
+                'Loc' => 3,
+                'Field' => 5,
+                'Object' => 6,
+                'Arguments' => 9,
+                'Result' => 6,
+              },
+              body: [],
+            }
+          end
+
+          # Find the class that will be responsible for cleaning the backtrace
+          def cleaner
+            LogSubscriber.backtrace_cleaner
+          end
+
+          # Rewrite the cleaner method so that it returns nil and do not clean
+          # any of the items of the backtrace
+          def show_everything!
+            redefine_singleton_method(:cleaner) { nil }
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/component/field.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 Request Component Field
       #
       # This class holds information about a given field that should be
@@ -14,61 +14,73 @@ module Rails # :nodoc:
         include Directives
 
         delegate :decorate, to: :type_klass
-        delegate :operation, :variables, to: :parent
-        delegate :method_name, :resolver, :performer, :type_klass, :leaf_type?,
-          :dynamic_resolver?, to: :field
-
-        parent_memoize :request
+        delegate :operation, :variables, :request, to: :parent
+        delegate :method_name, :resolver, :performer, :type_klass,:leaf_type?,
+          :dynamic_resolver?, :mutation?, to: :field
 
         attr_reader :name, :alias_name, :parent, :field, :arguments, :current_object
 
         alias args arguments
 
-        def initialize(parent, node, data)
+        def initialize(parent, node)
           @parent = parent
 
-          @name = data[:name]
-          @alias_name = data[:alias]
-
-          super(node, data)
-        end
+          @name = node[0]
+          @alias_name = node[1]
 
-        # Return both the field directives and the request directives
-        def all_directives
-          field.all_directives + super
+          super(node)
         end
 
         # Override that considers the requested field directives and also the
         # definition field events, both from itself and its directives events
         def all_listeners
-          (request.cache(:listeners)[field] ||= field.all_listeners) + super
+          request.nested_cache(:listeners, field) do
+            if !field.listeners?
+              directive_listeners
+            elsif !directives?
+              field.all_listeners
+            else
+              local = directive_listeners
+              local.empty? ? field.all_listeners : field.all_listeners + local
+            end
+          end
         end
 
         # Override that considers the requested field directives and also the
         # definition field events, both from itself and its directives events
         def all_events
-          @all_events ||= Helpers.merge_hash_array(
-            (request.cache(:events)[field] ||= field.all_events),
-            super,
-          )
+          request.nested_cache(:events, field) do
+            if !field.events?
+              directive_events
+            elsif !directives?
+              field.all_events
+            else
+              Helpers.merge_hash_array(field.all_events, directive_events)
+            end
+          end
         end
 
         # Get and cache all the arguments for the field
         def all_arguments
-          request.cache(:arguments)[field] ||= begin
-            if (result = field.all_arguments).any?
-              result.each_value.map(&:gql_name).zip(result.each_value).to_h
-            else
-              {}
+          return unless field.arguments?
+
+          request.nested_cache(:arguments, field) do
+            field.all_arguments.each_value.with_object({}) do |argument, hash|
+              hash[argument.gql_name] = argument
             end
           end
         end
 
+        # Check if the field is using a directive
+        def using?(item_or_symbol)
+          super || field.using?(item_or_symbol)
+        end
+
         # Assign a given +field+ to this class. The field must be an output
         # field, which means that +output_type?+ must be true. It also must be
         # called exactly once per field.
-        def assing_to(field)
-          raise ArgumentError, <<~MSG.squish if defined?(@assigned)
+        def assign_to(field)
+          raise ArgumentError, (+<<~MSG).squish if defined?(@assigned)
             The "#{gql_name}" field is already assigned to #{@field.inspect}.
           MSG
 
@@ -97,6 +109,14 @@ module Rails # :nodoc:
           true
         end
 
+        # Check if all the sub fields are broadcastable
+        # TODO: Maybe check for interfaces and if all types allow broadcast
+        def broadcastable?
+          value = field.broadcastable?
+          value = schema.config.default_subscription_broadcastable if value.nil?
+          value != false
+        end
+
         # A little extension of the +is_a?+ method that allows checking it using
         # the underlying +field+
         def of_type?(klass)
@@ -106,7 +126,7 @@ module Rails # :nodoc:
         # When the field is invalid, there's no much to do
         # TODO: Maybe add a invalid event trigger here
         def resolve_invalid(error = nil)
-          request.exception_to_error(error, @node) if error.present?
+          request.exception_to_error(error, self) if error.present?
 
           validate_output!(nil)
           response.safe_add(gql_name, nil)
@@ -118,26 +138,44 @@ module Rails # :nodoc:
         # field needs to be redirected to the one from the actual resolved
         # +object+ type
         def resolve_with!(object)
+          return if skipped?
           return resolve! if invalid?
 
           old_field, @field = @field, object[@field.name]
+          request.nested_cache(:listeners, field) { strategy.add_listeners_from(self) }
           @current_object = object
           resolve!
         ensure
           @field, @current_object = old_field, nil
         end
 
+        # Build the cache object
+        def cache_dump
+          super.merge(field: (field && all_to_gid(field)))
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][0]
+          @alias_name = data[:node][1]
+          @field = all_from_gid(data[:field])
+          super
+
+          check_authorization! unless unresolvable?
+        end
+
         protected
 
           # Perform the organization step
           def organize_then(&block)
             super(block) do
               check_assignment!
+
+              parse_directives(@node[3])
               check_authorization!
 
-              parse_arguments
-              parse_directives
-              parse_selection
+              parse_arguments(@node[2])
+              parse_selection(@node[4])
             end
           end
 
@@ -149,8 +187,7 @@ module Rails # :nodoc:
           # Perform the resolve step
           def resolve_then(&block)
             stacked do
-              strategy.perform(self) if field.mutation?
-              send(field.array? ? 'resolve_many' : 'resolve_one', &block)
+              send((field.array? ? :resolve_many : :resolve_one), &block)
             rescue StandardError => error
               resolve_invalid(error)
             end
@@ -181,46 +218,30 @@ module Rails # :nodoc:
             end
           end
 
-          # This override allows reasigned fields to perform events. This
-          # happens when fields are originally organized from interfaces. If
-          # the event is stopped for the object, then it doesn't proceed to the
-          # strategy implementation, ensuring compatibility
-          def trigger_event(event_name, **xargs)
-            return super if !defined?(@current_object) || @current_object.nil?
-
-            listeners = request.cache(:listeners)[field] ||= field.all_listeners
-            return super unless listeners.include?(event_name)
-
-            callbacks = request.cache(:events)[field] ||= field.all_events
-            old_events, @all_events = @all_events, callbacks
-            super
-          ensure
-            @all_events = old_events
-          end
-
           # Check if the field was assigned correctly to an output field
           def check_assignment!
-            raise MissingFieldError, <<~MSG.squish if field.nil?
+            raise MissingFieldError, (+<<~MSG).squish if field.nil?
               Unable to find a field named "#{gql_name}" on
               #{entry_point? ? operation.kind : parent.type_klass.name}.
             MSG
 
-            raise FieldError, <<~MSG.squish unless field.output_type?
+            raise FieldError, (+<<~MSG).squish unless field.output_type?
               The "#{gql_name}" was assigned to a non-output type of field: #{field.inspect}.
             MSG
 
-            empty_selection = data[:selection].nil? || data[:selection].null?
-            raise FieldError, <<~MSG.squish if field.leaf_type? && !empty_selection
-              The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
-              is a leaf type and does not have nested fields.
-            MSG
-
-            raise FieldError, <<~MSG.squish if !field.leaf_type? && empty_selection
-              The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
-              is not a leaf type and requires a selection of fields.
-            MSG
+            if @node[4].nil?
+              raise FieldError, (+<<~MSG).squish if !field.leaf_type?
+                The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
+                is not a leaf type and requires a selection of fields.
+              MSG
+            else
+              raise FieldError, (+<<~MSG).squish if field.leaf_type?
+                The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
+                is a leaf type and does not have nested fields.
+              MSG
+            end
 
-            raise DisabledFieldError, <<~MSG.squish if field.disabled?
+            raise DisabledFieldError, (+<<~MSG).squish if field.disabled?
               The "#{gql_name}" was found but it is marked as disabled.
             MSG
           end

data/lib/rails/graphql/request/component/fragment.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 Request Component Fragment
       #
       # This class holds information about a given fragment defined using the
@@ -12,19 +12,18 @@ module Rails # :nodoc:
         include SelectionSet
         include Directives
 
-        attr_reader :name, :type_klass, :request
+        attr_reader :name, :type_klass, :request, :current_object
 
-        def initialize(request, node, data)
-          @name = data[:name]
+        def initialize(request, node)
+          @name = node[0]
           @request = request
 
-          super(node, data)
+          super(node)
 
           check_duplicated_fragment!
         end
 
         # Return a lazy loaded variable proc
-        # TODO: Mark all the dependent variables
         def variables
           Request::Arguments.lazy
         end
@@ -34,6 +33,16 @@ module Rails # :nodoc:
           Request::Arguments.operation
         end
 
+        # Stores all the used variables
+        def used_variables
+          return @used_variables if defined?(@used_variables)
+        end
+
+        # Stores all the used nested fragments
+        def used_fragments
+          return @used_fragments if defined?(@used_fragments)
+        end
+
         # Spread should always be performed with a current object, thus the
         # typename comes from it
         def typename
@@ -42,7 +51,7 @@ module Rails # :nodoc:
 
         # Only resolve if the +type_klass+ is equivalent to the given +object+
         def resolve_with!(object)
-          return if invalid?
+          return if unresolvable?
 
           @current_object = object
           resolve!
@@ -50,6 +59,24 @@ module Rails # :nodoc:
           @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))
+        end
+
+        # Organize from cache data
+        def cache_load(data)
+          @name = data[:node][0]
+          @type_klass = all_from_gid(data[:type_klass])
+
+          super
+        end
+
         protected
 
           # Fragments always resolve selection unstacked on response, meaning
@@ -58,20 +85,25 @@ module Rails # :nodoc:
             false
           end
 
+          # Wrap the field organization with the collection of variables
+          def organize
+            organize_then { collect_usages { organize_fields } }
+          end
+
           # Perform the organization step
           def organize_then(&block)
             super(block) do
-              @type_klass = find_type!(data[:type])
-              parse_directives(:fragment_definition)
+              @type_klass = find_type!(@node[1])
+              parse_directives(@node[2], :fragment_definition)
 
               check_assignment!
-              parse_selection
+              parse_selection(@node[3])
             end
           end
 
           # Resolve the spread operation
           def resolve
-            return if invalid?
+            return if unresolvable?
 
             object = @current_object || type_klass
             resolve_then if type_klass =~ object
@@ -86,32 +118,48 @@ module Rails # :nodoc:
 
           # Check if the field was assigned correctly to an output field
           def check_assignment!
-            raise ExecutionError, <<~MSG.squish unless type_klass.output_type?
-              Unable to assing #{type_klass.gql_name} to "#{name}" fragment because
+            raise ExecutionError, (+<<~MSG).squish unless type_klass.output_type?
+              Unable to assign #{type_klass.gql_name} to "#{name}" fragment because
               it is not a output type.
             MSG
 
-            raise ExecutionError, <<~MSG.squish if type_klass.leaf_type?
-              Unable to assing #{type_klass.gql_name} to "#{name}" fragment because
-              a "#{type_klass.kind}" type can not be the source of a fragmnet.
+            raise ExecutionError, (+<<~MSG).squish if type_klass.leaf_type?
+              Unable to assign #{type_klass.gql_name} to "#{name}" fragment because
+              a "#{type_klass.kind}" type can not be the source of a fragment.
             MSG
           end
 
           # If there is another fragment with the same name already defined,
           # raise an error
           def check_duplicated_fragment!
-            return unless request.fragments.key?(name)
+            other = request.document[1].find do |other|
+              other != @node && name == other[0]
+            end
 
+            return if other.nil?
             invalidate!
 
-            other_node = request.fragments[name].instance_variable_get(:@node)
-            location = GraphQL::Native.get_location(other_node)
-
-            request.report_node_error(<<~MSG.squish, @node)
+            request.report_node_error((+<<~MSG).squish, self)
               Duplicated fragment named "#{name}" defined on
-              line #{location.begin_line}:#{location.begin_column}
+              line #{other.begin_line}:#{other.begin_column}
             MSG
           end
+
+          # Use the information on the operation to collect all the variables
+          # and nested fragments that were used inside a fragment
+          def collect_usages
+            vars_total = operation.used_variables.size
+            frag_total = operation.used_fragments.size
+            yield
+          ensure
+            if operation.used_variables.size > vars_total
+              @used_variables = Set.new(operation.used_variables.to_enum.drop(vars_total))
+            end
+
+            if operation.used_fragments.size > frag_total
+              @used_fragments = Set.new(operation.used_fragments.to_enum.drop(frag_total))
+            end
+          end
       end
     end
   end