railbox 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e7c53ea3b3e9b5c1f7a67c19273456d4cedb978257834328db3b1a3e058e0bf
+  data.tar.gz: 2832aeeb9558208d4ba229828403459422fcd19ea765ac193b63067031746349
+SHA512:
+  metadata.gz: 670dbf35a4f62c0c81a779bc5d1f2e4af414f13b6d72064fbfd0eedc1bfd5097617c7f6508b8bc2abe082dea5927e5da4dfa78a23dfca0e38dda92c9b77def7a
+  data.tar.gz: ffdd4cc4dd8bd242483ac8b61fecacb3a9b69104d3931c3cead162a6b0c7601e2dfa0381d74005facdf1967b533643b61c242b867029e8b6b6e04f5f3b33c10d

data/lib/generators/railbox/install/install_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Railbox
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('templates', __dir__)
+
+      def create_migration_file
+        migration_template 'migration.rb.tt', "db/migrate/create_transactional_outbox.rb"
+      end
+
+      def self.next_migration_number(dirname)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+    end
+  end
+end

data/lib/railbox/exceptions/queue_error.rb

@@ -0,0 +1,5 @@
+module Railbox
+  module Exceptions
+    class QueueError < StandardError; end
+  end
+end

data/lib/railbox/exceptions/validation_error.rb

@@ -0,0 +1,6 @@
+module Railbox
+  module Exceptions
+    # Raised when provided options or arguments are invalid for outbox creation.
+    class ValidationError < StandardError; end
+  end
+end

data/lib/railbox/handler/handler.rb

@@ -0,0 +1,33 @@
+# Module to be included in service classes for adding queue processing support
+# and an additional `outbox_entity` property.
+#
+# @example Usage
+#   class MyService
+#     include Railbox::Handler
+#   end
+#
+#   MyService.enqueue(method: 'update', body: { key: 'value' })
+#
+# @!method outbox_entity
+#   @return [Object] Returns the current value of outbox_entity.
+#
+module Railbox
+  module Handler
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :outbox_entity
+
+      # Queues a request for asynchronous execution
+      # @param method [String] to be called (default: 'create')
+      # @param body [Hash] main payload for the handler
+      # @param opts [Hash] any additional options (e.g. relative_entity/meta)
+      #
+      def enqueue(method: 'create', body: {}, **opts)
+        HandlingQueue.enqueue(service: name, method: method, body: body, **opts)
+      end
+    end
+  end
+end

data/lib/railbox/http_client/faraday.rb

@@ -0,0 +1,33 @@
+module Railbox
+  module HttpClient
+    class Faraday
+      class << self
+        def request(method, url, query = {}, body = {}, headers = {})
+          connection = ::Faraday.new do |config|
+            config.adapter :httpclient
+            config.request :json
+            config.response :json, parser_options: {symbol_keys: true}
+            config.response :raise_error
+
+            config.response :logger, Rails.logger, logger_options
+          end
+
+          connection.send(method, url) do |req|
+            req.params  = query if query.present?
+            req.headers = headers if headers.present?
+            req.body    = body if body.present? && method != :get
+          end
+        end
+
+        def logger_options
+          {
+            headers:   {request: true, response: true},
+            bodies:    {request: true, response: true},
+            errors:    true,
+            log_level: :info
+          }
+        end
+      end
+    end
+  end
+end

data/lib/railbox/interfaces/transactional_outbox_interface.rb

@@ -0,0 +1,14 @@
+module Railbox
+  class TransactionalOutboxInterface
+
+    def initialize(record)
+      @record = record
+    end
+
+    extend Forwardable
+    def_delegators :@record,
+                   :id, :action_type, :action_data, :status, :relative_entity,
+                   :query, :body, :headers, :meta, :attempts, :retry_at, :failure_reasons,
+                   :group
+  end
+end

data/lib/railbox/models/transactional_outbox.rb

