rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/railties/controller.rb

@@ -1,20 +1,30 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Controller
     #
     # The controller helper methods that allow GraphQL to be performed on a
-    # Rails Controller class.
+    # Rails Controller class
     module Controller
       extend ActiveSupport::Concern
 
-      REQUEST_XARGS = %i[operation_name variables context schema].freeze
+      REQUEST_XARGS = %i[operation_name variables context schema query_cache_key].freeze
+      DESCRIBE_HEADER = <<~TXT.freeze
+        """
+        Use the following HTTP params to modify this result:
+          without_descriptions => Hide all descriptions
+          without_spec => Hide all default spec types
+        """
+      TXT
 
       included do
         # Each controller is assigned to a GraphQL schema on which the requests
         # will be performed from. It can be a string or the class
         class_attribute :gql_schema, instance_accessor: false
+
+        # Add the internal views directory
+        prepend_view_path("#{__dir__}/app/views")
       end
 
       # POST /execute
@@ -24,49 +34,73 @@ module Rails # :nodoc:
 
       # GET /describe
       def describe
-        render plain: gql_schema.to_gql(
-          with_descriptions: !params.key?(:without_descriptions),
-          with_spec: !params.key?(:without_spec),
-        )
+        render plain: gql_schema_header + gql_describe_schema + gql_schema_footer
+      end
+
+      # GET /graphiql
+      def graphiql
+        render '/graphiql', layout: false, locals: { settings: graphiql_settings }
       end
 
       protected
 
+        # Identifies if the request should be threated as a compiled request
+        def gql_compiled_request?(*)
+          false
+        end
+
         # Render a response as a GraphQL request
         def gql_request_response(*args, **xargs)
           render json: gql_request(*args, **xargs)
         end
 
         # Execute a GraphQL request
-        def gql_request(query, **xargs)
-          request_xargs = REQUEST_XARGS.inject({}) do |result, setting|
-            result.merge(setting => (xargs[setting] || send("gql_#{setting}")))
+        def gql_request(document, **xargs)
+          request_xargs = REQUEST_XARGS.each_with_object({}) do |setting, result|
+            result[setting] ||= (xargs[setting] || send(:"gql_#{setting}"))
           end
 
-          ::Rails::GraphQL::Request.execute(query, **request_xargs)
+          request_xargs[:hash] ||= gql_query_cache_key
+          request_xargs[:origin] ||= self
+          request_xargs[:compiled] ||= gql_compiled_request?(document)
+
+          request_xargs = request_xargs.except(*%i[query_cache_key query_cache_version])
+          ::Rails::GraphQL::Request.execute(document, **request_xargs)
         end
 
         # The schema on which the requests will be performed from
         def gql_schema
+          return @gql_schema if defined?(@gql_schema)
+
           schema = self.class.gql_schema
-          schema = schema.safe_constantize if schema.is_a?(String)
-          schema ||= application_default_schema
-          return schema if schema.is_a?(Module) && schema < ::Rails::GraphQL::Schema
+          schema = schema.constantize if schema.is_a?(String)
+          schema ||= gql_application_default_schema
+
+          return @gql_schema = schema if schema.is_a?(Module) &&
+            schema < ::Rails::GraphQL::Schema
 
-          raise ExecutionError, <<~MSG.squish
+          raise ExecutionError, (+<<~MSG).squish
             Unable to find a valid schema for #{self.class.name},
             defined value: #{schema.inspect}.
           MSG
         end
 
         # Get the GraphQL query to execute
-        def gql_query
+        def gql_document
           params[:query]
         end
 
+        alias gql_query gql_document
+
+        # Get the cache key of the query for persisted queries
+        def gql_query_cache_key(key = nil, version = nil)
+          return unless (key ||= params[:query_cache_key]).present?
+          CacheKey.new(key, version || params[:query_cache_version])
+        end
+
         # Get the GraphQL operation name
         def gql_operation_name
-          params[:operationName]
+          params[:operationName] || params[:operation_name]
         end
 
         # Get the GraphQL context for a requests
@@ -84,16 +118,48 @@ module Rails # :nodoc:
           end
         end
 
