Support prepending callbacks

README.md

@@ -111,7 +111,7 @@ Will be executed right after transaction in which it have been declared was roll
 
 If called outside transaction will raise an exception!
 
-Please keep in mind ActiveRecord's [limitations for rolling back nested transactions](http://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#module-ActiveRecord::Transactions::ClassMethods-label-Nested+transactions). See [`in_transaction`](#in_transaction) for a workaround to this limitation. 
+Please keep in mind ActiveRecord's [limitations for rolling back nested transactions](http://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html#module-ActiveRecord::Transactions::ClassMethods-label-Nested+transactions). See [`in_transaction`](#in_transaction) for a workaround to this limitation.
 
 ### Available helper methods
 
@@ -139,7 +139,7 @@ class ServiceObjectBtw
 end
 ```
 
-Our service object can run its database operations safely when run in isolation. 
+Our service object can run its database operations safely when run in isolation.
 
 ```rb
 ServiceObjectBtw.new.call # This opens a new #transaction block
@@ -195,6 +195,8 @@ end
     - `:warn_and_execute` to print warning and execute immediately
     - `:raise` to raise an exception instead of executing
 
+- `prepend` puts the callback at the head of the callback chain, instead of at the end.
+
 ### FAQ
 
 #### Does it works with transactional_test or DatabaseCleaner

lib/after_commit_everywhere.rb

@@ -39,11 +39,13 @@ class << self
     # @param callback   [#call] Callback to be executed
     # @return           void
     def after_commit(
+      prepend: false,
       connection: nil,
       without_tx: EXECUTE,
       &callback
     )
       register_callback(
+        prepend: prepend,
         connection: connection,
         name: __method__,
         callback: callback,
@@ -64,6 +66,7 @@ def after_commit(
     # @param callback   [#call] Callback to be executed
     # @return           void
     def before_commit(
+      prepend: false,
       connection: nil,
       without_tx: WARN_AND_EXECUTE,
       &callback
@@ -73,6 +76,7 @@ def before_commit(
       end
 
       register_callback(
+        prepend: prepend,
         connection: connection,
         name: __method__,
         callback: callback,
@@ -90,8 +94,9 @@ def before_commit(
     # @param callback   [#call] Callback to be executed
     # @return           void
     # @raise            [NotInTransaction] if called outside transaction.
-    def after_rollback(connection: nil, &callback)
+    def after_rollback(prepend: false, connection: nil, &callback)
       register_callback(
+        prepend: prepend,
         connection: connection,
         name: __method__,
         callback: callback,
@@ -100,7 +105,7 @@ def after_rollback(connection: nil, &callback)
     end
 
     # @api private
-    def register_callback(connection: nil, name:, without_tx:, callback:)
+    def register_callback(prepend:, connection: nil, name:, without_tx:, callback:)
       raise ArgumentError, "Provide callback to #{name}" unless callback
 
       unless in_transaction?(connection)
@@ -119,7 +124,12 @@ def register_callback(connection: nil, name:, without_tx:, callback:)
 
       connection ||= default_connection
       wrap = Wrap.new(connection: connection, "#{name}": callback)
-      connection.add_transaction_record(wrap)
+
+      if prepend
+        connection.current_transaction.instance_variable_get(:@records).unshift(wrap)
+      else
+        connection.add_transaction_record(wrap)
+      end
     end
 
     # Helper method to determine whether we're currently in transaction or not

spec/after_commit_everywhere_spec.rb

@@ -28,6 +28,34 @@
     end
 
     context "within transaction" do
+      context 'when prepend is true' do
+        let(:handler_1) { spy("handler_1") }
+        let(:handler_2) { spy("handler_2") }
+
+        it 'executes prepended callback first' do
+          ActiveRecord::Base.transaction do
+            example_class.new.after_commit { handler_1.call }
+            example_class.new.after_commit(prepend: true) { handler_2.call }
+          end
+          expect(handler_2).to have_received(:call).ordered
+          expect(handler_1).to have_received(:call).ordered
+        end
+      end
+
+      context 'when prepend is not specified' do
+        let(:handler_1) { spy("handler_1") }
+        let(:handler_2) { spy("handler_2") }
+
+        it 'executes callbacks in the order they were defined' do
+          ActiveRecord::Base.transaction do
+            example_class.new.after_commit { handler_1.call }
+            example_class.new.after_commit { handler_2.call }
+          end
+          expect(handler_1).to have_received(:call).ordered
+          expect(handler_2).to have_received(:call).ordered
+        end
+      end
+
       it "executes code only after commit" do
         ActiveRecord::Base.transaction do
           subject