@@ -0,0 +1,50 @@
+module Railbox
+  module Models
+    # == Schema Information
+    #
+    # Table name: transactional_outboxes
+    #
+    #  id              :bigint           not null, primary key
+    #  action_type     :string           not null    # Type of action/event (class_method/http)
+    #  action_data     :jsonb            not null    # Action data or payload ({process_class: "MyService", process_method: "create"}/{method: "POST", url: "https://..."}) (default: {})
+    #  status          :string           not null    # Processing status (e.g. in_progress, failed, completed)
+    #  entity_type     :string                       # Polymorphic type for associated entity
+    #  entity_id       :integer                      # Polymorphic ID for associated entity
+    #  query           :jsonb                        # Url query (JSON)
+    #  body            :jsonb                        # Main body/payload (default: {})
+    #  headers         :jsonb                        # Headers (default: {})
+    #  meta            :jsonb                        # Metadata or extra info (JSON)
+    #  attempts        :integer          default(0)  # Number of processing attempts
+    #  retry_at        :datetime                     # Next retry timestamp
+    #  failure_reasons :jsonb, array                 # Array of failure reason objects
+    #  created_at      :datetime         not null    # Record creation timestamp
+    #  updated_at      :datetime         not null    # Last update timestamp
+    #
+    # Indexes
+    #
+    #  index_transactional_outboxes_on_entity_type_and_entity_id  (entity_type,entity_id)
+    #
+    # Purpose:
+    #   - Queues reliable actions/events for external systems.
+    #   - Tracks delivery status and retry logic.
+    #   - Stores metadata and failure reasons for auditing/debugging.
+    #
+    class TransactionalOutbox < ::ActiveRecord::Base
+      belongs_to :relative_entity, polymorphic: true, foreign_key: :entity_id, foreign_type: :entity_type
+
+      def in_group?
+        group.present? || entity_group.present?
+      end
+
+      def group
+        action_data[:group]
+      end
+
+      def entity_group
+        "#{entity_type}.#{entity_id}"
+      end
+    end
+  end
+end
+
+

data/lib/railbox/mutators/transactional_outbox_mutator.rb

@@ -0,0 +1,29 @@
+module Railbox
+  module Mutators
+    class TransactionalOutboxMutator
+      class << self
+
+        def create(attributes)
+          TransactionalOutbox.create!(attributes)
+        end
+
+        def update(record, attributes)
+          record.assign_attributes(attributes)
+
+          if record.status == 'in_progress'
+            record.attempts += 1
+
+            if record.attempts >= Railbox.configuration.max_attempts
+              record.status = 'failed'
+            else
+              record.retry_at = (Railbox.configuration.retry_strategy[record.attempts - 1] || Railbox.configuration.retry_strategy.last).from_now
+            end
+          end
+
+          record.save!
+          record
+        end
+      end
+    end
+  end
+end

data/lib/railbox/processors/handler_processor.rb

@@ -0,0 +1,19 @@
+module Railbox
+  module Processors
+    class HandlerProcessor
+      class << self
+
+        def process(record)
+          interface             = Railbox::TransactionalOutboxInterface.new(record)
+          action_data           = record.action_data.deep_symbolize_keys!
+          handler               = Object.const_get(action_data[:class_name])
+          handler.outbox_entity = interface
+
+          handler.public_send(action_data[:method_name])
+
+          handler.outbox_entity = nil
+        end
+      end
+    end
+  end
+end

data/lib/railbox/processors/http_processor.rb

@@ -0,0 +1,18 @@
+module Railbox
+  module Processors
+    class HttpProcessor
+      class << self
+
+        def process(record)
+          action_data = record.action_data.deep_symbolize_keys!
+
+          Railbox::HttpClient::Faraday.request(action_data[:method_name],
+                                               action_data[:url],
+                                               record.query,
+                                               record.body,
+                                               record.headers)
+        end
+      end
+    end
+  end
+end

data/lib/railbox/queue/base_queue.rb

@@ -0,0 +1,42 @@
+module Railbox
+  module Queue
+    # Abstract base class for enqueuing tasks into the transactional outbox.
+    #
+    # This class is intended to be subclassed: descendants should implement their own logic for enqueuing tasks.
+    #
+    # Usage example:
+    #   class MyQueue < Railbox::BaseQueue
+    #     def self.enqueue(**opts)
+    #       # your implementation here
+    #     end
+    #   end
+    #
+    # The .enqueue method **must** be implemented in each subclass.
+    # Calling .enqueue directly on BaseQueue will raise NotImplementedError.
+    #
+    class BaseQueue
+      class << self
+        # Abstract method for enqueuing a task into the outbox.
+        #
+        # Each subclass must override this method with specific logic.
+        #
+        # @param opts [Hash] Parameters required by a particular implementation.
+        # @raise [NotImplementedError] if the method is not overridden in a subclass.
+        #
+        def enqueue(**_)
+          raise NotImplementedError, 'You must implement this method'
+        end
+
+        private
+
+        # Creates a record in the transactional outbox with the given attributes.
+        #
+        # @param attributes [Hash] Record attributes
+        # @return [Railbox::TransactionalOutboxMutator] The created record
+        def to_queue(**attributes)
+          Railbox::TransactionalOutboxMutator.create(**attributes)
+        end
+      end
+    end
+  end
+end