+        # Return the settings for the GraphiQL view
+        def graphiql_settings(mode = nil)
+          if mode == :cable
+            { mode: :cable, url: '/cable', channel: 'GraphQL::BaseChannel' }
+          else
+            { mode: :fetch, url: '/graphql' }
+          end
+        end
+
+        # Shows a text representation of the schema
+        def gql_describe_schema(schema = gql_schema)
+          schema.to_gql(
+            with_descriptions: !params.key?(:without_descriptions),
+            with_spec: !params.key?(:without_spec),
+          )
+        end
+
+        # Print a header of the current schema for the description process
+        # TODO: Maybe add a way to detect from which file the schema is being loaded
+        def gql_schema_header
+          ns = +" [#{gql_schema.namespace}]" if gql_schema.namespace != :base
+          +"#{DESCRIBE_HEADER}# Schema #{gql_schema.name}#{ns}\n"
+        end
+
+        # Show the footer of the describe page
+        def gql_schema_footer
+          $/ + $/ + '# Version: ' + gql_version + $/ +
+            '# Rails GraphQL ' + ::Rails::GraphQL::VERSION::STRING +
+            ' (Spec ' + ::GQLParser::VERSION + ')'
+        end
+
+        # Get the version of the running instance of GraphQL
+        def gql_version
+          ::Rails::GraphQL.type_map.version
+        end
+
       private
 
         # Find the default application schema
-        def application_default_schema
-          app_class = Rails.application.class
-          source_name = app_class.respond_to?(:module_parent_name) \
-            ? :module_parent_name \
-            : :parent_name
-
-          klass = "::GraphQL::#{app_class.send(source_name)}Schema".constantize
+        def gql_application_default_schema
+          app_class = Rails.application.class.name.chomp('::Application')
+          klass = "::GraphQL::#{app_class}Schema".safe_constantize
           self.class.gql_schema = klass
         end
     end

data/lib/rails/graphql/railties/controller_runtime.rb

@@ -2,20 +2,20 @@
 
 require 'active_support/core_ext/module/attr_internal'
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Controller Runtime
     #
     # Tool that calculates the runtime of a GraphQL operation. This works
     # similar to how Rails ActiveRecord calculate its execution time while
-    # performing a request.
+    # performing a request
     module ControllerRuntime
       extend ActiveSupport::Concern
 
-      module ClassMethods # :nodoc: all
+      module ClassMethods
         def log_process_action(payload)
           messages, gql_runtime = super, payload[:gql_runtime]
-          messages << format('GraphQL: %.1fms', gql_runtime.to_f) if gql_runtime
+          messages << format(+'GraphQL: %.1fms', gql_runtime.to_f) if gql_runtime
           messages
         end
       end

data/lib/rails/graphql/railties/log_subscriber.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+require "active_support/parameter_filter"
+
+module Rails
+  module GraphQL
     # = GraphQL Log Subscriber
     #
-    # This is the log tracker that workds the same way as ActiveRecord when it
-    # has to report on logs that a query was performed.
-    class LogSubscriber < ::ActiveSupport::LogSubscriber # :nodoc: all
+    # This is the log tracker that works the same way as ActiveRecord when it
+    # has to report on logs that a query was performed
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
       class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
 
+      REMOVE_COMMENTS = /#(?=(?:[^"]*"[^"]*")*[^"]*$).*/
+
       def self.runtime
         RuntimeRegistry.gql_runtime ||= 0
       end
@@ -22,23 +26,65 @@ module Rails # :nodoc:
         return unless logger.debug?
 
         payload = event.payload
+        cached = '[CACHE]' if payload[:cached]
+        doc = payload[:document]&.gsub(REMOVE_COMMENTS, '')&.squish
+
+        desc = +"#{header(event, cached)}  #{doc}"
+        desc << debug_variables(payload[:variables]) unless payload[:variables].blank?
+
+        debug(desc)
+      end
+
+      def compile(event)
+        return unless logger.debug?
+
+        payload = event.payload
+        doc = payload[:document].gsub(REMOVE_COMMENTS, '').squish
+
+        helper = ActiveSupport::NumberHelper::NumberToHumanSizeConverter
+        total = helper.convert(payload[:total], EMPTY_HASH)
+
+        debug(+"#{header(event, 'Compile')} #{total}  #{doc}")
+      end
+
+      def validate(event)
+        return unless logger.debug?
+
+        payload = event.payload
+        doc = payload[:document].gsub(REMOVE_COMMENTS, '').squish
+        valid = payload[:result] ? color('YES', GREEN) : color('NO', RED)
+
+        debug(+"#{header(event, 'Valid?')} #{valid}  #{doc}")
+      end
+
+      def subscription(event)
+        return unless logger.info?
 
-        name = ['GraphQL', payload[:name].presence]
-        name.unshift('CACHE') if payload[:cached]
-        name = "#{name.compact.join(' ')} (#{event.duration.round(1)}ms)"
+        item, type, provider = event.payload.values_at(:item, :type, :provider)
+        provider = provider.class.name.sub(/\ARails::GraphQL::Subscription::/, '')
+        duration = event.duration.round(1)
 
