trx_ext 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d86c6295c4d141b3bcf938c95e8856cf390d5bd1a0454f81dfde3a135c35b9ff
-  data.tar.gz: d47c2e2425bf29d242824da94551acd8f44cb4489c811935ef5bd16169892544
+  metadata.gz: 437621539108dd313b7d2b91383ca64009bc64472cb71a67e851f1eb76b3a894
+  data.tar.gz: 6b18b50ebdd5ac8b91fc7f5fd870cdc30b2d8a421a5ba7c2d3a42620b9460218
 SHA512:
-  metadata.gz: 1dd474ef6d21fe8443b14b7d3d12a3af00c030d14ff45924cf5130495cd12e5e37b8890d6af9303100e7acf269564fce405b9f00848661079c4e2627735ccfe7
-  data.tar.gz: 98ea0710b3c50b96741511c50ce627b06e8d8a7e8701c53935db1696c7aec2e61db9474bfa4239f11aa15e2243a7754a7de1590d3e2a157a885d8e6f9b4d1d93
+  metadata.gz: de55ddb63c774c507bcb2c88e13f55f34d97fa4c16576eb77c12b8dc27ab61a70f00790715a60ddc7b5338ad6db40733e66878264e535389dd210ab8da172b9c
+  data.tar.gz: ed336131965bca0cee5818f39d17e025cd89da876fbbcb5084d2f7028fb00bf39a1297e2df88196eb9b130ede88bd312b480ccf2119c94277880aeef0030348c

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [3.0.0] - 2024-09-20
+- Drop `trx_ext` callbacks implementation in favour of rails v7.2 transaction callbacks
+
+## [2.0.1] - 2024-09-20
+- Restrict rails version to `< 7.2`. Rails v7.2 has suddenly released its own transaction callbacks which interferes with `trx_ext` transaction callbacks. Example of rails v7.2 transaction callbacks:
+
+```ruby
+Article.transaction do |transaction|
+  article.update(published: true)
+  transaction.after_commit do
+    PublishNotificationMailer.with(article: article).deliver_later
+  end
+end
+```
+
+Next major version of `trx_ext` will drop its own transaction callbacks implementation and will start relying on rails' transaction callbacks.
+
 ## [2.0.0] - 2024-04-14
 
 - `trx_ext` now supports any adapter(except `mysql`; `mysql2` is supported though), supported by rails

data/README.md

@@ -1,6 +1,6 @@
 # TrxExt
 
-Extends functionality of ActiveRecord's transaction to auto-retry failed SQL transaction in case of deadlock, serialization error or unique constraint error. It also allows you to define `on_complete` callback that is being executed after SQL transaction is finished(either COMMIT-ed or ROLLBACK-ed). The implementation is not bound to any database, but relies on the rails connection adapters instead. Thus, if your database is supported by rails out of the box, then the gem's features will just work. Currently supported adapters:
+Extends functionality of ActiveRecord's transaction to auto-retry failed SQL transaction in case of deadlock, serialization error or unique constraint error. The implementation is not bound to any database, but relies on the rails connection adapters instead. Thus, if your database is supported by rails out of the box, then the gem's features will just work. Currently supported adapters:
 
 - `postgresql`
 - `mysql2`
@@ -9,14 +9,15 @@ Extends functionality of ActiveRecord's transaction to auto-retry failed SQL tra
 
 **WARNING!**
 
-Because the implementation of this gem patches ActiveRecord - carefully test its integration into your project. For example, if your application patches ActiveRecord or if some of your gems patches ActiveRecord - there might be conflicts in the implementation which could potentially lead to the data loss.
-
-Currently, the implementation is tested for rails v7.1+. **If you need the support of rails v6.0, v6.1, v7.0 - please use v1.x of this gem, but it works with PostgreSQL only.**
+Because the implementation of this gem wraps some ActiveRecord methods - carefully test its integration into your project. For example, if your application patches ActiveRecord or if some of your gems patches ActiveRecord - there might be conflicts in the implementation which could potentially lead to the data loss.
 
 ## Requirements
 
