esse-async_indexing 0.0.2 → 0.1.0.rc1

data/lib/esse/async_indexing/cli.rb

@@ -13,20 +13,34 @@ Esse::CLI::Index.class_eval do
   option :suffix, type: :string, default: nil, aliases: "-s", desc: "Suffix to append to index name"
   option :context, type: :hash, default: {}, required: true, desc: "List of options to pass to the index class"
   option :service, type: :string, default: nil, alias: "-s", desc: "Service to use for async import: sidekiq, faktory"
-  option :eager_include_document_attributes, type: :string, default: nil, desc: "Comma separated list of lazy document attributes to include to the bulk index request. Or pass `true` to include all lazy attributes"
-  option :lazy_update_document_attributes, type: :string, default: nil, desc: "Comma separated list of lazy document attributes to bulk update after the bulk index request Or pass `true` to include all lazy attributes"
+  option :preload_lazy_attributes, type: :string, default: nil, desc: "Command separated list of lazy document attributes to preload using search API before the bulk import. Or pass `true` to preload all lazy attributes"
+  option :eager_load_lazy_attributes, type: :string, default: nil, desc: "Comma separated list of lazy document attributes to include to the bulk index request. Or pass `true` to include all lazy attributes"
+  option :update_lazy_attributes, type: :string, default: nil, desc: "Comma separated list of lazy document attributes to bulk update after the bulk index request Or pass `true` to include all lazy attributes"
+  option :enqueue_lazy_attributes, type: :boolean, default: nil, desc: "Enqueue the lazy document attributes job after the bulk import. (default: true))"
+  option :job_options, type: :hash, default: {}, desc: "List of options to pass to the background job. (Example: --job-options=queue:default)"
   def async_import(*index_classes)
     opts = Esse::HashUtils.deep_transform_keys(options.to_h, &:to_sym)
     opts[:service] ||= Esse.config.async_indexing.services.first
-    opts.delete(:lazy_update_document_attributes) if opts[:lazy_update_document_attributes] == "false"
-    opts.delete(:eager_include_document_attributes) if opts[:eager_include_document_attributes] == "false"
-    if (val = opts[:eager_include_document_attributes])
-      opts[:eager_include_document_attributes] = (val == "true") ? true : val.split(",")
-    end
-    if (val = opts[:lazy_update_document_attributes])
-      opts[:lazy_update_document_attributes] = (val == "true") ? true : val.split(",")
+    %i[preload_lazy_attributes eager_load_lazy_attributes update_lazy_attributes].each do |key|
+      if (val = opts.delete(key)) && val != "false"
+        opts[key] = (val == "true") ? true : val.split(",")
+      end
     end
     require "esse/async_indexing/cli/async_import"
     Esse::AsyncIndexing::CLI::AsyncImport.new(indices: index_classes, **opts).run
   end
+
+  desc "async_update_lazy_attributes INDEX_CLASS", "Async update lazy attributes for the given index"
+  option :repo, type: :string, default: nil, alias: "-r", desc: "Repository to use for import"
+  option :suffix, type: :string, default: nil, aliases: "-s", desc: "Suffix to append to index name"
+  option :context, type: :hash, default: {}, required: true, desc: "List of options to pass to the index class"
+  option :service, type: :string, default: nil, alias: "-s", desc: "Service to use for async import: sidekiq, faktory"
+  option :job_options, type: :hash, default: {}, desc: "List of options to pass to the background job. (Example: --job-options=queue:default)"
+  def async_update_lazy_attributes(index_class, *attributes)
+    opts = Esse::HashUtils.deep_transform_keys(options.to_h, &:to_sym)
+    opts[:service] ||= Esse.config.async_indexing.services.first
+    require "esse/async_indexing/cli/async_update_lazy_attributes"
+
+    Esse::AsyncIndexing::CLI::AsyncUpdateLazyAttributes.new(indices: [index_class], attributes: attributes, **opts).run
+  end
 end

data/lib/esse/async_indexing/config.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "configuration"
-require_relative "configuration/base"
-require_relative "configuration/faktory"
-require_relative "configuration/sidekiq"
 
 module Esse
   module AsyncIndexing

data/lib/esse/async_indexing/configuration.rb

@@ -17,29 +17,65 @@ module Esse
         @services ||= ConfigService.new
       end
 
