🎉 interator-sidekiq created.

Author: gabrielras

.github/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    - '*'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v1
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.0.3'
+          bundler-cache: true
+
+      - name: Rspec - Build and run tests
+        run: |
+          gem install bundler
+          bundle install --jobs 4 --retry 3
+          bundle exec rspec spec

.gitignore

@@ -0,0 +1,28 @@
+*.log
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version
+.ruby-gemset
+.idea
+.gs
+.byebug_history
+covarage

.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'bundler'
+gem 'rake'
+gem 'rspec'

LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2022, Gabriel Rocha
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,111 @@
+# Interactor::Sidekiq
+
+Provides [Interactor](https://github.com/collectiveidea/interactor) with asynchronous action using [Sidekiq](https://github.com/mperham/sidekiq).
+
+## Installation
+
+```ruby
+gem 'interactor-sidekiq', '~> 1.0'
+```
+
+## #async_call
+You can now add asynchronous behavior to both types of inetagents (basic interactors and organizers).
+
+```ruby
+class RegularAction
+  include Interactor
+
+  def call
+    { context: context.variable }
+  end
+end
+```
+With the above example we can already use **async_call**.
+
+```sh
+>> RegularAction.call(key: 'value')
+#<Interactor::Context key="value">
+>> Sidekiq::Queues.jobs_by_queue
+{}
+```
+```sh
+>> RegularAction.async_call(key: 'value')
+#<Interactor::Context key="value">
+>> Sidekiq::Queues.jobs_by_queue
+{"default"=>[{"retry"=>true, "queue"=>"default", "args"=>["{\"key\":\"value\",\"interactor_class\":\"RegularAction\"}"], "class"=>"Interactor::SidekiqWorker::Worker", "jid"=>"91a374e10e584b02cb84eec3", "created_at"=>1656283783.3459146, "enqueued_at"=>1656283783.3459556}]}
+```
+
+You can pass the **sidekiq_options** and **sidekiq_scheduling_options** to customize the behavior of the **async_call** method.
+
+#### Passing options from sidekiq
+
+To set custom [sidekiq_options] (https://github.com/mperham/sidekiq/wiki/Advanced-Options#workers) you can add `sidekiq_options` class method in your interactors - these options will be passed to Sidekiq `` set ` before scheduling the asynchronous worker.
+
+#### Passing scheduling options
+
+In order to be able to schedule jobs for future execution following [Scheduled Jobs](https://github.com/mperham/sidekiq/wiki/Scheduled-Jobs), you can add the `sidekiq_schedule_options` class method in your subscriber definition - these options will be passed to Sidekiq's `perform_in` method when the worker is called.
+
+```sh
+>> RegularAction.async_call(message: 'hello!', sidekiq_options: { queue: :low_priority }, sidekiq_schedule_options: { perform_in: 5 })
+
+Interactor::Context message: 'hello!', sidekiq_options: { queue: :low_priority }, sidekiq_schedule_options: { perform_in: 5 }
+```
+
+## Failure
+
+If you pass invalid parameters to sidekiq, you will get an immediate return with the error message.
+```sh
+>> result = RegularAction.async_call(message: 'hello!', sidekiq_schedule_options: "error")
+#<Interactor::Context key="value", sidekiq_options="bad error message", error="undefined method `transform_keys' for \"bad error message\":String">
+>> result.failure?
+true
+>> Sidekiq::Queues.jobs_by_queue
+{}
+```
+
+## Interactor::Async
+
+Now you need an interactor to always assume asynchronous behavior using: **Interator::Async**.
+
+#### Passing handle sidekiq exception
+
+When executing the perform method in sidekiq there may be a problem, thinking about it we have already made it possible for you to handle this error.
+**If the context is failed during invocation of the interactor in background, the Interactor::Failure is raised**.
+
+
+```ruby
+class AsyncAction
+  include Interactor::Async
+
+  def call
+    { context: context.variable }
+  end
+
+  def self.sidekiq_options
+    { queue: :low_priority }
+  end
+    
+  def self.sidekiq_schedule_options
+    { perform_in: 5 }
+  end
+  
+  def self.handle_sidekiq_exception(error)
+    # Integrate with Application Monitoring and Error Tracking Software
+  end
+end
+```
+
+## Compatibility
+
+The same Ruby versions as Sidekiq are offically supported, but it should work
+with any 2.x syntax Ruby including JRuby and Rubinius.
+
+## Running Specs
+
+```
+bundle exec rspec
+```
+
+## License
+
+MIT

Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

interactor-sidekiq.gemspec

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'interactor/sidekiq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'interactor-sidekiq'
+  spec.version       = Interactor::Sidekiq::VERSION
+  spec.authors       = ['Gabriel Rocha']
+  spec.email         = ['[email protected]']
+  spec.summary       = 'Async Interactor using Sidekiq'
+  spec.description   = 'Async Interactor using Sidekiq'
+  spec.homepage      = 'https://github.com/gabrielras/interactor-sidekiq'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'interactor', '~> 3.0'
+  spec.add_dependency 'sidekiq', '>=4.1'
+end

lib/interactor/sidekiq.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'interactor'
+require 'sidekiq'
+
+module Interactor
+  # Internal: Install Interactor's behavior in the given class.
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      extend SidekiqWorker
+      include Hooks
+
+      # Public: Gets the Interactor::Context of the Interactor instance.
+      attr_reader :context
+    end
+  end
+
+  # based on Sidekiq 4.x #delay method, which is not enabled by default in Sidekiq 5.x
+  # https://github.com/mperham/sidekiq/blob/4.x/lib/sidekiq/extensions/generic_proxy.rb
+  # https://github.com/mperham/sidekiq/blob/4.x/lib/sidekiq/extensions/class_methods.rb
+
+  module SidekiqWorker
+    class Worker
+      include ::Sidekiq::Worker
+
+      def perform(context)
+        interactor_class(context).sync_call(context.except(:interactor_class))
+      rescue Exception => e
+        if interactor_class(context).respond_to?(:handle_sidekiq_exception)
+          interactor_class(context).handle_sidekiq_exception(e)
+        else
+          raise e
+        end
+      end
+
+      private
+
+      def interactor_class(context)
+        Module.const_get context[:interactor_class]
+      end
+    end
+
+    def sync_call(context = {})
+      new(context).tap(&:run!).context
+    end
+
+    def async_call(context = {})
+      options = handle_sidekiq_options(context)
+      schedule_options = delay_sidekiq_schedule_options(context)
+
+      Worker.set(options).perform_in(schedule_options.fetch(:delay, 0), handle_context_for_sidekiq(context))
+      new(context.to_h).context
+    rescue Exception => e
+      begin
+        new(context.to_h).context.fail!(error: e.message)
+      rescue Failure => e
+        e.context
+      end
+    end
+
+    private
+
+    def handle_context_for_sidekiq(context)
+      context.to_h.merge(interactor_class: to_s).to_json
+    end
+
+    def handle_sidekiq_options(context)
+      if context[:sidekiq_options].nil?
+        respond_to?(:sidekiq_options) ? sidekiq_options : { queue: :default }
+      else
+        context[:sidekiq_options]
+      end
+    end
+
+    def delay_sidekiq_schedule_options(context)
+      options = handle_sidekiq_schedule_options(context)
+      return {} unless options.key?(:perform_in) || options.key?(:perform_at)
+
+      { delay: options[:perform_in] || options[:perform_at] }
+    end
+
+    def handle_sidekiq_schedule_options(context)
+      if context[:sidekiq_schedule_options].nil?
+        respond_to?(:sidekiq_schedule_options) ? sidekiq_schedule_options : { delay: 0 }
+      else
+        context[:sidekiq_schedule_options]
+      end
+    end
+  end
+
+  module Async
+    def self.included(base)
+      base.class_eval do
+        include Interactor
+
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def call(context = {})
+        default_async_call(context)
+      end
+
+      def call!(context = {})
+        default_async_call(context)
+      end
+
+      private
+
+      def default_async_call(context)
+        async_call(context)
+      end
+    end
+  end
+end

lib/interactor/sidekiq/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Interactor
+  module Sidekiq
+    VERSION = '1.0.0'
+  end
+end