-- ActiveRecord 7.1+
-- Ruby 3
+- ActiveRecord 7.2+
+- Ruby 3.1+
+
+**If you need the support of rails v6.0, v6.1, v7.0 - please use v1.x of this gem, but it works with PostgreSQL only.**
+**If you need the support of rails v7.1 - please use v2.x of this gem.**
 
 ## Installation
 
@@ -46,15 +47,15 @@ end
 
 trx do
   DummyRecord.first || DummyRecord.create
-  trx do |c|
-    c.on_complete { puts "This message will be printed after COMMIT statement." }
+  trx do |t|
+    t.after_commit { puts "This message will be printed after COMMIT statement." }
   end  
 end
 
 trx do
   DummyRecord.first || DummyRecord.create
-  trx do |c|
-    c.on_complete { puts "This message will be printed after ROLLBACK statement." }    
+  trx do |t|
+    t.after_rollback { puts "This message will be printed after ROLLBACK statement." }
   end
   raise ActiveRecord::Rollback
 end
@@ -62,7 +63,7 @@ end
 class DummyRecord
   # Wrap method in transaction
   wrap_in_trx def some_method_with_quieries
-    DummyRecord.first || DummyRecord.create    
+    DummyRecord.first || DummyRecord.create
   end
 end
 ```
@@ -82,7 +83,7 @@ If you want to wrap some method into a transaction using `wrap_in_trx` outside t
 class MyAwesomeLib
   # Wrap method in transaction
   def some_method_with_quieries
-    DummyRecord.first || DummyRecord.create    
+    DummyRecord.first || DummyRecord.create
   end
   wrap_in_trx :some_method_with_quieries, 'DummyRecord'
 end
@@ -91,9 +92,9 @@ end
 ## Configuration
 
 ```ruby
-TrxExt.configure do |c|
+TrxExt.configure do |config|
   # Number of retries before failing when unique constraint error raises. Default is 5
-  c.unique_retries = 5
+  config.unique_retries = 5
 end
 ```
 
@@ -194,7 +195,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
 
     def update_posts
       trx do
-        @user.posts.update_all(banned: true) if @user.user_permission.admin?          
+        @user.posts.update_all(banned: true) if @user.user_permission.admin?
       end  
     end    
     ```
@@ -230,17 +231,17 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
     COMMIT
     ```
 
-* It may happen that you need to invoke mailer's method inside `trx` block and pass there values that are calculated within the transaction block. Normally, you need to extract those values into after-transaction code and invoke mailer after transaction's end. Use `on_complete` callback to simplify your code:
+* It may happen that you need to invoke mailer's method inside `trx` block and pass there values that are calculated within the transaction block. Normally, you need to extract those values into after-transaction code and invoke mailer after transaction's end. Use `after_commit` callback to simplify your code:
 
   #### Bad
     ```ruby
     trx do
       user = User.find_or_initialize_by(email: email)
       if user.save
-        # May be invoked more than one time if transaction is retried        
+        # May be invoked more than one time if transaction is retried
         Mailer.registration_confirmation(user.id).deliver_later 
       end
-    end  
+    end
     ```
 
   #### Good (before refactoring)
@@ -256,10 +257,10 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
 
   #### Good (after refactoring)
     ```ruby
-    trx do |c|
+    trx do |t|
       user = User.find_or_initialize_by(email: email)
       if user.save
-        c.on_complete { Mailer.registration_confirmation(user.id).deliver_later }   
+        t.after_commit { Mailer.registration_confirmation(user.id).deliver_later }
       end
     end
     ```
@@ -273,11 +274,11 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
       User.deleted.find_each do |user|
         if user.created_at > 2.days.ago
           user.active!
-          resurrected_users_count += 1      
+          resurrected_users_count += 1
         end
       end
     end
-    puts resurrected_users_count    
+    puts resurrected_users_count
     ```
 
   #### Good
@@ -288,7 +289,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
       User.deleted.find_each do |user|
         if user.created_at > 2.days.ago
           user.active!
