add an ability to deliver messages asynchronously via adapters

Author: prog-supdex

README.md

@@ -337,6 +337,34 @@ Or you can use `collect`
   end
 ```
 
+## Async delivering messages
+
+If you use `Rails` application or you use `ActiveJob`, you can deliver messages using `ActiveJob`
+
+### Configuration
+
+You have the next configuration
+
+```ruby
+  GraphQL::AnyCable.configure do |config|
+    # ... other configurations
+    config.delivery_method = "inline" # the default value "inline", also can be "active_job"
+    config.queue = "default" # the name of ActiveJob queue
+    config.job_class = "GraphQL::Jobs::TriggerJob" # the name executor job
+  end
+```
+
+`delivery_method` can be either `inline` or `active_job`.
+`inline` means that delivering messaging will work sync.
+`active_job` - It will add delivering messages operations to `ActiveJob` with queue `default` and using job `GraphQL::Jobs::TriggerJob`
+
+You can change the queue or job_class by changing it in the configuration
+
+Or you can run code
+
+```ruby
+  GraphQL::AnyCable.delivery_method = "active_job", { queue: "broadcasting", job_class: "GraphQL::Jobs::TriggerJob" }
+```
 
 ## Testing applications which use `graphql-anycable`
 

graphql-anycable.gemspec

@@ -37,4 +37,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "railties"
   spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "activejob", "~> 6.0"
 end

lib/graphql-anycable.rb

@@ -7,6 +7,7 @@
 require_relative "graphql/anycable/config"
 require_relative "graphql/anycable/railtie" if defined?(Rails)
 require_relative "graphql/anycable/stats"
+require_relative "graphql/anycable/delivery_adapter"
 require_relative "graphql/subscriptions/anycable_subscriptions"
 
 module GraphQL
@@ -25,6 +26,19 @@ def self.stats(**options)
       Stats.new(**options).collect
     end
 
+    def self.delivery_method=(args)
+      method_name, options = Array(args)
+      options ||= {}
+
+      config.delivery_method = method_name
+      config.queue = options[:queue] if options[:queue]
+      config.job_class = options[:job_class] if options[:job_class]
+    end
+
+    def self.delivery_adapter(object)
+      DeliveryAdapter.lookup(executor_object: object)
+    end
+
     module_function
 
     def redis

lib/graphql/adapters/active_job_adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Adapters
+    class ActiveJobAdapter < BaseAdapter
+      def trigger(...)
+        executor_class_job.set(queue: config.queue).perform_later(
+          executor_object,
+          executor_method,
+          ...
+        )
+      end
+
+      private
+
+      def executor_class_job
+        config.job_class.constantize
+      end
+
+      def config
+        GraphQL::AnyCable.config
+      end
+    end
+  end
+end

lib/graphql/adapters/base_adapter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Adapters
+    class BaseAdapter
+      attr_reader :executor_object, :executor_method
+
+      def initialize(executor_object:)
+        @executor_object = executor_object
+        @executor_method = executor_object.class::EXECUTOR_METHOD_NAME
+      end
+
+      def trigger
+        raise NoMethodError, "#{__method__} method should be implemented in concrete class"
+      end
+    end
+  end
+end

lib/graphql/adapters/inline_adapter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Adapters
+    class InlineAdapter < BaseAdapter
+      def trigger(...)
+        executor_object.public_send(executor_method, ...)
+      end
+    end
+  end
+end

lib/graphql/anycable/config.rb

@@ -12,6 +12,38 @@ class Config < Anyway::Config
       attr_config use_redis_object_on_cleanup: true
       attr_config use_client_provided_uniq_id: true
       attr_config redis_prefix: "graphql" # Here, we set clear redis_prefix without any hyphen. The hyphen is added at the end of this value on our side.
+
+      attr_config delivery_method: "inline", queue: "default", job_class: "GraphQL::Jobs::TriggerJob"
+
+      def job_class=(value)
+        ensure_value_is_not_blank!("job_class", value)
+
+        super
+      end
+
+      def queue=(value)
+        ensure_value_is_not_blank!("queue", value)
+
+        super
+      end
+
+      def delivery_method=(value)
+        ensure_value_is_not_blank!("delivery_method", value)
+
+        super
+      end
+
+      private
+
+      def empty_value?(value)
+        value.nil? || value == ""
+      end
+
+      def ensure_value_is_not_blank!(name, value)
+        return unless empty_value?(value)
+
+        raise_validation_error("#{name} can not be blank")
+      end
     end
   end
 end

lib/graphql/anycable/delivery_adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "graphql/adapters/base_adapter"
+require "graphql/adapters/inline_adapter"
+require "graphql/adapters/active_job_adapter"
+
+module GraphQL
+  module AnyCable
+    class DeliveryAdapter
+      class << self
+        def lookup(options)
+          adapter_class_name = config.delivery_method.to_s.split("_").map(&:capitalize).join
+
+          Adapters.const_get("#{adapter_class_name}Adapter").new(**(options || {}))
+        rescue NameError => e
+          raise e.class, "Delivery adapter :#{config.delivery_method} haven't been found", e.backtrace
+        end
+
+        def config
+          GraphQL::AnyCable.config
+        end
+      end
+    end
+  end
+end

lib/graphql/anycable/railtie.rb

@@ -5,6 +5,15 @@
 module GraphQL
   module AnyCable
     class Railtie < ::Rails::Railtie
+      initializer "graphql_anycable.load_trigger_job" do
+        ActiveSupport.on_load(:active_job) do
+          require "graphql/jobs/trigger_job"
+          require "graphql/serializers/anycable_subscription_serializer"
+
+          ActiveJob::Serializers.add_serializers(GraphQL::Serializers::AnyCableSubscriptionSerializer)
+        end
+      end
+
       rake_tasks do
         path = File.expand_path(__dir__)
         Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }

lib/graphql/jobs/trigger_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Jobs
+    class TriggerJob < ActiveJob::Base
+      def perform(executor_object, execute_method, event_name, args = {}, object = nil, options = {})
+        executor_object.public_send(execute_method, event_name, args, object, **options)
+      end
+    end
+  end
+end