rails-graphql 0.1.0

data/lib/rails/graphql/railtie.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+require 'action_controller'
+require 'action_controller/railtie'
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = Rails GraphQL Railtie
+    #
+    # Rails integration and configuration
+    class Railtie < Rails::Railtie
+      config.eager_load_namespaces << Rails::GraphQL
+      config.graphql = GraphQL.config
+
+      rake_tasks do
+        load 'rails/graphql.rake'
+      end
+
+      runner do
+        require_relative './schema'
+      end
+
+      # Ensure a valid logger
+      initializer 'graphql.logger' do
+        ActiveSupport.on_load(:graphql) do
+          return if config.logger.present?
+          if ::Rails.logger.respond_to?(:tagged)
+            config.logger = ::Rails.logger
+          else
+            config.logger = ActiveSupport::TaggedLogging.new(::Rails.logger)
+          end
+        end
+      end
+
+      # Expose database runtime to controller for logging.
+      initializer 'graphql.log_runtime' do
+        require_relative './railties/controller_runtime'
+        ActiveSupport.on_load(:action_controller) do
+          include GraphQL::ControllerRuntime
+        end
+      end
+
+      # Backtrace cleaner for removing gem paths
+      initializer 'graphql.backtrace_cleaner' do
+        require_relative './railties/log_subscriber'
+        ActiveSupport.on_load(:graphql) do
+          GraphQL::LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
+        end
+      end
+
+      # Add reloader ability for files under 'app/graphql'
+      # TODO: Maybe improve to use rails auto loader
+      initializer 'graphql.reloader' do
+        Rails::GraphQL.eager_load!
+        ActiveSupport::Reloader.to_prepare do
+          Rails::GraphQL.type_map.use_checkpoint!
+          Rails::GraphQL.reload_ar_adapters!
+
+          Object.send(:remove_const, :GraphQL) if Object.const_defined?(:GraphQL)
+
+          load "#{__dir__}/shortcuts.rb"
+
+          $LOAD_PATH.each do |path|
+            next unless path =~ %r{\/app\/graphql$}
+            Dir.glob("#{path}/**/*.rb").sort.each(&method(:load))
+          end
+
+          GraphQL::Source.send(:build_pending!)
+        end
+      end
+
+      # initializer "active_record.set_reloader_hooks" do
+      #   ActiveSupport.on_load(:active_record) do
+      #     ActiveSupport::Reloader.before_class_unload do
+      #       if ActiveRecord::Base.connected?
+      #         ActiveRecord::Base.clear_cache!
+      #         ActiveRecord::Base.clear_reloadable_connections!
+      #       end
+      #     end
+      #   end
+      # end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Base Generator
+    #
+    # A module to help generators to operate
+    module BaseGenerator
+      TEMPALTES_PATH = '../../../generators/graphql/templates'
+
+      def self.included(base)
+        base.send(:namespace, "graphql:#{base.name.demodulize.underscore[0..-11]}")
+        base.send(:source_root, File.expand_path(TEMPALTES_PATH, __dir__))
+        base.send(:class_option, :directory,
+          type: :string,
+          default: 'app/graphql',
+          desc: 'Directory where generated files should be saved',
+        )
+      end
+
+      protected
+
+        def app_module_name
+          require File.expand_path('config/application', destination_root)
+
+          app_class = Rails.application.class
+          source_name = app_class.respond_to?(:module_parent_name) \
+            ? :module_parent_name \
+            : :parent_name
+
+          app_class.send(source_name)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Controller
+    #
+    # The controller helper methods that allow GraphQL to be performed on a
+    # Rails Controller class.
+    module Controller
+      extend ActiveSupport::Concern
+
+      REQUEST_XARGS = %i[operation_name variables context schema].freeze
+
+      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
+      end
+
+      # POST /execute
+      def execute
+        gql_request_response(gql_query)
+      end
+
+      # GET /describe
+      def describe
+        render plain: gql_schema.to_gql(
+          with_descriptions: !params.key?(:without_descriptions),
+          with_spec: !params.key?(:without_spec),
+        )
+      end
+
+      protected
+
+        # 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}")))
+          end
+
+          ::Rails::GraphQL::Request.execute(query, **request_xargs)
+        end
+
+        # The schema on which the requests will be performed from
+        def 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
+
+          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
+          params[:query]
+        end
+
+        # Get the GraphQL operation name
+        def gql_operation_name
+          params[:operationName]
+        end
+
+        # Get the GraphQL context for a requests
+        def gql_context
+          {}
+        end
+
+        # Get the GraphQL variables for a request
+        def gql_variables(variables = params[:variables])
+          case variables
+          when ::ActionController::Parameters then variables.permit!
+          when String then variables.present? ? JSON.parse(variables) : {}
+          when Hash   then variables
+          else {}
+          end
+        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
+          self.class.gql_schema = klass
+        end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/attr_internal'
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = 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.
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      module ClassMethods # :nodoc: all
+        def log_process_action(payload)
+          messages, gql_runtime = super, payload[:gql_runtime]
+          messages << format('GraphQL: %.1fms', gql_runtime.to_f) if gql_runtime
+          messages
+        end
+      end
+
+      private
+
+        attr_internal :gql_runtime
+
+        def process_action(*)
+          LogSubscriber.runtime = 0
+          super
+        end
+
+        def append_info_to_payload(payload)
+          super
+
+          payload[:gql_runtime] = LogSubscriber.runtime \
+            if (LogSubscriber.runtime || 0).positive?
+        end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = 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
+      class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
+      def self.runtime
+        RuntimeRegistry.gql_runtime ||= 0
+      end
+
+      def self.runtime=(value)
+        RuntimeRegistry.gql_runtime = value
+      end
+
+      def request(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        payload = event.payload
+
+        name = ['GraphQL', payload[:name].presence]
+        name.unshift('CACHE') if payload[:cached]
+        name = "#{name.compact.join(' ')} (#{event.duration.round(1)}ms)"
+
+        document = payload[:document].squish
+        variables = payload[:variables].blank? ? nil : begin
+          "  (#{JSON.pretty_generate(payload[:variables]).squish})"
+        end
+
+        debug "  #{color(name, MAGENTA, true)}  #{document}#{variables}"
+      end
+
+      private
+
+        def logger
+          GraphQL.config.logger
+        end
+
+        def debug(*)
+          return unless super
+
+          log_query_source if GraphQL.config.verbose_logs
+        end
+
+        def log_query_source
+          source = extract_query_source_location(caller)
+          logger.debug("  ↳ #{source}") if source
+        end
+
+        def extract_query_source_location(locations)
+          backtrace_cleaner.clean(locations.lazy).first
+        end
+    end
+  end
+
+  GraphQL::LogSubscriber.attach_to :graphql
+end

data/lib/rails/graphql/request.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Request
+    #
+    # This class is responsible for processing a GraphQL response. It will
+    # handle queries, mutations, and subscription, as long as all of them are
+    # provided together. It also can be executed multiple times using the same
+    # context calling +execute+ multiple times.
+    #
+    # ==== Options
+    #
+    # * <tt>:namespace</tt> - Set what is the namespace used for the request
+    #   (defaults to :base).
+    class Request
+      extend ActiveSupport::Autoload
+
+      RESPONSE_FORMATS = { string: :to_s, object: :to_h, hash: :to_h }.freeze
+
+      eager_autoload do
+        autoload_under :steps do
+          autoload :Organizable
+          autoload :Prepareable
+          autoload :Resolveable
+        end
+
+        autoload_under :helpers do
+          autoload :Directives
+          autoload :SelectionSet
+          autoload :ValueWriters
+        end
+
+        autoload :Arguments
+        autoload :Component
+        autoload :Context
+        autoload :Errors
+        autoload :Event
+        autoload :Strategy
+      end
+
+      attr_reader :schema, :visitor, :operations, :fragments, :errors,
+        :args, :response, :strategy, :stack
+
+      delegate :all_listeners, to: :schema
+
+      class << self
+        # Shortcut for initialize, set context, and execute
+        def execute(*args, schema: nil, namespace: :base, context: {}, **xargs)
+          result = new(schema, namespace: namespace)
+          result.context = context if context.present?
+          result.execute(*args, **xargs)
+        end
+
+        # Allow accessing component-based objects through the request
+        def const_defined?(name, *)
+          Component.const_defined?(name) || super
+        end
+
+        # Allow accessing component-based objects through the request
+        def const_missing(name)
+          Component.const_defined?(name) ? Component.const_get(name) : super
+        end
+
+        def eager_load! # :nodoc:
+          super
+
+          Request::Component.eager_load!
+          Request::Strategy.eager_load!
+        end
+      end
+
+      # Forces the schema to be registered on type map before moving forward
+      def initialize(schema = nil, namespace: :base)
+        @namespace = schema&.namespace || namespace
+        @schema = GraphQL::Schema.find!(@namespace)
+        @extensions = {}
+
+        ensure_schema!
+      end
+
+      # Cache all the schema events for this current request
+      def all_events
+        @all_events ||= schema.all_events
+      end
+
+      # Get the context of the request
+      def context
+        @context ||= OpenStruct.new.freeze
+      end
+
+      # Set the context of the request, it must be a +Hash+
+      def context=(data)
+        @context = build_ostruct(data).freeze
+      end
+
+      # Execute a given document with the given arguments
+      def execute(document, as: :string, **xargs)
+        reset!(**xargs)
+
+        to = RESPONSE_FORMATS[as]
+        @response = initialize_response(as, to)
+
+        execute!(document)
+        response.public_send(to)
+      end
+
+      alias perform execute
+
+      # Build a easy-to-access object representing the current information of
+      # the execution to be used on +rescue_with_handler+
+      def build_rescue_object(**extra)
+        OpenStruct.new(extra.reverse_merge(
+          args: @args,
+          source: stack.first,
+          request: self,
+          response: @response,
+          document: @document,
+        )).freeze
+      end
+
+      # Use schema handlers for exceptions caught during the execution process
+      def rescue_with_handler(exception, **extra)
+        schema.rescue_with_handler(exception, object: build_rescue_object(**extra))
+      end
+
+      # Add the given +exception+ to the errors using the +node+ location
+      def exception_to_error(exception, node, **xargs)
+        xargs[:exception] = exception.class.name
+        report_node_error(exception.message, node, **xargs)
+      end
+
+      # A little helper to report an error on a given node
+      def report_node_error(message, node, **xargs)
+        node = node.instance_variable_get(:@node) if node.is_a?(Request::Component)
+        location = GraphQL::Native.get_location(node)
+
+        xargs[:locations] ||= location.to_errors unless xargs.key?(:line)
+        report_error(message, **xargs)
+      end
+
+      # The final helper that facilitates how errors are reported
+      def report_error(message, **xargs)
+        xargs[:path] ||= stack_to_path
+        errors.add(message, **xargs)
+      end
+
+      # Add the given +object+ into the execution +stack+ and execute the given
+      # +block+ making sure to rescue exceptions using the +rescue_with_handler+
+      def stacked(object, &block)
+        stack.unshift(object)
+        block.call
+      rescue => exception
+        rescue_with_handler(exception) || raise
+      ensure
+        stack.shift
+      end
+
+      # Convert the current stack into a error path ignoring the schema
+      def stack_to_path
+        stack[0..-2].map do |item|
+          item.is_a?(Numeric) ? item : item.try(:gql_name)
+        end.compact.reverse
+      end
+
+      # Add extensions to the request, which ensures a bunch of extended
+      # behaviors for all the objects created through the request
+      def extend(*modules)
+        import_extensions(*modules)
+        request_ext = extensions[self.class]
+        super(request_ext) if request_ext && !is_a?(request_ext)
+      end
+
+      # This initiates a new object which is aware of extensions
+      def build(klass, *args, &block)
+        ext_module = extensions[klass]
+        obj = klass.new(*args, &block)
+        obj.extend(ext_module) if ext_module
+        obj
+      end
+
+      # Get and cache a sanitized version of the arguments
+      def sanitized_arguments
+        return {} unless args.each_pair.any?
+        cache(:sanitized_arguments) do
+          args.to_h.transform_keys { |key| key.to_s.camelize(:lower) }
+        end
+      end
+
+      # A shared way to cache information across the execution of an request
+      def cache(key, init_value = nil, &block)
+        @cache[key] ||= (init_value || block&.call || {})
+      end
+
+      private
+
+        attr_reader :extensions
+
+        # Reset principal variables and set the given +args+
+        def reset!(args: nil, variables: {}, operation_name: nil)
+          @args    = build_ostruct(args || variables).freeze
+          @errors  = Request::Errors.new(self)
+          @visitor = GraphQL::Native::Visitor.new
+          @operation_name = operation_name
+
+          @stack      = [schema]
+          @cache      = {}
+          @fragments  = {}
+          @operations = {}
+        end
+
+        # This executes the whole process capturing any exceptions and handling
+        # them as defined by the schema
+        def execute!(document)
+          log_execution(document) do
+            @document = GraphQL::Native.parse(document)
+            collect_definitions!
+
+            @strategy = find_strategy!
+            @strategy.trigger_event(:request)
+            @strategy.resolve!
+          end
+        rescue ParseError => err
+          parts = err.message.match(/\A(\d+)\.(\d+)(?:-\d+)?: (.*)\z/)
+          errors.add(parts[3], line: parts[1], col: parts[2])
+        ensure
+          @cache.clear
+          @fragments.clear
+          @operations.clear
+
+          @visitor.terminate
+          @visitor = nil
+
+          GraphQL::Native.free_node(@document) if defined?(@document)
+          @response.try(:append_errors, errors)
+        end
+
+        # Use the visitor to collect the operations and fragments
+        def collect_definitions!
+          visitor.collect_definitions(@document) do |kind, node, data|
+            case kind
+            when :operation
+              operations[data[:name]] = Component::Operation.build(self, node, data)
+            when :fragment
+              fragments[data[:name]] = build(Component::Fragment, self, node, data)
+            end
+          end
+        end
+
+        # Find the best strategy to resolve the request
+        def find_strategy!
+          klass = schema.config.request_strategies.lazy.map(&:constantize).select do |k|
+            k.can_resolve?(self)
+          end.max_by(&:priority)
+          build(klass, self)
+        end
+
+        # Find all necessary extensions inside the given +modules+ and prepare
+        # the extension base module
+        def import_extensions(*modules)
+          modules.each do |mod|
+            mod.constants.each do |const_name|
+              const_name = const_name.to_s
+              const = mod.const_get(const_name)
+              next unless const.is_a?(Module)
+
+              # Find the related request class to extend
+              klass = const_name === 'Request' ? self.class : begin
+                const_name.split('_').inject(self.class) do |k, next_const|
+                  k.const_defined?(next_const) ? k.const_get(next_const) : break
+                end
+              end
+
+              # Create the shared module and include the extension
+              next unless klass&.is_a?(Class)
+              extensions[klass] ||= Module.new
+              extensions[klass].include(const)
+            end
+          end
+        end
+
+        # Log the execution of a GraphQL document
+        def log_execution(document)
+          ActiveSupport::Notifications.instrument('request.graphql') do |payload|
+            yield.tap { log_payload(document, payload) }
+          end
+        end
+
+        # Build the payload to be sent to the log
+        def log_payload(document, data)
+          name = @operation_name.presence
+          name ||= operations.keys.first if operations.size.eql?(1)
+          map_variables = args.to_h if args.each_pair.any?
+
+          data.merge!(
+            name: name,
+            cached: false,
+            document: document,
+            variables: map_variables,
+          )
+        end
+
+        # Initialize the class that responsible for storaging the response
+        def initialize_response(as_format, to)
+          raise ::ArgumentError, <<~MSG.squish if to.nil?
+            The given format #{as_format.inspect} is not a valid reponse format.
+          MSG
+
+          klass = schema.config.enable_string_collector \
+            ? Collectors::JsonCollector \
+            : Collectors::HashCollector
+
+          obj = klass.new(self)
+          raise ::ArgumentError, <<~MSG.squish unless obj.respond_to?(to)
+            Unable to use "#{klass.name}" as response collector since it does
+            not implement a #{to.inspect} method.
+          MSG
+
+          obj
+        end
+
+        # Little helper to build an +OpenStruct+ ensure the given +value+ is a
+        # +Hash+. It can also +transform_keys+ with the given block
+        def build_ostruct(value, &block)
+          raise ::ArgumentError, <<~MSG.squish unless value.is_a?(Hash)
+            The "#{value.class.name}" is not a valid hash.
+          MSG
+
+          value = value.deep_transform_keys(&block) if block.present?
+          OpenStruct.new(value)
+        end
+
+        # Make sure that a schema was assigned by find the corresponding one for
+        # the namespace of the request
+        def ensure_schema!
+          raise ::ArgumentError, <<~MSG.squish if schema.nil?
+            Unable to perform a request under the #{@namespace.inspect} namespace,
+            because there are no schema assigned to it.
+          MSG
+        end
+    end
+  end
+end