-          resurrected_users_count += 1      
+          resurrected_users_count += 1
         end
       end
     end
@@ -304,7 +305,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
           if @user.update(user_params)
             redirect_to @user
           else
-            render :edit                              
+            render :edit
           end
         end
       end
@@ -319,7 +320,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
         if @user.update(user_params)
           redirect_to @user
         else
-          render :edit                              
+          render :edit
         end
       end
     end
@@ -332,7 +333,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
         if @user.update(user_params)
           redirect_to @user
         else
-          render :edit                              
+          render :edit
         end
       end
     end
@@ -342,11 +343,11 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
     ```ruby
     class UsersController
       def update
-        trx do |c|
+        trx do |t|
           if @user.update(user_params)
-            c.on_complete { redirect_to @user }
+            t.after_commit { redirect_to @user }
           else
-            c.on_complete { render :edit }                              
+            t.after_commit { render :edit }
           end
         end
       end
@@ -377,7 +378,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
       if @post.tags_arr.include?('special')
         @post.update_columns(special: true)
       end
-      @post.mongo_post.update(special: @post.tags_arr.include?('special'))        
+      @post.mongo_post.update(special: @post.tags_arr.include?('special'))
     end
     ```
 
@@ -397,12 +398,12 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
   #### Bad
     ```ruby
     def some_method
-      trx do |c|
+      trx do |t|
         user = User.find_by(email: email)
         return user if user
         
         user = User.create(email: email)
-        c.on_complete { Mailer.registration_confirmation(user.id).deliver_later }
+        t.after_commit { Mailer.registration_confirmation(user.id).deliver_later }
       end
     end
     ```
@@ -414,7 +415,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
     def some_method
       puts "Start"
       yield
-      puts "End"      
+      puts "End"
     end
   
     def another_method
@@ -442,7 +443,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
     wrap_in_trx def some_method
       return if User.where(email: email).exists?
         