-      def faktory
-        @faktory ||= begin
-          services.add(:faktory)
-          Configuration::Faktory.new
-        end
-        if block_given?
-          yield @faktory
-        else
-          @faktory
-        end
+      def reset!
+        @services = nil
+        @tasks = nil
+        bg_job_config.reset!
       end
 
-      def sidekiq
-        @sidekiq ||= begin
-          services.add(:sidekiq)
-          Configuration::Sidekiq.new
+      BackgroundJob::SERVICES.each_key do |service|
+        define_method(service) do |&block|
+          config_for(service, &block)
         end
-        if block_given?
-          yield @sidekiq
-        else
-          @sidekiq
+      end
+
+      def config_for(service)
+        case service.to_sym
+        when :faktory
+          conf = bg_job_config.faktory
+          unless services.faktory?
+            default_jobs.each { |job_class| conf.jobs[job_class] ||= {} }
+            services << :faktory
+          end
+          yield conf if block_given?
+          conf
+        when :sidekiq
+          conf = bg_job_config.sidekiq
+          unless services.sidekiq?
+            default_jobs.each { |job_class| conf.jobs[job_class] ||= {} }
+            services << :sidekiq
+          end
+          yield conf if block_given?
+          conf
+        else raise ArgumentError, "Unknown service: #{service}"
         end
       end
+
+      def tasks
+        @tasks ||= Esse::AsyncIndexing::Tasks.new
+      end
+
+      # DSL to define custom job enqueueing
+      #
+      # task(:import) do |service:, repo:, operation:, ids:, **kwargs|
+      #   MyCustomJob.perform_later(repo.index.name, ids, **kwargs)
+      # end
+      # task(:index, :update, :delete) do |service:, repo:, operation:, id, **kwargs|
+      #   MyCustomJob.perform_later(repo.index.name, [id], **kwargs)
+      # end
+      def task(*operations, &block)
+        tasks.define(*operations, &block)
+      end
+
+      private
+
+      def bg_job_config
+        BackgroundJob.config
+      end
+
+      def default_jobs
+        Esse::AsyncIndexing::Jobs::DEFAULT.values
+      end
     end
   end
 end

data/lib/esse/async_indexing/jobs/bulk_update_lazy_attribute_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Esse::AsyncIndexing::Jobs::BulkUpdateLazyAttributeJob
+  def perform(index_class_name, repo_name, attribute_name, ids, options = {})
+    Esse::AsyncIndexing::Actions::BulkUpdateLazyAttribute.call(index_class_name, repo_name, attribute_name, ids, options)
+  end
+end

data/lib/esse/async_indexing/jobs/import_all_job.rb

@@ -2,6 +2,6 @@
 
 class Esse::AsyncIndexing::Jobs::ImportAllJob
   def perform(index_class_name, repo_name, options = {})
-    Esse::AsyncIndexing::Actions::BatchImportAll.call(index_class_name, repo_name, options)
+    Esse::AsyncIndexing::Actions::BulkImportAll.call(index_class_name, repo_name, options)
   end
 end

data/lib/esse/async_indexing/jobs/import_ids_job.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Esse::AsyncIndexing::Jobs::ImportIdsJob
+  def perform(index_class_name, repo_name, ids, options = {})
+    # This is specific to the AsyncIndexing plugin, can't pass to Esse import method
+    enqueue_lazy = options.delete(:enqueue_lazy_attributes) if options.key?(:enqueue_lazy_attributes)
+    enqueue_lazy = options.delete("enqueue_lazy_attributes") if options.key?("enqueue_lazy_attributes")
+    enqueue_lazy = true if enqueue_lazy.nil?
+    total = Esse::AsyncIndexing::Actions::BulkImport.call(index_class_name, repo_name, ids, options)
+    options = Esse::HashUtils.deep_transform_keys(options, &:to_s)
+
+    return total if total.zero?
+    return total unless enqueue_lazy
+    return total if lazy_already_imported?(options)
+    return total unless self.class.respond_to?(:background_job_service)
+
+    index_class, repo_class = Esse::AsyncIndexing::Actions::CoerceIndexRepository.call(index_class_name, repo_name)
+    return total unless Esse::AsyncIndexing.plugin_installed?(index_class)
+
+    repo_class.lazy_document_attributes.each_key do |attr_name|
+      repo_class.async_indexing_job_for(:update_lazy_attribute).call(
+        **options,
+        service: self.class.background_job_service,
+        repo: repo_class,
+        operation: :update_lazy_attribute,
+        attribute: attr_name,
+        ids: ids
+      )
+    end
+    total
+  end
+
+  protected
+
+  # The `import` action already eager or lazy load the document attributes when some of these options are set.
+  def lazy_already_imported?(options)
+    preload = options.delete("preload_lazy_attributes") || false
+    eager = options.delete("eager_load_lazy_attributes") || false
+    lazy = options.delete("update_lazy_attributes") || false
+    preload || eager || lazy
+  end
+end