data/lib/railbox/queue/handling_queue.rb

@@ -0,0 +1,61 @@
+module Railbox
+  module Queue
+    # HandlingQueue is responsible for enqueuing "class method call" actions into the transactional outbox table.
+    #
+    # Usage example:
+    #   Railbox::HandlingQueue.enqueue(
+    #     service: "MyService",
+    #     method: "perform_action",
+    #     body: { key: "value" },
+    #     headers: { ... },
+    #     query: { ... },
+    #     entity_type: "User",
+    #     entity_id: 123,
+    #     meta: { ... }
+    #   )
+    #
+    # This method creates a Railbox::TransactionalOutboxMutator record to be processed by a background job later,
+    # enabling reliable, auditable, and decoupled invocation of class methods in your system.
+    #
+    # A ValidationError is raised if the given options are invalid (for example, missing class, method, or incorrect body format).
+    #
+    class HandlingQueue < BaseQueue
+      OPTIONS = %i[headers query relative_entity meta].freeze
+
+      class << self
+        # Enqueues a class method call operation for asynchronous processing via the transactional outbox.
+        #
+        # @param service [String] Name of the target service class (must exist).
+        # @param method [String, Symbol] Name of the public class method to call (default: 'create').
+        # @param body [Hash] The request payload (must be a Hash)
+        # @param opts [Hash] Optional parameters: headers, query, entity_type, entity_id, meta.
+        # @raise [ValidationError] If the service, method, or body are invalid.
+        # @return [Boolean] true if enqueuing succeeds.
+        #
+        def enqueue(service:, method: 'create', body: {}, **opts)
+          opts.deep_symbolize_keys!.slice!(*OPTIONS)
+          validate_options(service, method, body, **opts)
+
+          to_queue(
+            action_type: 'handler',
+            action_data: {class_name: service, method_name: method},
+            body:        body,
+            status:      'in_progress',
+            **opts
+          )
+
+          true
+        end
+
+        private
+
+        def validate_options(service, method, body, **_)
+          raise ValidationError, "Service #{service} is not present" unless service.present?
+          raise ValidationError, "Service class #{service} is not defined" unless Object.const_defined?(service)
+          raise ValidationError, "Method #{method} for class #{service} is not defined" unless Object.const_get(service).respond_to?(method)
+          raise ValidationError, 'Body must be a Hash' unless body.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

data/lib/railbox/queue/http_queue.rb