-      User.create(email: email)     
+      User.create(email: email)
     end
     ```
 
@@ -453,130 +454,7 @@ There is "On complete" feature that allows you to define callbacks(blocks of cod
       return user if user
       
       user = User.create(email: email)
-      trx { |c| c.on_complete { Mailer.registration_confirmation(user.id).deliver_later } }
-    end
-    ```
-
-## On complete callbacks
-
-On-complete callbacks are defined with `TrxExt::CallbackPool#on_complete` method. An instance of `TrxExt::CallbackPool` is passed in each transaction block. You may add as much on-complete callbacks as you want by calling `TrxExt::CallbackPool#on_complete` several times - they will be executed in the order you define
-them(FIFO principle). The on-complete callbacks from nested transactions will be executed from the most deep to the most top transaction. Another words, if top transaction defines `<#TrxExt::CallbackPool 0x1>` instance and nested transaction defines `<#TrxExt::CallbackPool 0x2>` instance then, when executing on-complete callbacks - the callbacks of `<#TrxExt::CallbackPool 0x2>` instance will be executed first(FILO principle).
-
-Example:
-
-```ruby
-ActiveRecord::Base.transaction do |c1|
-  User.first
-  c1.on_complete { puts "This is 3rd message" }
-  ActiveRecord::Base.transaction do |c2|
-    User.last
-    c2.on_complete { puts "This is 2nd message" }
-    ActiveRecord::Base.transaction do |c3|
-      c3.on_complete { puts "This is 1st message" }
-      User.first(2)
-    end
-  end
-  c1.on_complete { puts "This is 4th message" }
-end
-```
-
-If you don't need to define on-complete callbacks - you may skip explicit definition of block's argument.
-
-Example:
-
-```ruby
-ActiveRecord::Base.transaction { User.first }
-```
-
-Keep in mind, that all on-complete callbacks are not a part of the transaction. If you want to make it transactional - you need to wrap it in another transaction.
-
-Example:
-
-```ruby
-ActiveRecord::Base.transaction do |c1|
-  User.first
-  c1.on_complete do
-    ActiveRecord::Base.transaction do
-      User.find_or_create_by(email: email)
-    end
-  end
-end
-```
-
-You may define on-complete callbacks inside another on-complete callbacks. You may define another transactions in
-on-complete callbacks. Just don't get confused in the order they are going to be executed.
-
-Example:
-
-```ruby
-ActiveRecord::Base.transaction do |c1|
-  User.first
-  c1.on_complete do
-    puts "This line will be executed first"
-    ActiveRecord::Base.transaction do |c2|
-      User.last
-      c2.on_complete do
-        puts "This line will be executed second"
-      end
-    end
-    puts "This line will be executed third"
-  end
-end
-```
-
-Also, please avoid usage of the callbacks that belong to one transaction in another transaction explicitly. This complicates the readability of the code.
-
-Example:
-
-```ruby
-ActiveRecord::Base.transaction do |c1|
-  User.first
-  c1.on_complete do
-    ActiveRecord::Base.transaction do
-      User.last
-      c1.on_complete do
-        puts "This will be executed at the time when parent transaction's on-complete callbacks are executed!"
-      end
-    end
-  end
-end
-```
-
-## On complete callbacks integrity
-
-* Don't define callbacks blocks as lambdas unless you are 100% sure what you are doing. Lambda has a bit different behaviour comparing to Proc. Refer to [ruby documentation](https://ruby-doc.org/core-2.6.5/Proc.html#class-Proc-label-Lambda+and+non-lambda+semantics).
-
-* When defining a callback - make sure that it does not depend on transaction's integrity. Another words - define it in a way like it is a normal code implementation outside the transaction:
-
-  #### Bad
-    ```ruby
-    trx do |c|
-      user = User.find(id)
-      user.referrals.create(referral_attrs)
-      c.on_complete do  
-        Mailer.new_referral(
-          user_id: user.id, total_referrals: user.referrals.count
-        ).deliver_later 
-      end
-    end
-    ```
-
-  #### Explanation
-  The example above introduces two issues:
-  - `on_complete` callback does not depend on the result of `user.referrals.create(referral_attrs)`. And it should - we only need to send the email only if referral is created. Solution - add the condition for the `on_complete` callback
-  - the number of user's referrals `user.referrals.count` is calculated inside `on_complete`, but it should be calculated within the transaction. Solution - calculate referrals count in transaction, extract its value into local variable and use that variable in the `on_complete` callback
-
-  #### Good
-    ```ruby
-    trx do |c|
-      user = User.find(id)
-      referral = user.referrals.create(referral_attrs)
-      if referral.persisted?
-        total_referrals = user.referrals.count
-        c.on_complete do 
-          Mailer.new_referral(user_id: user.id, total_referrals: total_referrals).deliver_later
-        end
-      end
+      trx { |t| t.after_commit { Mailer.registration_confirmation(user.id).deliver_later } }
     end
     ```
 
@@ -588,7 +466,7 @@ You can make any method atomic by wrapping it into transaction using `#wrap_in_t
 class ApplicationRecord < ActiveRecord::Base
   class << self
     wrap_in_trx :find_or_create_by
-    wrap_in_trx :find_or_create_by!    
+    wrap_in_trx :find_or_create_by!
   end
 
   wrap_in_trx def some_method
@@ -602,7 +480,7 @@ end
 ### Setup
 
 - After checking out the repo, run `bundle install` to install dependencies.
-- Run docker-compose using `docker-compose up` command - it starts necessary services
+- Run docker-compose using `docker compose up` command - it starts necessary services
 - Run next command to create dev and test databases:
 
 ```shell

data/bin/test_all_ar_versions

@@ -2,7 +2,7 @@
 
 # frozen_string_literal: true
 
-%w[7.1].each do |ar_version|
+%w[7.2].each do |ar_version|
   `rm Gemfile.lock`
   Process.waitpid(Kernel.spawn({ 'AR_VERSION' => ar_version }, "bundle install --quiet", close_others: true))
   Process.waitpid(Kernel.spawn({ 'AR_VERSION' => ar_version }, "rspec", close_others: true))