data/lib/esse/async_indexing/{workers.rb → jobs.rb}

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "worker"
-
 module Esse
   module AsyncIndexing
-    module Workers
+    module Jobs
       DEFAULT = {
-        "esse/async_indexing/jobs/bulk_update_lazy_document_attribute_job" => "Esse::AsyncIndexing::Jobs::BulkUpdateLazyDocumentAttributeJob",
+        "esse/async_indexing/jobs/bulk_update_lazy_attribute_job" => "Esse::AsyncIndexing::Jobs::BulkUpdateLazyAttributeJob",
         "esse/async_indexing/jobs/document_delete_by_id_job" => "Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob",
         "esse/async_indexing/jobs/document_index_by_id_job" => "Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob",
         "esse/async_indexing/jobs/document_update_by_id_job" => "Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob",
         "esse/async_indexing/jobs/document_upsert_by_id_job" => "Esse::AsyncIndexing::Jobs::DocumentUpsertByIdJob",
         "esse/async_indexing/jobs/import_all_job" => "Esse::AsyncIndexing::Jobs::ImportAllJob",
-        "esse/async_indexing/jobs/import_batch_id_job" => "Esse::AsyncIndexing::Jobs::ImportBatchIdJob",
-        "esse/async_indexing/jobs/update_lazy_document_attribute_job" => "Esse::AsyncIndexing::Jobs::UpdateLazyDocumentAttributeJob"
-      }
+        "esse/async_indexing/jobs/import_ids_job" => "Esse::AsyncIndexing::Jobs::ImportIdsJob"
+      }.freeze
 
       # The backend service may live in a different application, so they are not required by default.
       # That's why we have a separate structure to let enqueue jobs even without having the explicit worker class loaded.
@@ -22,27 +19,13 @@ module Esse
       def self.install!(service, **options)
         return if @installed_services&.include?(service.to_sym)
 
-        DEFAULT.each do |job, worker_name|
+        DEFAULT.each do |job, const_name|
           Kernel.require(job)
-          worker = Esse::AsyncIndexing::Jobs.const_get(worker_name.split("::").last)
-          worker.extend(self.for(service, **options))
+          klass = Esse::AsyncIndexing::Jobs.const_get(const_name.split("::").last)
+          klass.extend BackgroundJob.mixin(service, **options)
         end
         @installed_services = Array(@installed_services) << service.to_sym
       end
-
-      def self.for(service, **options)
-        require_relative "workers/#{service}"
-        service = service.to_sym
-        worker_options = options.merge(service: service)
-        module_name = service.to_s.split(/_/i).collect! { |w| w.capitalize }.join
-        mod = Esse::AsyncIndexing::Workers.const_get(module_name)
-        mod.module_eval do
-          define_method(:bg_worker_options) do
-            worker_options
-          end
-        end
-        mod
-      end
     end
   end
 end

