rails-graphql 0.2.0 → 1.0.0.beta

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Base Generator
     #
     # A module to help generators to operate
@@ -22,13 +22,7 @@ module Rails # :nodoc:
 
         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)
+          Rails.application.class.name.chomp('::Application')
         end
     end
   end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    # = GraphQL Channel
+    #
+    # The channel helper methods that allow GraphQL to be performed on an
+    # Action Cable channel. It also provides structure fro working with
+    # subscriptions
+    module Channel
+      extend ActiveSupport::Concern
+
+      included do
+        # Each channel 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
+
+        # Set it up a callback after unsubscribed so that all the subscriptions
+        # can be properly unsubscribed
+        after_unsubscribe :gql_clear_subscriptions
+      end
+
+      # The default action of the helper to perform GraphQL requests. Any other
+      # action cab be added and use the granular methods here provided
+      def execute(data)
+        transmit(gql_request_response(data))
+      end
+
+      protected
+
+        # Identifies if the received request within +data+ should be threated as
+        # a compiled request
+        def gql_compiled_request?(*)
+          false
+        end
+
+        # Get the response of a request withing the given +data+
+        def gql_request_response(data)
+          xargs = gql_params(data)
+          schema, context, query = xargs.extract!(:schema, :context, :query).values
+
+          request = gql_request(schema)
+          request.context = context
+          request.execute(query, **xargs)
+
+          gql_merge_subscriptions(request)
+          gql_response(request)
+        end
+
+        # Merge the subscriptions in this channel and the ones that were added
+        # by the last request
+        def gql_merge_subscriptions(request)
+          gql_subscriptions.merge!(request.subscriptions)
+        end
+
+        # Properly format the response of the provided +request+ so it can be
+        # transmitted
+        def gql_response(request)
+          { result: request.response.as_json, more: request.subscriptions? }
+        end
+
+        # Build the necessary params from the provided data
+        def gql_params(data)
+          cache_key = gql_query_cache_key(
+            data['query_cache_key'],
+            data['query_cache_version'],
+          )
+
+          {
+            query: data['query'],
+            origin: self,
+            variables: gql_variables(data),
+            operation_name: data['operation_name'] || data['operationName'],
+            compiled: gql_compiled_request?(data),
+            context: gql_context(data),
+            schema: gql_schema(data),
+            hash: cache_key,
+            as: :hash,
+          }
+        end
+
+        # The list of ids of subscription and to which field they are
+        # associated with
+        def gql_subscriptions
+          @gql_subscriptions ||= {}
+        end
+
+        # The instance of a GraphQL request. It can't simply perform using
+        # +execute+, because it is important to check if any subscription was
+        # generated
+        def gql_request(schema = gql_schema)
+          @gql_request ||= ::Rails::GraphQL::Request.new(schema)
+        end
+
+        # Get the cache key of the query for persisted queries
+        def gql_query_cache_key(key = nil, version = nil)
+          CacheKey.new(key, version) if key.present?
+        end
+
+        # The schema on which the requests will be performed from
+        def gql_schema(*)
+          schema = self.class.gql_schema
+          schema = schema.constantize if schema.is_a?(String)
+          schema ||= gql_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 context for a requests
+        # +ActionCable::Channel::Base#extract_action+
+        def gql_context(data)
+          { action: (data['action'] || :receive).to_sym }
+        end
+
+        # Get the GraphQL variables for a request
+        def gql_variables(data)
+          variables = data['variables']
+
+          case variables
+          when ::ActionController::Parameters then variables.permit!.to_h
+          when String then variables.present? ? JSON.parse(variables) : {}
+          when Hash   then variables
+          else {}
+          end
+        end
+
+        # Remove all subscriptions
+        def gql_clear_subscriptions
+          gql_remove_subscription(*gql_subscriptions.keys) unless gql_subscriptions.empty?
+        end
+
+        # Remove one or more subscriptions
+        def gql_remove_subscriptions(*sids)
+          gql_schema.remove_subscriptions(*sids)
+        end
+
+        alias gql_remove_subscription gql_remove_subscriptions
+
+      private
+
+        # Find the default application schema
+        def gql_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.public_send(source_name)}Schema".constantize
+          self.class.gql_schema = klass
+        end
+    end
+  end
+end

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

@@ -1,15 +1,22 @@
 # 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
@@ -24,10 +31,7 @@ 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
 
       protected
@@ -37,23 +41,46 @@ module Rails # :nodoc:
           render json: gql_request(*args, **xargs)
         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
+
         # 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}")))
+          request_xargs = REQUEST_XARGS.each_with_object({}) do |setting, result|
+            result[setting] ||= (xargs[setting] || send(:"gql_#{setting}"))
           end
 
+          request_xargs[:hash] ||= gql_query_cache_key
+          request_xargs[:origin] ||= self
+
+          request_xargs = request_xargs.except(*%i[query_cache_key query_cache_version])
           ::Rails::GraphQL::Request.execute(query, **request_xargs)
         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
+
         # 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
@@ -64,9 +91,15 @@ module Rails # :nodoc:
           params[:query]
         end
 
+        # 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 +117,28 @@ module Rails # :nodoc:
           end
         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
+        def gql_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
+          klass = "::GraphQL::#{app_class.public_send(source_name)}Schema".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,33 @@ module Rails # :nodoc:
       # the spread and operation.
       class Arguments < OpenStruct
         THREAD_KEY = :_rails_graphql_operation
-        LAZY_LOADER = ->(key, object) { object.variables[key] }.curry
+
+        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
 
         class << self
           # Easy access to the easy loader method
           def lazy
-            LAZY_LOADER
+            Lazy
           end
 
           # Get the current operation thread safely
@@ -42,50 +61,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