data/lib/trx_ext/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TrxExt
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/lib/trx_ext.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 require 'active_record'
-require_relative "trx_ext/callback_pool"
 require_relative "trx_ext/object_ext"
 require_relative "trx_ext/retry"
-require_relative "trx_ext/transaction"
 require_relative "trx_ext/config"
 require_relative "trx_ext/version"
 
@@ -39,12 +37,12 @@ module TrxExt
     private
 
     def integrate_into_class(klass)
-      klass.prepend TrxExt::Transaction
       TrxExt::Retry.with_retry_until_serialized(klass, :exec_query)
       TrxExt::Retry.with_retry_until_serialized(klass, :exec_insert)
       TrxExt::Retry.with_retry_until_serialized(klass, :exec_delete)
       TrxExt::Retry.with_retry_until_serialized(klass, :exec_update)
       TrxExt::Retry.with_retry_until_serialized(klass, :exec_insert_all)
+      TrxExt::Retry.with_retry_until_serialized(klass, :transaction)
     end
   end
 end

data/trx_ext.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = "Allow you to retry deadlocks, serialization errors, non-unique errors."
   spec.homepage      = "https://github.com/intale/trx_ext"
   spec.license       = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
+  spec.required_ruby_version = ">= 3.1.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
@@ -31,5 +31,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activerecord', '>= 7.1'
+  spec.add_dependency 'activerecord', '>= 7.2', '< 8'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trx_ext
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
 description: Allow you to retry deadlocks, serialization errors, non-unique errors.
 email:
 - ivan.dzyzenko@gmail.com
@@ -89,11 +95,9 @@ files:
 - dummy_app/tmp/.keep
 - dummy_app/vendor/.keep
 - lib/trx_ext.rb
-- lib/trx_ext/callback_pool.rb
 - lib/trx_ext/config.rb
 - lib/trx_ext/object_ext.rb
 - lib/trx_ext/retry.rb
-- lib/trx_ext/transaction.rb
 - lib/trx_ext/version.rb
 - log/.gitkeep
 - trx_ext.gemspec