data/lib/esse/async_indexing/tasks.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Esse
+  module AsyncIndexing
+    class Tasks
+      DEFAULT = {
+        import: ->(service:, repo:, operation:, ids:, job_options: {}, **kwargs) {
+          unless (ids = Esse::ArrayUtils.wrap(ids)).empty?
+            BackgroundJob.job(service, "Esse::AsyncIndexing::Jobs::ImportIdsJob", **job_options)
+              .with_args(repo.index.name, repo.repo_name, ids, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
+              .push
+          end
+        },
+        index: ->(service:, repo:, operation:, id:, job_options: {}, **kwargs) {
+          if id
+            BackgroundJob.job(service, "Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob", **job_options)
+              .with_args(repo.index.name, repo.repo_name, id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
+              .push
+          end
+        },
+        update: ->(service:, repo:, operation:, id:, job_options: {}, **kwargs) {
+          if id
+            BackgroundJob.job(service, "Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob", **job_options)
+              .with_args(repo.index.name, repo.repo_name, id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
+              .push
+          end
+        },
+        delete: ->(service:, repo:, operation:, id:, job_options: {}, **kwargs) {
+          if id
+            BackgroundJob.job(service, "Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob", **job_options)
+              .with_args(repo.index.name, repo.repo_name, id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
+              .push
+          end
+        },
+        update_lazy_attribute: ->(service:, repo:, operation:, attribute:, ids:, job_options: {}, **kwargs) {
+          unless (ids = Esse::ArrayUtils.wrap(ids)).empty?
+            BackgroundJob.job(service, "Esse::AsyncIndexing::Jobs::BulkUpdateLazyAttributeJob", **job_options)
+              .with_args(repo.index.name, repo.repo_name, attribute.to_s, ids, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
+              .push
+          end
+        }
+      }.freeze
+
+      def initialize
+        @tasks = {}.freeze
+      end
+
+      def user_defined?(name)
+        @tasks.key?(name.to_sym)
+      end
+
+      def define(*names, &block)
+        names = DEFAULT.keys if names.empty?
+        validate!(names, block)
+        new_tasks = names.each_with_object({}) { |name, h| h[name.to_sym] = block }
+        @tasks = @tasks.dup.merge(new_tasks)
+      ensure
+        @tasks.freeze
+      end
+
+      def fetch(name)
+        id = name.to_sym
+        @tasks[id] || DEFAULT[id] || raise(ArgumentError, "Unknown task: #{name}")
+      end
+      alias_method :[], :fetch
+
+      private
+
+      def validate!(names, block)
+        unless block.is_a?(Proc)
+          raise ArgumentError, "The block of task must be a callable object"
+        end
+
+        names.each do |name|
+          unless DEFAULT.key?(name)
+            raise ArgumentError, "Unrecognized task: #{name}. Valid tasks are: #{DEFAULT.keys}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/esse/async_indexing/version.rb

@@ -2,6 +2,6 @@
 
 module Esse
   module AsyncIndexing
-    VERSION = "0.0.2"
+    VERSION = "0.1.0.rc1"
   end
 end

data/lib/esse/async_indexing.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require "esse"
-require "esse-redis_storage"
 require "forwardable"
 require "securerandom"
 require "time"
 require "multi_json"
+require "background_job"
 
 module Esse
   module AsyncIndexing
@@ -14,32 +14,24 @@ module Esse
 
     module Jobs
     end
-
-    module Workers
-    end
   end
 end
 
 require_relative "async_indexing/version"
 require_relative "async_indexing/actions"
-require_relative "async_indexing/adapters"
 require_relative "async_indexing/config"
+require_relative "async_indexing/tasks"
 require_relative "async_indexing/errors"
-require_relative "async_indexing/workers"
+require_relative "async_indexing/jobs"
 require_relative "plugins/async_indexing"
 
 module Esse::AsyncIndexing
-  SERVICES = {
-    sidekiq: Adapters::Sidekiq,
-    faktory: Adapters::Faktory
-  }
-
   # @param worker_class [String] The worker class name
   # @param options [Hash] Options that will be passed along to the worker instance
   # @return [Esse::AsyncIndexing::Worker] An instance of worker
-  def self.worker(worker_class, service: nil, **options)
+  def self.worker(worker_class, service:, **options)
     serv_name = service_name(service)
-    Worker.new(worker_class, **Esse.config.async_indexing.send(service).worker_options(worker_class).merge(options), service: serv_name)
+    BackgroundJob.job(serv_name, worker_class, **options)
   end
 
   def self.service_name(identifier = nil)
@@ -47,26 +39,29 @@ module Esse::AsyncIndexing
     if identifier.nil?
       raise ArgumentError, "There are no async indexing services configured. Please configure at least one service or pass the service name as an argument."
     end
-
-    if SERVICES[identifier.to_sym].nil?
-      raise ArgumentError, "Invalid service: #{identifier.inspect}, valid services are: #{SERVICES.keys.join(", ")}"
+    unless (services = BackgroundJob::SERVICES).key?(identifier.to_sym)
+      raise ArgumentError, "Invalid service: #{identifier.inspect}, valid services are: #{services.keys.join(", ")}"
     end
 
     identifier.to_sym
   end
 
-  def self.jid
-    SecureRandom.hex(12)
-  end
-
   def self.async_indexing_repo?(repo)
     return false unless repo.is_a?(Class) && repo < Esse::Repository
 
     repo.respond_to?(:implement_batch_ids?) && repo.implement_batch_ids?
   end
+
+  def self.plugin_installed?(index)
+    index = index.index if index.is_a?(Class) && index < Esse::Repository
+    return false unless index.is_a?(Class) && index < Esse::Index
+
+    index.plugins.include?(Esse::Plugins::AsyncIndexing)
+  end
 end
 
 Esse::Config.__send__ :include, Esse::AsyncIndexing::Config
+
 if defined?(Esse::CLI)
   require_relative "async_indexing/cli"
 end

data/lib/esse/plugins/async_indexing.rb

@@ -4,48 +4,23 @@ module Esse
   module Plugins
     module AsyncIndexing
       module RepositoryClassMethods
-        DEFAULT_ASYNC_INDEXING_JOBS = {
-          import: ->(service:, repo:, operation:, ids:, **kwargs) {
-            unless (ids = Esse::ArrayUtils.wrap(ids)).empty?
-              batch_id = Esse::RedisStorage::Queue.for(repo: repo).enqueue(values: ids)
-              Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::ImportBatchIdJob", service: service)
-                .with_args(repo.index.name, repo.repo_name, batch_id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
-                .push
-            end
-          },
-          index: ->(service:, repo:, operation:, id:, **kwargs) {
-            if id
-              Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob", service: service)
-                .with_args(repo.index.name, repo.repo_name, id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
-                .push
-            end
-          },
-          update: ->(service:, repo:, operation:, id:, **kwargs) {
-            if id
-              Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob", service: service)
-                .with_args(repo.index.name, repo.repo_name, id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
-                .push
-            end
-          },
-          delete: ->(service:, repo:, operation:, id:, **kwargs) {
-            if id
-              Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob", service: service)
-                .with_args(repo.index.name, repo.repo_name, id, Esse::HashUtils.deep_transform_keys(kwargs, &:to_s))
-                .push
-            end
-          }
-        }.freeze
-
         # This method is used to retrieve only the ids of the documents in the collection.
         # It's used to asynchronously index the documents.
         # The #each_batch_ids method is optional and should be implemented by the collection class.
         #
+        # @yield [batch] Yields each batch of ids
         # @return [Enumerator] The enumerator
-        def batch_ids(*args, **kwargs, &block)
+        def batch_ids(*args, **kwargs)
           if implement_batch_ids?
-            Enumerator.new do |yielder|
+            if block_given?
               @collection_proc.new(*args, **kwargs).each_batch_ids do |batch|
-                yielder.yield(batch)
+                yield(batch)
+              end
+            else
+              Enumerator.new do |yielder|
+                @collection_proc.new(*args, **kwargs).each_batch_ids do |batch|
+                  yielder.yield(batch)
+                end
               end
             end
           else
@@ -70,35 +45,19 @@ module Esse
         #   MyCustomJob.perform_later(repo.index.name, [id], **kwargs)
         # end
         def async_indexing_job(*operations, &block)
-          operations = AsyncIndexingJobValidator::OPERATIONS if operations.empty?
-          AsyncIndexingJobValidator.call(operations, block)
-          hash = operations.each_with_object({}) { |operation, h| h[operation] = block }
-          @async_indexing_jobs = async_indexing_jobs.dup.merge(hash)
-        ensure
-          @async_indexing_jobs.freeze
+          definer = @async_indexing_tasks || Esse::AsyncIndexing::Tasks.new
+          definer.define(*operations, &block)
+          @async_indexing_tasks = definer
         end
 
-        def async_indexing_jobs
-          @async_indexing_jobs || {}.freeze
-        end
+        def async_indexing_job?(operation)
+          return false unless @async_indexing_tasks
 
-        def async_indexing_job_for(operation)
-          async_indexing_jobs[operation] || DEFAULT_ASYNC_INDEXING_JOBS[operation] || raise(ArgumentError, "The #{operation} operation is not implemented")
+          @async_indexing_tasks.user_defined?(operation)
         end
 
-        class AsyncIndexingJobValidator
-          OPERATIONS = %i[import index update delete].freeze
-
-          def self.call(operations, block)
-            unless block.is_a?(Proc)
-              raise ArgumentError, "The block of async_indexing_job must be a callable object"
-            end
-
-            operations.each do |operation|
-              next if OPERATIONS.include?(operation)
-              raise ArgumentError, format("Unrecognized operation: %<operation>p. Valid operations are: %<valid>p", operation: operation, valid: OPERATIONS)
-            end
-          end
+        def async_indexing_job_for(operation)
+          (@async_indexing_tasks || Esse.config.async_indexing.tasks).fetch(operation)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: esse-async_indexing
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0.rc1
 platform: ruby
 authors:
 - Marcos G. Zimmermann
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-02 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: esse
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: 0.4.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.4
+        version: 0.4.0.rc1
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.0.0
 - !ruby/object:Gem::Dependency
-  name: esse-redis_storage
+  name: background_job
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.0.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -169,17 +169,15 @@ files:
 - lib/esse-async_indexing.rb
 - lib/esse/async_indexing.rb
 - lib/esse/async_indexing/actions.rb
-- lib/esse/async_indexing/actions/batch_delete.rb
-- lib/esse/async_indexing/actions/batch_import.rb
-- lib/esse/async_indexing/actions/batch_import_all.rb
-- lib/esse/async_indexing/actions/batch_update.rb
-- lib/esse/async_indexing/actions/bulk_update_lazy_document_attribute.rb
+- lib/esse/async_indexing/actions/bulk_delete.rb
+- lib/esse/async_indexing/actions/bulk_import.rb
+- lib/esse/async_indexing/actions/bulk_import_all.rb
+- lib/esse/async_indexing/actions/bulk_update.rb
+- lib/esse/async_indexing/actions/bulk_update_lazy_attribute.rb
 - lib/esse/async_indexing/actions/coerce_index_repository.rb
 - lib/esse/async_indexing/actions/delete_document.rb
-- lib/esse/async_indexing/actions/import_batch_id.rb
 - lib/esse/async_indexing/actions/index_document.rb
 - lib/esse/async_indexing/actions/update_document.rb
-- lib/esse/async_indexing/actions/update_lazy_document_attribute.rb
 - lib/esse/async_indexing/actions/upsert_document.rb
 - lib/esse/async_indexing/active_record.rb
 - lib/esse/async_indexing/active_record_callbacks/callback.rb
@@ -187,33 +185,22 @@ files:
 - lib/esse/async_indexing/active_record_callbacks/on_create.rb
 - lib/esse/async_indexing/active_record_callbacks/on_destroy.rb
 - lib/esse/async_indexing/active_record_callbacks/on_update.rb
-- lib/esse/async_indexing/adapters.rb
-- lib/esse/async_indexing/adapters/adapter.rb
-- lib/esse/async_indexing/adapters/faktory.rb
-- lib/esse/async_indexing/adapters/sidekiq.rb
 - lib/esse/async_indexing/cli.rb
 - lib/esse/async_indexing/cli/async_import.rb
+- lib/esse/async_indexing/cli/async_update_lazy_attributes.rb
 - lib/esse/async_indexing/config.rb
 - lib/esse/async_indexing/configuration.rb
-- lib/esse/async_indexing/configuration/base.rb
-- lib/esse/async_indexing/configuration/faktory.rb
-- lib/esse/async_indexing/configuration/sidekiq.rb
 - lib/esse/async_indexing/errors.rb
-- lib/esse/async_indexing/jobs/bulk_update_lazy_document_attribute_job.rb
+- lib/esse/async_indexing/jobs.rb
+- lib/esse/async_indexing/jobs/bulk_update_lazy_attribute_job.rb
 - lib/esse/async_indexing/jobs/document_delete_by_id_job.rb
 - lib/esse/async_indexing/jobs/document_index_by_id_job.rb
 - lib/esse/async_indexing/jobs/document_update_by_id_job.rb
 - lib/esse/async_indexing/jobs/document_upsert_by_id_job.rb
 - lib/esse/async_indexing/jobs/import_all_job.rb
-- lib/esse/async_indexing/jobs/import_batch_id_job.rb
-- lib/esse/async_indexing/jobs/update_lazy_document_attribute_job.rb
-- lib/esse/async_indexing/testing.rb
+- lib/esse/async_indexing/jobs/import_ids_job.rb
+- lib/esse/async_indexing/tasks.rb
 - lib/esse/async_indexing/version.rb
-- lib/esse/async_indexing/worker.rb
-- lib/esse/async_indexing/workers.rb
-- lib/esse/async_indexing/workers/faktory.rb
-- lib/esse/async_indexing/workers/shared_class_methods.rb
-- lib/esse/async_indexing/workers/sidekiq.rb
 - lib/esse/plugins/async_indexing.rb
 homepage: https://github.com/marcosgz/esse-async_indexing
 licenses:
@@ -233,9 +220,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.33
 signing_key: