esse-async_indexing 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a7931a646008cb93875d4e0fc47a552c2a19e3f9089c5e500e3cbb822f32f9bd
+  data.tar.gz: 374d59d804ca1b37e30f853b765d5b6ea0b975a97335d45249fa6e9f019d171c
+SHA512:
+  metadata.gz: fb5ef232b141e0b2ee7f629f139376f4ef169da0b7078fdf6b5e74937219c096f065e5d0b982004ab0fe50b0b5363fd09dad62a1fab110f59d84d0e7f7072561
+  data.tar.gz: 7b09c24955e14df91435ef2a4ce39796c36ddb7ee0e9c173a40fbad0e7d11cf86c67b891454555f5814ebaf56994042a361de7c2fbd9ab093a7709a946aed0c2

data/.rubocop.yml

@@ -0,0 +1,35 @@
+inherit_mode:
+  merge:
+    - Exclude
+
+require:
+  - rubocop-performance
+  - rubocop-rspec
+  - standard/cop/block_single_line_braces
+
+inherit_gem:
+  standard: config/base.yml
+
+AllCops:
+  TargetRubyVersion: 2.5
+  SuggestExtensions: false
+  Exclude:
+    - "db/**/*"
+    - "tmp/**/*"
+    - "vendor/**/*"
+  NewCops: enable
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+Rspec/MultipleMemoizedHelpers:
+  Enabled: false
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/StubbedMock:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.0.2 - 2024-08-02
+* Include sidekiq and faktory jobs to perform async indexing of documents
+* Create Active Model async indexing callbacks
+* many bug fixes and improvements
+
+## 0.0.1 - 2024-07-15
+The first release of the esse-async_indexing plugin
+* Added: Initial implementation of the plugin

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "esse"
+gem "esse-rspec"
+gem "esse-active_record", ">= 0.3.5", require: false
+gem "timecop"
+gem "faktory_worker_ruby", require: false
+gem "opensearch-ruby", require: false
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,168 @@
+PATH
+  remote: .
+  specs:
+    esse-async_indexing (0.0.2)
+      esse (>= 0.3.4)
+      esse-redis_storage (>= 0.1.0)
+      multi_json
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.1.3.4)
+      activesupport (= 7.1.3.4)
+    activerecord (7.1.3.4)
+      activemodel (= 7.1.3.4)
+      activesupport (= 7.1.3.4)
+      timeout (>= 0.4.0)
+    activesupport (7.1.3.4)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.8)
+    coderay (1.1.3)
+    concurrent-ruby (1.3.3)
+    connection_pool (2.4.1)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    diff-lcs (1.5.1)
+    drb (2.2.1)
+    esse (0.3.4)
+      multi_json
+      thor (>= 0.19)
+    esse-active_record (0.3.5)
+      activerecord (>= 4.2, < 8)
+      esse (>= 0.3.0)
+    esse-redis_storage (0.1.0)
+      esse (>= 0.3.2)
+      multi_json (>= 1.0.0)
+      redis (>= 4.0.0)
+    esse-rspec (0.0.6)
+      esse (>= 0.2.4)
+      rspec (>= 3)
+    faktory_worker_ruby (2.0.0)
+      connection_pool (~> 2.2, >= 2.2.2)
+    faraday (2.8.1)
+      base64
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-net_http (3.0.2)
+    hashdiff (1.1.0)
+    i18n (1.14.5)
+      concurrent-ruby (~> 1.0)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    method_source (1.1.0)
+    minitest (5.24.1)
+    multi_json (1.15.0)
+    mutex_m (0.2.0)
+    opensearch-ruby (3.4.0)
+      faraday (>= 1.0, < 3)
+      multi_json (>= 1.0)
+    parallel (1.25.1)
+    parser (3.3.4.0)
+      ast (~> 2.4.1)
+      racc
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    public_suffix (5.1.1)
+    racc (1.8.0)
+    rainbow (3.1.1)
+    redis (5.2.0)
+      redis-client (>= 0.22.0)
+    redis-client (0.22.2)
+      connection_pool
+    regexp_parser (2.9.2)
+    rexml (3.3.2)
+      strscan
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    rubocop (1.64.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
+    rubocop-performance (1.21.1)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    rubocop-rspec (3.0.3)
+      rubocop (~> 1.61)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    standard (1.37.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.64.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.4)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.4.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.21.0)
+    strscan (3.1.0)
+    thor (1.3.1)
+    timecop (0.9.10)
+    timeout (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.5.0)
+    webmock (3.23.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  esse
+  esse-active_record (>= 0.3.5)
+  esse-async_indexing!
+  esse-rspec
+  faktory_worker_ruby
+  opensearch-ruby
+  pry
+  rspec
+  rubocop
+  rubocop-performance
+  rubocop-rspec
+  standard
+  timecop
+  webmock
+
+BUNDLED WITH
+   2.3.22

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Marcos G. Zimmermann
+
+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.

data/README.md

@@ -0,0 +1,262 @@
+# Esse Async Indexing
+
+This gem provides a way to [Esse](https://github.com/marcosgz/esse) index documents asynchronously using [Faktory](https://github.com/contribsys/faktory_worker_ruby) or [Sidekiq](https://github.com/sidekiq/sidekiq).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'esse-async_indexing'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Configuration
+
+```ruby
+Esse.configure do |config|
+  config.redis = ConnectionPool.new(size: 10, timeout: 5) do
+    Redis.new(url: ENV.fetch('REDIS_URL', 'redis://0.0.0.0:6379'))
+  end
+
+  # Setup Sidekiq
+  require 'sidekiq'
+  config.async_indexing.sidekiq do |sidekiq|
+    sidekiq.namespace = "sidekiq"
+    sidekiq.redis = ConnectionPool.new(size: 10, timeout: 5) do
+      Redis.new(url: ENV.fetch('REDIS_URL', 'redis://0.0.0.0:6379'))
+    end
+  end
+
+  # Faktory
+  require 'faktory_worker_ruby'
+  config.async_indexing.faktory # No need to setup redis connection
+end
+```
+
+Optional worker configuration:
+
+```ruby
+Esse.configure do |config|
+  config.async_indexing.sidekiq.workers = {
+    "Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::DocumentUpsertByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::ImportAllJob" => { queue: "batch_indexing", retry: 3 },
+    "Esse::AsyncIndexing::Jobs::ImportBatchIdJob" => { queue: "batch_indexing", retry: 3 },
+    "Esse::AsyncIndexing::Jobs::BulkUpdateLazyDocumentAttributeJob" => { queue: "batch_indexing", retry: 3 },
+    "Esse::AsyncIndexing::Jobs::UpdateLazyDocumentAttributeJob" => { queue: "indexing" },
+  }
+  # or if you are using Faktory
+  config.async_indexing.faktory.workers = {
+    "Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::DocumentUpsertByIdJob" => { queue: "indexing" },
+    "Esse::AsyncIndexing::Jobs::ImportAllJob" => { queue: "batch_indexing", retry: 3 },
+    "Esse::AsyncIndexing::Jobs::ImportBatchIdJob" => { queue: "batch_indexing", retry: 3 },
+    "Esse::AsyncIndexing::Jobs::BulkUpdateLazyDocumentAttributeJob" => { queue: "batch_indexing", retry: 3 },
+    "Esse::AsyncIndexing::Jobs::UpdateLazyDocumentAttributeJob" => { queue: "indexing" },
+  }
+end
+```
+
+## Index Configuration
+
+To enable async indexing for an index, you need to add the `:async_indexing` plugin to the index. And the index collection must implement the `#each_batch_ids` method that yields an array of document ids.
+
+```ruby
+class GeosIndex < Esse::Index
+  plugin :async_indexing
+
+  repository :city do
+    collection Collections::CityCollection
+    document Documents::CityDocument
+  end
+end
+
+class GeosIndex::Collections::CityCollection < Esse::Collection
+  def each
+    # implement the each method as usual
+  end
+
+  def each_batch_ids
+    ::City.select(:id).except(:includes, :preload).find_in_batches(**batch_options) do |rows|
+      yield(rows.map(&:id))
+    end
+  end
+end
+```
+
+## CLI Commands
+
+This gem includes the `async_import` command to import documents asynchronously.
+
+```bash
+$ bundle exec esse index help async_import
+$ bundle exec esse index async_import GeosIndex --suffix="20240101" --service="sidekiq" --repo="city"
+```
+
+
+## Workers/Jobs
+
+The gem provides a few jobs to index, update, upsert and delete document or batch of documents with given ids. The sidekiq or faktory worker does not need to live in the same application that enqueues the job. The worker can be in a separate application that only runs the worker process. This gem has its own DSL to push jobs.
+
+But for make sure to require the jobs in the worker application by calling `install!`
+
+```ruby
+Esse::AsyncIndexing::Workers.install!(:faktory)
+Esse::AsyncIndexing::Workers.install!(:sidekiq)
+```
+
+
+### Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob
+
+Fetch a document from `GeosIndex.repo(:city)` collection using the given id and index it
+
+```ruby
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentIndexByIdJob", service: :sidekiq).with_args("GeosIndex", "city", city.id, suffix: "20240101")
+.push
+```
+
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+### Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob
+
+Fetch a document from `GeosIndex.repo(:city)` collection using the given id and update it
+
+```ruby
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentUpdateByIdJob", service: :sidekiq).with_args("GeosIndex", "city", city.id, suffix: "20240101")
+```
+
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+### Esse::AsyncIndexing::Jobs::DocumentUpsertByIdJob
+
+Fetch a document from `GeosIndex.repo(:city)` collection using the given id and upsert it
+
+```ruby
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentUpsertByIdJob", service: :sidekiq).with_args("GeosIndex", "city", city.id, suffix: "20240101")
+```
+
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+
+### Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob
+
+Delete a document from the index using the given id
+
+```ruby
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::DocumentDeleteByIdJob", service: :sidekiq).with_args("GeosIndex", "city", city.id, suffix: "20240101")
+```
+
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+### Esse::AsyncIndexing::Jobs::ImportAllJob
+
+Import all documents from the `GeosIndex.repo(:city)` collection where `state_abbr` is "IL"
+
+```ruby
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::ImportAllJob", service: :sidekiq).with_args("GeosIndex", "city", context: {state_abbr: "IL"}, suffix: "20240101")
+```
+
+**Note:** Suffix and import context are optional, just an example of how to pass additional arguments to the job.
+
+### Esse::AsyncIndexing::Jobs::ImportBatchIdJob
+
+Import a batch of documents from the `GeosIndex.repo(:city)` collection using a batch_id generated by the [esse-redis_storage](https://github.com/marcosgz/esse-redis_storage) gem. This is the job that the `async_import` command uses.
+
+```ruby
+batch_id = Esse::RedisStorage::Queue.for(repo: GeosIndex.repo(:city)).enqueue(values: big_list_of_uuids)
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::ImportBatchIdJob", service: :sidekiq).with_args("GeosIndex", "city", batch_id, suffix: "20240101")
+```
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+### Esse::AsyncIndexing::Jobs::BulkUpdateLazyDocumentAttributeJob
+
+Update a lazy attribute of a document from the index using the given enqueued batch_id.
+
+```ruby
+batch_id = Esse::RedisStorage::Queue.for(repo: GeosIndex.repo(:city), attribute_name: "total_schools").enqueue(values: big_list_of_uuids)
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::BulkUpdateLazyDocumentAttributeJob", service: :sidekiq).with_args("GeosIndex", "city", "total_schools", batch_id, suffix: "20240101")
+```
+
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+### Esse::AsyncIndexing::Jobs::UpdateLazyDocumentAttributeJob
+
+Update a lazy attribute of a document from the index using the given id
+
+```ruby
+Esse::AsyncIndexing.worker("Esse::AsyncIndexing::Jobs::UpdateLazyDocumentAttributeJob", service: :sidekiq).with_args("GeosIndex", "city", "total_schools", [city.id], suffix: "20240101")
+```
+
+**Note:** Suffix is optional, just an example of how to pass additional arguments to the job.
+
+### Custom Jobs
+
+To implement a custom job :import, :index, :update or :delete documents, you need to define them using the `async_indexing_job` method in the index repository.
+
+```ruby
+class GeosIndex < Esse::Index
+  plugin :async_indexing
+
+  repository :city do
+    collection Collections::CityCollection
+    document Documents::CityDocument
+    async_indexing_job(:import) do |service:, repo:, operation:, ids:, **kwargs|
+      GeosCityImportJob.perform_later(ids, **kwargs)
+    end
+    async_indexing_job(:index, :update, :delete)  do |service:, repo:, operation:, id:, **kwargs|
+      GeosCityUpsertJob.perform_later(id, **kwargs)
+    end
+  end
+end
+```
+
+## Extras
+
+You may want to use `async_indexing_callback` or `async_update_lazy_attribute_callback` callbacks along with the ActiveRecord models to automatically index, update, upsert or delete documents or attributes when the model is created, updated or destroyed.
+
+This functionality require the [esse-active_record](https://github.com/marcosgz/esse-active_record) gem to be installed. Then require the `esse/asyn_indexing/active_record` file in the initializer.
+
+```ruby
+require 'esse/async_indexing/active_record'
+```
+
+Now you can use the `async_index_callback` or `async_update_lazy_attribute_callback` in the ActiveRecord models.
+
+```diff
+class City < ApplicationRecord
+- include Esse::ActiveRecord::Model
++ include Esse::AsyncIndexing::ActiveRecord::Model
+
+  belongs_to :state, optional: true
+
+- index_callback('geos_index:city') { id }
+- update_lazy_attribute_callback('geos_index:state', 'cities_count', if: :state_id?) { state_id }
++ async_index_callback('geos_index:city', service_name: :sidekiq) { id }
++ async_update_lazy_attribute_callback('geos_index:state', 'cities_count', if: :state_id?, service_name: :sidekiq) { state_id }
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake none` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcosgz/esse-async_indexing.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/docker-compose.yml

@@ -0,0 +1,11 @@
+services:
+  redis:
+    image: redis
+    command: redis-server
+    ports:
+      - 6379:6379
+  faktory:
+    image: contribsys/faktory
+    ports:
+      - 7419:7419
+      - 7420:7420

data/lib/esse/async_indexing/actions/batch_delete.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Esse::AsyncIndexing::Actions
+  class BatchDelete
+    def self.call(index_class_name, repo_name, ids, options = {})
+      docs = Esse::LazyDocumentHeader.coerce_each(ids)
+      return if docs.empty?
+
+      index_class, _repo_class = CoerceIndexRepository.call(index_class_name, repo_name)
+      bulk_opts = Esse::HashUtils.deep_transform_keys(options, &:to_sym)
+      index_class.bulk(**bulk_opts, delete: docs.map(&:to_doc))
+      docs.size
+    end
+  end
+end

data/lib/esse/async_indexing/actions/batch_import.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Esse::AsyncIndexing::Actions
+  class BatchImport
+    def self.call(index_class_name, repo_name, ids, options = {})
+      ids = Array(ids)
+      return if ids.empty?
+
+      _index_class, repo_class = CoerceIndexRepository.call(index_class_name, repo_name)
+      kwargs = Esse::HashUtils.deep_transform_keys(options, &:to_sym)
+      kwargs[:context] ||= {}
+      kwargs[:context][:id] = ids
+      repo_class.import(**kwargs)
+    end
+  end
+end

data/lib/esse/async_indexing/actions/batch_import_all.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Esse::AsyncIndexing::Actions
+  class BatchImportAll
+    def self.call(index_class_name, repo_name, options = {})
+      _index_class, repo_class = CoerceIndexRepository.call(index_class_name, repo_name)
+      kwargs = Esse::HashUtils.deep_transform_keys(options, &:to_sym)
+      repo_class.import(**kwargs)
+    end
+  end
+end

data/lib/esse/async_indexing/actions/batch_update.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Esse::AsyncIndexing::Actions
+  class BatchUpdate
+    DOC_ARGS = %i[lazy_attributes context]
+
+    def self.call(index_class_name, repo_name, ids, options = {})
+      ids = Array(ids)
+      return if ids.empty?
+
+      index_class, repo_class = CoerceIndexRepository.call(index_class_name, repo_name)
+      bulk_opts = Esse::HashUtils.deep_transform_keys(options, &:to_sym)
+      find_opts = {}
+      if (context = bulk_opts.delete(:context))
+        find_opts.merge!(context)
+      end
+      if (lazy_attributes = bulk_opts.delete(:lazy_attributes))
+        find_opts[:lazy_attributes] = lazy_attributes
+      end
+      find_opts[:id] = ids
+
+      count = 0
+      repo_class.each_serialized_batch(**find_opts) do |batch|
+        index_class.cluster.may_update_type!(bulk_opts)
+        index_class.bulk(**bulk_opts, update: batch)
+        count += batch.size
+      end
+
+      count
+    end
+  end
+end

data/lib/esse/async_indexing/actions/bulk_update_lazy_document_attribute.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Esse::AsyncIndexing::Actions
+  class BulkUpdateLazyDocumentAttribute
+    def self.call(index_class_name, repo_name, attr_name, batch_id, options = {})
+      _index_class, repo_class = CoerceIndexRepository.call(index_class_name, repo_name)
+      queue = Esse::RedisStorage::Queue.for(repo: repo_class, attribute_name: attr_name)
+
+      kwargs = Esse::HashUtils.deep_transform_keys(options, &:to_sym)
+
+      attr_name = repo_class.lazy_document_attributes.keys.find { |key| key.to_s == attr_name.to_s }
+      updated_ids = []
+      queue.fetch(batch_id) do |ids|
+        updated_ids = ids
+        repo_class.update_documents_attribute(attr_name, ids, **kwargs)
+      end
+      updated_ids
+    end
+  end
+end

data/lib/esse/async_indexing/actions/coerce_index_repository.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Esse::AsyncIndexing::Actions::CoerceIndexRepository
+  def self.call(index_class_name, repo_name)
+    index_class = begin
+      Object.const_get(index_class_name)
+    rescue NameError
+      raise(ArgumentError, "Index class #{index_class_name} not found")
+    end
+
+    repo_class = index_class.repo_hash[repo_name.to_s]
+    repo_class ||= if repo_name.include?("::")
+      index_class.repo_hash.map { |_, v| [v.to_s, v] }.to_h[repo_name]
+    end
+    if repo_class.nil?
+      raise ArgumentError, <<~MSG
+        No repo named "#{repo_name}" found in #{index_class_name}. Use the `repository` method to define one:
+
+          repository :#{repo_name} do
+            # collection ...
+            # document ...
+          end
+      MSG
+    end
+
+    [index_class, repo_class]
+  end
+end

data/lib/esse/async_indexing/actions/delete_document.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Esse::AsyncIndexing::Actions
+  class DeleteDocument
+    DOC_ARGS = %i[lazy_attributes]
+
+    def self.call(index_class_name, repo_name, document_id, options = {})
+      index_class, _repo_class = CoerceIndexRepository.call(index_class_name, repo_name)
+      bulk_opts = Esse::HashUtils.deep_transform_keys(options, &:to_sym)
+      bulk_opts.delete_if { |k, _| DOC_ARGS.include?(k) }
+
+      index_class.delete(id: document_id, **bulk_opts)
+      :deleted
+    end
+  end
+end