@@ -103,8 +107,8 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/intale/trx_ext
-  source_code_uri: https://github.com/intale/trx_ext/tree/v2.0.0
-  changelog_uri: https://github.com/intale/trx_ext/blob/v2.0.0/CHANGELOG.md
+  source_code_uri: https://github.com/intale/trx_ext/tree/v3.0.0
+  changelog_uri: https://github.com/intale/trx_ext/blob/v3.0.0/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -113,7 +117,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/trx_ext/callback_pool.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module TrxExt
-  class CallbackPool
-    class << self
-      # @param :previous [nil, TrxExt::CallbackPool]
-      # @return [TrxExt::CallbackPool]
-      def add(previous: nil)
-        # It may happen when transaction is defined inside `on_complete` callback and, thus, when adding the
-        # `on_complete` callback for it, `previous` will point on the `TrxExt::CallbackPool` of the transaction's
-        # callback that is being executing right now. We should not continue such chain and allow the transaction to
-        # build its own chain.
-        # Example:
-        #   trx do |c1|
-        #     c1.on_complete do
-        #       # When executing .add to define c2 TrxExt::CallbackPool - previous argument will contain
-        #       # c1 TrxExt::CallbackPool that is already being executing. Assign nil to previous in this case.
-        #       trx do |c2|
-        #         c2.on_complete { }
-        #       end
-        #     end
-        #   end
-        previous = nil if previous&.locked_for_execution?
-        inst = new
-        inst.previous = previous
-        inst
-      end
-    end
-
-    # Points on the previous instance in the single linked chain
-    attr_accessor :previous
-    attr_writer :locked_for_execution
-
-    def initialize
-      @callbacks = []
-      @locked_for_execution = false
-    end
-
-    # @return [Boolean] whether current instance is locked for the next {#exec_callbacks} action
-    def locked_for_execution?
-      @locked_for_execution
-    end
-
-    # @param blk [Proc]
-    # @return [void]
-    def on_complete(&blk)
-      @callbacks.push(blk)
-    end
-
-    # The chain of callbacks pool comes as follows:
-    # <#TrxExt::CallbackPool:0x03 @callbacks=[] previous=
-    #   <#TrxExt::CallbackPool:0x02 @callbacks=[] previous=
-    #     <#TrxExt::CallbackPool:0x01 @callbacks=[] previous=nil>
-    #   >
-    # >
-    # The most inner instance - is the instance that was created first in stack call. The most top instance - is the
-    # instance that was created last in the stack call.
-    # Related example of how they are created during `trx` calls:
-    #   trx do |c0x01|
-    #     trx do |c0x02|
-    #       trx do |c0x03|
-    #       end
-    #     end
-    #   end
-    #
-    # At the end of execution of each `trx` - {#exec_callbacks_chain} will be called for each {TrxExt::CallbackPool}.
-    # But only <#TrxExt::CallbackPool:0x01> will really execute the callbacks of all pools in the chain - only it has
-    # rights to do this, because only it stands on the top of the call stack. This is ensured with
-    # `return unless previous.nil?` condition. At the moment of execution of {#exec_callbacks_chain} of top-stack
-    # instance - {ActiveRecord::Base.connection.current_callbacks_chain_link} points on the most inner, by call stack,
-    # {TrxExt::CallbackPool}. In the example above, it is <#TrxExt::CallbackPool:0x03>
-    #
-    # @param :connection [ActiveRecord::ConnectionAdapters::PostgreSQLAdapter]
-    # @return [Boolean] whether callbacks was executed
-    def exec_callbacks_chain(connection:)
-      return false unless previous.nil?
-
-      current = connection.current_callbacks_chain_link
-      loop do
-        # It is important to keep it here to prevent potential
-        # `NoMethodError: undefined method `exec_callbacks' for nil:NilClass` exception when trying to execute callbacks
-        # for the transaction that raised an exception. In case of exception - current_callbacks_chain_link is set to
-        # nil. See {TrxExt::Retry.retry_until_serialized}. See {TrxExt::Transaction#transaction}.
-        # Example:
-        #   trx { raise "trol" } # Should raise RuntimeError instead of NoMethodError
-        break if current.nil?
-
-        current.locked_for_execution = true
-        current.exec_callbacks
-        current = current.previous
-      end
-      # Can't use `ensure` here, because it will be triggered even if condition in first line is falsey. And we need
-      # to set connection#current_callbacks_chain_link to nil only in case of exception or in case of successful run of
-      # callbacks
-      connection.current_callbacks_chain_link = nil
-      true
-    rescue
-      connection.current_callbacks_chain_link = nil
-      raise
-    end
-
-    # @return [void]
-    def exec_callbacks
-      @callbacks.each(&:call)
-      nil
-    end
-  end
-end

data/lib/trx_ext/transaction.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module TrxExt
-  # Implements the feature that allows you to define callbacks that will be fired after SQL transaction is complete.
-  module Transaction
-    # See https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/DatabaseStatements.html#method-i-transaction
-    # for available params
-    def transaction(**kwargs, &blk)
-      pool = nil
-      TrxExt::Retry.retry_until_serialized(self) do
-        super(**kwargs) do
-          pool = TrxExt::CallbackPool.add(previous: current_callbacks_chain_link)
-          self.current_callbacks_chain_link = pool
-          blk.call(pool)
-        end
-      rescue
-        self.current_callbacks_chain_link = nil
-        raise
-      end
-    ensure
-      pool.exec_callbacks_chain(connection: self)
-    end
-
-    # Returns the {TrxExt::CallbackPool} instance for the transaction that is being executed at the moment.
-    def current_callbacks_chain_link
-      @trx_callbacks_chain
-    end
-
-    # Set the {TrxExt::CallbackPool} instance for the transaction that is being executed at the moment.
-    def current_callbacks_chain_link=(val)
-      @trx_callbacks_chain = val
-    end
-  end
-end