@@ -0,0 +1,61 @@
+module Railbox
+  module Queue
+    # HttpQueue is responsible for enqueuing HTTP request actions into the transactional outbox.
+    #
+    # Usage example:
+    #   Railbox::HttpQueue.enqueue(
+    #     url: "https://example.com/api",
+    #     method: :post,
+    #     body: { data: 1 },
+    #     headers: { "Authorization" => "Bearer ..." },
+    #     query: { foo: "bar" },
+    #     meta: { correlation_id: "123" }
+    #   )
+    #
+    # This creates a Railbox::TransactionalOutboxMutator record, which will be processed later by a background worker,
+    # providing reliable, traceable, and decoupled execution of HTTP requests.
+    #
+    # A ValidationError will be raised if the url, method, or body are invalid.
+    #
+    class HttpQueue < BaseQueue
+      OPTIONS = %i[query meta group].freeze
+      METHODS = %i[get post put patch delete].freeze
+
+      class << self
+        # Enqueues an HTTP request action for asynchronous processing via the transactional outbox.
+        #
+        # @param url [String] The HTTP endpoint URL (must begin with http:// or https://).
+        # @param method [Symbol] HTTP method to use (:get, :post, :put, :patch, :delete). Defaults to :post.
+        # @param body [Hash] Request payload (must be a Hash). Defaults to empty hash.
+        # @param headers [Hash] Optional HTTP headers.
+        # @param opts [Hash] Additional options: query, meta, group.
+        # @raise [ValidationError] If the url, method, or body are invalid.
+        # @return [Boolean] true if enqueuing is successful.
+        #
+        def enqueue(url:, method: :post, body: {}, headers: {}, **opts)
+          opts.deep_symbolize_keys!.slice!(*OPTIONS)
+          validate_options(url, method, body)
+
+          to_queue(
+            action_type: 'http_request',
+            action_data: {url: url, method_name: method},
+            body:        body,
+            headers:     headers,
+            status:      'in_progress',
+            **opts
+          )
+
+          true
+        end
+
+        private
+
+        def validate_options(url, method, body)
+          raise ValidationError, "Url #{url} is not valid" unless %r{\Ahttps?://[^\s/$.?#].\S*\z}i.match?(url)
+          raise ValidationError, "Invalid method: #{method}. Allowed methods are: #{METHODS.join(', ')}" unless METHODS.include?(method)
+          raise ValidationError, 'Body must be a Hash' unless body.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

data/lib/railbox/workers/base_worker.rb

@@ -0,0 +1,25 @@
+module Railbox
+  module Workers
+    class BaseWorker < ::ActiveJob::Base
+      queue_as :default
+
+      def with_lock
+        lock_id  = Zlib.crc32(self.class.name, 0)
+        lock_sql = "SELECT pg_try_advisory_lock(#{lock_id}) AS locked"
+
+        result = ActiveRecord::Base.connection.execute(lock_sql)
+        locked = result.first['locked'] unless result.nil?
+
+        unless locked
+          Rails.logger.info "Another #{self.class.name} work now."
+          return
+        end
+
+        yield
+
+      ensure
+        ActiveRecord::Base.connection.execute("SELECT pg_advisory_unlock(#{lock_id})")
+      end
+    end
+  end
+end

data/lib/railbox/workers/process_queue_worker.rb

@@ -0,0 +1,93 @@
+module Railbox
+  module Workers
+    class ProcessQueueWorker < BaseWorker
+      PROCESSORS = {
+        'handler'      => Processors::HandlerProcessor,
+        'http_request' => Processors::HttpProcessor
+      }.freeze
+
+      def perform
+        with_lock do
+          grouped_records.each_value do |group|
+            group.each do |record|
+              process_record(record)
+            rescue => e
+              TransactionalOutboxMutator.update(record, {failure_reasons: record.failure_reasons << { message: e.message, backtrace: e.backtrace&.take(3), at: DateTime.current}})
+              raise e if record.in_group? || record.action_type == 'handler'
+
+              Rails.logger.error("RailboxWorker error: #{e.message}\n #{e.backtrace&.take(3)&.join("\n")}")
+
+              next
+            end
+          rescue => e
+            Rails.logger.error("RailboxWorker error: #{e.message}\n #{e.backtrace&.take(3)&.join("\n")}")
+            next
+          end
+        rescue => e
+          Rails.logger.error("RailboxWorker error: #{e.message}\n #{e.backtrace&.take(3)&.join("\n")}")
+        end
+      end
+
+      private
+
+      def grouped_records
+        sql = <<-SQL.squish
+          SELECT t.*
+          FROM transactional_outboxes t
+          WHERE t.status = 'in_progress'
+            AND (t.retry_at IS NULL OR t.retry_at <= NOW())
+            AND NOT EXISTS (
+              SELECT 1
+              FROM transactional_outboxes f
+              WHERE f.status = 'failed'
+                AND (
+                  (t.action_data ? 'group' AND (f.action_data->>'group') = (t.action_data->>'group'))
+                  OR (
+                    (NOT (t.action_data ? 'group') OR (t.action_data->>'group') IS NULL)
+                    AND f.entity_type = t.entity_type
+                    AND f.entity_id   = t.entity_id
+                  )
+                )
+            )
+          ORDER BY t.created_at
+        SQL
+
+        records = Railbox::TransactionalOutbox.find_by_sql(sql)
+
+        grouped = records.group_by do |record|
+          record.group.present? ? [:group, record.group] : [:entity, record.entity_group]
+        end
+
+        grouped.transform_values do |group_records|
+          key_record = group_records.first
+          scope      = Railbox::TransactionalOutbox.where(status: 'in_progress')
+
+          if key_record.group.present?
+            scope = scope.where("action_data ->> 'group' = ?", key_record.group)
+          else
+            scope = scope.where(entity_type: key_record.entity_type, entity_id: key_record.entity_id)
+          end
+
+          all_group_records = scope.order(:created_at).to_a
+
+          group_records if all_group_records.first&.id.in?(group_records.map(&:id))
+        end.compact.reject { |_k, v| v.blank? }
+      end
+
+      def process_record(record)
+        Rails.logger.info("Start process with transactional outbox ID #{record.id}")
+        processor = PROCESSORS[record.action_type]
+
+        if processor
+          processor.process(record)
+        else
+          raise Railbox::QueueError, "Unknown action_type=#{record.action_type} for outbox #{record.id}"
+        end
+
+        TransactionalOutboxMutator.update(record, {status: 'completed'})
+
+        Rails.logger.info("Finish process with transactional outbox ID #{record.id}")
+      end
+    end
+  end
+end

data/lib/railbox.rb

@@ -0,0 +1,59 @@
+require 'active_record'
+require 'active_job'
+
+require 'faraday'
+require 'faraday/httpclient'
+
+require_relative 'railbox/exceptions/validation_error'
+require_relative 'railbox/exceptions/queue_error'
+
+require_relative 'railbox/models/transactional_outbox'
+require_relative 'railbox/mutators/transactional_outbox_mutator'
+
+require_relative 'railbox/interfaces/transactional_outbox_interface'
+
+require_relative 'railbox/queue/base_queue'
+require_relative 'railbox/queue/http_queue'
+require_relative 'railbox/queue/handling_queue'
+
+require_relative 'railbox/handler/handler'
+
+require_relative 'railbox/processors/handler_processor'
+require_relative 'railbox/processors/http_processor'
+
+require_relative 'railbox/workers/base_worker'
+require_relative 'railbox/workers/process_queue_worker'
+
+require_relative 'railbox/http_client/faraday'
+
+module Railbox
+  class << self
+    attr_writer :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+
+  class Configuration
+    attr_accessor :max_attempts, :retry_strategy
+
+    def initialize
+      @max_attempts   = 5
+      @retry_strategy = [1.minute, 10.minutes, 1.hour, 3.hours, 1.day]
+    end
+  end
+end
+
+Railbox::HttpQueue                  = Railbox::Queue::HttpQueue
+Railbox::HandlingQueue              = Railbox::Queue::HandlingQueue
+Railbox::TransactionalOutbox        = Railbox::Models::TransactionalOutbox
+Railbox::TransactionalOutboxMutator = Railbox::Mutators::TransactionalOutboxMutator
+Railbox::QueueError                 = Railbox::Exceptions::QueueError
+Railbox::ValidationError            = Railbox::Exceptions::ValidationError

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: railbox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Egor Beresnev
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: forwardable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem for implementing the transactional outbox pattern with support
+  for HTTP requests and custom message pre-processing.
+email:
+- egor594bed@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/railbox/install/install_generator.rb
+- lib/railbox.rb
+- lib/railbox/exceptions/queue_error.rb
+- lib/railbox/exceptions/validation_error.rb
+- lib/railbox/handler/handler.rb
+- lib/railbox/http_client/faraday.rb
+- lib/railbox/interfaces/transactional_outbox_interface.rb
+- lib/railbox/models/transactional_outbox.rb
+- lib/railbox/mutators/transactional_outbox_mutator.rb
+- lib/railbox/processors/handler_processor.rb
+- lib/railbox/processors/http_processor.rb
+- lib/railbox/queue/base_queue.rb
+- lib/railbox/queue/handling_queue.rb
+- lib/railbox/queue/http_queue.rb
+- lib/railbox/workers/base_worker.rb
+- lib/railbox/workers/process_queue_worker.rb
+homepage: https://github.com/egor594bed/railbox
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/egor594bed/railbox
+  source_code_uri: https://github.com/egor594bed/railbox
+  changelog_uri: https://github.com/egor594bed/railbox/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Reliable transactional outbox for background tasks and decoupled processing
+test_files: []