shikibu 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d241ad341f0963dd1fe64cb61dc2a25a95fd8d0f01d12aef81c0372075dbcba
-  data.tar.gz: d287f1ee1f8f58a6a4b6f44565e54ad848792ec3005931fe77a55a187c7c7a6c
+  metadata.gz: 5b3b677128439973fcda2120c7377d1de6cc358bd4cd0b3fd9857e089d85de62
+  data.tar.gz: 6826b04fff743009f655282d55451c9850066116343c2da1211e7178d451ed6b
 SHA512:
-  metadata.gz: 39e4b6bbabb954eb6fd11ec715e91afff3b61ba2737c836332ed5161b6f5f9cbef2d30b72f3b08b96d76b96e05018e86127c88fffb8952a0aece2724e643a979
-  data.tar.gz: bc4cacdb7f83dc73a80468d0daa92af3bc23f69315b07836e12d195b48d46c4bbe5ed18374609cefe7fc8ba03cd3fde8fff9316b147646b85ff57bad99d637df
+  metadata.gz: 3d7c8eb5b7c2722cbb6569659c61fc02540ba5ef9d9d9da55281e9b482e0ff0a567b4434f309010d3faa35aed0ebd6592a97b77826410db3476a34dd80ea4d8b
+  data.tar.gz: 842f548cc2394a5a4a0aeb1641812c6e26f9e24d3f9f73bfeba6d262e3598429e102b560069897a75a6ea0ea9319c4fa27b67689c00714e5d6be3a5ccf6156e2

data/lib/shikibu/storage/sequel_storage.rb

@@ -33,8 +33,43 @@ module Shikibu
       # Transaction Management
       # ============================================
 
+      # Thread-local storage for transaction state
+      # Tracks nesting depth and post-commit callbacks
+      def transaction_state
+        Thread.current[:shikibu_tx_state] ||= { depth: 0, callbacks: [] }
+      end
+
+      # Register a callback to be executed after successful commit of the outermost transaction
+      # @param block [Proc] The callback to execute after commit
+      # @raise [RuntimeError] If called outside of a transaction
+      def register_post_commit_callback(&block)
+        raise 'Not in transaction' unless in_transaction?
+
+        transaction_state[:callbacks] << block
+      end
+
       def transaction(&)
-        @db.transaction(&)
+        state = transaction_state
+        state[:depth] += 1
+        committed = false
+
+        begin
+          result = @db.transaction(&)
+          committed = true
+
+          # Execute callbacks only after successful commit of outermost transaction
+          if state[:depth] == 1
+            callbacks = state[:callbacks].dup
+            state[:callbacks].clear
+            callbacks.each(&:call)
+          end
+
+          result
+        ensure
+          state[:depth] -= 1
+          # Clear callbacks on rollback (when not committed) at outermost level
+          state[:callbacks].clear if state[:depth].zero? && !committed
+        end
       end
 
       def in_transaction?
@@ -405,8 +440,15 @@ module Shikibu
           )
         end
 
-        # Send NOTIFY for new message
-        send_notify(Notify::Channel::CHANNEL_MESSAGE, { ch: channel, msg_id: message_id })
+        # Send NOTIFY for new message (deferred if in transaction)
+        notify_payload = { ch: channel, msg_id: message_id }
+        if in_transaction?
+          register_post_commit_callback do
+            send_notify(Notify::Channel::CHANNEL_MESSAGE, notify_payload)
+          end
+        else
+          send_notify(Notify::Channel::CHANNEL_MESSAGE, notify_payload)
+        end
 
         message_id
       end
@@ -588,8 +630,15 @@ module Shikibu
           )
         end
 
-        # Send NOTIFY for new outbox event
-        send_notify(Notify::Channel::OUTBOX_PENDING, { evt_id: event_id, evt_type: event_type })
+        # Send NOTIFY for new outbox event (deferred if in transaction)
+        notify_payload = { evt_id: event_id, evt_type: event_type }
+        if in_transaction?
+          register_post_commit_callback do
+            send_notify(Notify::Channel::OUTBOX_PENDING, notify_payload)
+          end
+        else
+          send_notify(Notify::Channel::OUTBOX_PENDING, notify_payload)
+        end
       end
 
       def get_pending_outbox_events(limit: 100)

data/lib/shikibu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shikibu
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/shikibu/workflow.rb

@@ -279,21 +279,24 @@ module Shikibu
     end
 
     def execute_single_compensation(comp, compensation_id)
-      comp[:block].call
-
-      # Record successful compensation (Romancy/Edda compatible format)
-      ctx.storage.append_history(
-        instance_id: ctx.instance_id,
-        activity_id: "compensation:#{compensation_id || comp[:activity_id]}",
-        event_type: EventType::COMPENSATION_EXECUTED,
-        event_data: {
-          compensation_id: compensation_id,
-          activity_id: comp[:activity_id],
-          activity_name: comp[:compensation_name]
-        }
-      )
+      # Execute compensation and record result atomically in a transaction
+      ctx.storage.transaction do
+        comp[:block].call
+
+        # Record successful compensation (Romancy/Edda compatible format)
+        ctx.storage.append_history(
+          instance_id: ctx.instance_id,
+          activity_id: "compensation:#{compensation_id || comp[:activity_id]}",
+          event_type: EventType::COMPENSATION_EXECUTED,
+          event_data: {
+            compensation_id: compensation_id,
+            activity_id: comp[:activity_id],
+            activity_name: comp[:compensation_name]
+          }
+        )
+      end
     rescue StandardError => e
-      # Record failed compensation but continue with others
+      # Record failed compensation but continue with others (outside transaction)
       ctx.storage.append_history(
         instance_id: ctx.instance_id,
         activity_id: "compensation:#{compensation_id || comp[:activity_id]}",
@@ -320,23 +323,28 @@ module Shikibu
           # Call hooks
           ctx.hooks&.on_activity_start&.call(ctx.instance_id, activity_id, name, attempt)
 
-          result = block.call
+          # Execute activity and record result atomically in a transaction
+          result = ctx.storage.transaction do
+            res = block.call
+
+            # Record successful result (atomic with activity execution)
+            ctx.storage.append_history(
+              instance_id: ctx.instance_id,
+              activity_id: activity_id,
+              event_type: EventType::ACTIVITY_COMPLETED,
+              event_data: { result: res }
+            )
 
-          # Record successful result
-          ctx.storage.append_history(
-            instance_id: ctx.instance_id,
-            activity_id: activity_id,
-            event_type: EventType::ACTIVITY_COMPLETED,
-            event_data: { result: result }
-          )
+            res
+          end
 
-          # Cache for replay
+          # Cache for replay (outside transaction)
           ctx.cache_result(activity_id, {
                              event_type: EventType::ACTIVITY_COMPLETED,
                              result: result
                            })
 
-          # Call hooks
+          # Call hooks (outside transaction)
           ctx.hooks&.on_activity_complete&.call(ctx.instance_id, activity_id, name, result, false)
 
           return result

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shikibu
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yasushi Itoh