-        document = payload[:document].squish
-        variables = payload[:variables].blank? ? nil : begin
-          "  (#{JSON.pretty_generate(payload[:variables]).squish})"
+        desc = +"#{header(event, provider)} Subscription #{type}"
+
+        unless item.nil?
+          hex = { added: GREEN, removed: RED, updated: BLUE }[type]
+
+          if type == :updated
+            desc << +": #{color(item.sid, hex)}"
+          else
+            desc << +": [#{color(item.sid, hex)}] #{item.schema}.#{item.field.gql_name}"
+            desc << +" [#{(item.scope === null_subscription_scope ? nil : item.scope).inspect}"
+            desc << +", #{item.args.as_json.inspect}]"
+          end
         end
 
-        debug "  #{color(name, MAGENTA, true)}  #{document}#{variables}"
+        info(desc)
       end
 
       private
 
         def logger
-          GraphQL.config.logger
+          GraphQL.logger
         end
 
         def debug(*)
@@ -47,14 +93,35 @@ module Rails # :nodoc:
           log_query_source if GraphQL.config.verbose_logs
         end
 
+        def header(event, suffix = '')
+          duration = event.duration.round(1)
+          parts = ['  GraphQL', suffix.presence, event.payload[:name]]
+          parts << "(#{duration}ms)" unless duration.zero?
+
+          color(parts.compact.join(' '), MAGENTA, true)
+        end
+
+        def debug_variables(vars)
+          vars = JSON.pretty_generate(parameter_filter.filter(vars))
+          +'  ' << '(' << vars.squish << ')'
+        end
+
         def log_query_source
           source = extract_query_source_location(caller)
-          logger.debug("  ↳ #{source}") if source
+          logger.debug(+"  ↳ #{source}") if source
         end
 
         def extract_query_source_location(locations)
           backtrace_cleaner.clean(locations.lazy).first
         end
+
+        def parameter_filter
+          ActiveSupport::ParameterFilter.new(GraphQL.config.filter_parameters)
+        end
+
+        def null_subscription_scope
+          Request::Subscription::NULL_SCOPE
+        end
     end
   end
 

data/lib/rails/graphql/request/arguments.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 Arguments
       #
       # This is an extension of an +OpenStruct+ since argument values can be
@@ -14,14 +14,34 @@ module Rails # :nodoc:
       # the spread and operation.
       class Arguments < OpenStruct
         THREAD_KEY = :_rails_graphql_operation
-        LAZY_LOADER = ->(key, object) { object.variables[key] }.curry
 
-        delegate :key?, to: :@table
+        class Lazy < Delegator
+          attr_reader :var_name
+
+          def self.[](key)
+            new(key)
+          end
+
+          def initialize(var_name)
+            @var_name = var_name
+          end
+
+          def __getobj__
+            Arguments.operation&.variables&.dig(var_name)
+          end
+
+          def __setobj__(*)
+            raise FrozenError
+          end
+        end
+
+        delegate :key?, :[], to: :@table
+        alias to_hash to_h
 
         class << self
           # Easy access to the easy loader method
           def lazy
-            LAZY_LOADER
+            Lazy
           end
 
           # Get the current operation thread safely
@@ -42,50 +62,6 @@ module Rails # :nodoc:
           def scoped?
             operation.present?
           end
-
-          # If it's running under a scope, transform proc based values
-          def transform(value)
-            return if value.nil?
-            scoped? && value.is_a?(Proc) ? value.call(operation) : value
-          end
-        end
-
-        # Transform any proc by its actual value before returning the hash
-        def to_h(*)
-          super.transform_values(&self.class.method(:transform))
-        end
-
-        # Before iterating, transform any needed value
-        def each_pair
-          enum = to_h.to_enum
-          return enum unless block_given?
-          enum.each { |v| yield v }
-          self
-        end
-
-        # rubocop:disable Style/MissingRespondToMissing
-        # Transform the value before returning
-        def method_missing(*)
-          self.class.transform(super)
-        end
-        # rubocop:enable Style/MissingRespondToMissing
-
-        # Transform the value before returning
-        def [](*)
-          self.class.transform(super)
-        end
-
-        # Transform the value before returning
-        def dig(name, *names)
-          result = self.class.transform(super(name))
-          names.empty? ? result : result&.dig(*names)
-        end
-
-        # Override the freeze method to just freeze the table and do not create
-        # the getters and setter methods
-        def freeze
-          @table.freeze
-          super
         end
       end
     end

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

@@ -0,0 +1,212 @@
+# 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
+            oid = -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
+                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
+            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
+
+          # 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
+            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, 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, 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.variables)
+            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, nil)
+            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