edda-framework 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

edda/channels.py

@@ -445,15 +445,40 @@ async def publish(
     message_id = await storage.publish_to_channel(channel, data, full_metadata)
 
     # Wake up waiting subscribers
-    await _wake_waiting_subscribers(
-        storage,
-        channel,
-        message_id,
-        data,
-        full_metadata,
-        target_instance_id=target_instance_id,
-        worker_id=effective_worker_id,
-    )
+    # If in a transaction, defer delivery until after commit to ensure atomicity
+    if storage.in_transaction():
+        # Capture current values for the closure
+        _storage = storage
+        _channel = channel
+        _message_id = message_id
+        _data = data
+        _metadata = full_metadata
+        _target_instance_id = target_instance_id
+        _worker_id = effective_worker_id
+
+        async def deferred_wake() -> None:
+            await _wake_waiting_subscribers(
+                _storage,
+                _channel,
+                _message_id,
+                _data,
+                _metadata,
+                target_instance_id=_target_instance_id,
+                worker_id=_worker_id,
+            )
+
+        storage.register_post_commit_callback(deferred_wake)
+    else:
+        # Not in transaction - deliver immediately
+        await _wake_waiting_subscribers(
+            storage,
+            channel,
+            message_id,
+            data,
+            full_metadata,
+            target_instance_id=target_instance_id,
+            worker_id=effective_worker_id,
+        )
 
     return message_id
 

edda/context.py

@@ -5,7 +5,7 @@ This module provides the WorkflowContext class for workflow execution,
 managing state, history, and replay during workflow execution.
 """
 
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any, cast
 
@@ -451,6 +451,33 @@ class WorkflowContext:
         """
         return self.storage.in_transaction()
 
+    def register_post_commit(self, callback: Callable[[], Awaitable[None]]) -> None:
+        """
+        Register a callback to be executed after the current transaction commits.
+
+        The callback will be executed after the top-level transaction commits successfully.
+        If the transaction is rolled back, the callback will NOT be executed.
+        This is useful for deferring side effects (like message delivery) until after
+        the transaction has been committed.
+
+        Args:
+            callback: An async function to call after commit.
+
+        Raises:
+            RuntimeError: If not in a transaction.
+
+        Example:
+            async with ctx.transaction():
+                # Save order to database
+                await ctx.storage.append_history(...)
+
+                # Defer message delivery until after commit
+                async def deliver_notifications():
+                    await notify_subscribers(order_id)
+                ctx.register_post_commit(deliver_notifications)
+        """
+        self.storage.register_post_commit_callback(callback)
+
     async def recur(self, **kwargs: Any) -> None:
         """
         Restart the workflow with fresh history (Erlang-style tail recursion).

edda/storage/models.py

@@ -136,27 +136,6 @@ WORKFLOW_TIMER_SUBSCRIPTIONS_INDEXES = [
     "CREATE INDEX IF NOT EXISTS idx_timer_subscriptions_instance ON workflow_timer_subscriptions(instance_id);",
 ]
 
-# SQL schema for message subscriptions (for wait_message)
-WORKFLOW_MESSAGE_SUBSCRIPTIONS_TABLE = """
-CREATE TABLE IF NOT EXISTS workflow_message_subscriptions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    instance_id TEXT NOT NULL,
-    channel TEXT NOT NULL,
-    activity_id TEXT,
-    timeout_at TEXT,
-    created_at TEXT NOT NULL DEFAULT (datetime('now')),
-    FOREIGN KEY (instance_id) REFERENCES workflow_instances(instance_id) ON DELETE CASCADE,
-    CONSTRAINT unique_instance_channel UNIQUE (instance_id, channel)
-);
-"""
-
-# Indexes for message subscriptions
-WORKFLOW_MESSAGE_SUBSCRIPTIONS_INDEXES = [
-    "CREATE INDEX IF NOT EXISTS idx_message_subscriptions_channel ON workflow_message_subscriptions(channel);",
-    "CREATE INDEX IF NOT EXISTS idx_message_subscriptions_timeout ON workflow_message_subscriptions(timeout_at);",
-    "CREATE INDEX IF NOT EXISTS idx_message_subscriptions_instance ON workflow_message_subscriptions(instance_id);",
-]
-
 # SQL schema for group memberships (Erlang pg style)
 WORKFLOW_GROUP_MEMBERSHIPS_TABLE = """
 CREATE TABLE IF NOT EXISTS workflow_group_memberships (
@@ -306,7 +285,6 @@ ALL_TABLES = [
     WORKFLOW_HISTORY_ARCHIVE_TABLE,
     WORKFLOW_COMPENSATIONS_TABLE,
     WORKFLOW_TIMER_SUBSCRIPTIONS_TABLE,
-    WORKFLOW_MESSAGE_SUBSCRIPTIONS_TABLE,
     WORKFLOW_GROUP_MEMBERSHIPS_TABLE,
     OUTBOX_EVENTS_TABLE,
     # Channel-based Message Queue System
@@ -324,7 +302,6 @@ ALL_INDEXES = (
     + WORKFLOW_HISTORY_ARCHIVE_INDEXES
     + WORKFLOW_COMPENSATIONS_INDEXES
     + WORKFLOW_TIMER_SUBSCRIPTIONS_INDEXES
-    + WORKFLOW_MESSAGE_SUBSCRIPTIONS_INDEXES
     + WORKFLOW_GROUP_MEMBERSHIPS_INDEXES
     + OUTBOX_EVENTS_INDEXES
     # Channel-based Message Queue System

edda/storage/protocol.py

@@ -5,6 +5,7 @@ This module defines the StorageProtocol using Python's structural typing (Protoc
 Any storage implementation that conforms to this protocol can be used with Edda.
 """
 
+from collections.abc import Awaitable, Callable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
@@ -104,6 +105,21 @@ class StorageProtocol(Protocol):
         """
         ...
 
+    def register_post_commit_callback(self, callback: Callable[[], Awaitable[None]]) -> None:
+        """
+        Register a callback to be executed after the current transaction commits.
+
+        The callback will be executed after the top-level transaction commits successfully.
+        If the transaction is rolled back, the callback will NOT be executed.
+
+        Args:
+            callback: An async function to call after commit.
+
+        Raises:
+            RuntimeError: If not in a transaction.
+        """
+        ...
+
     # -------------------------------------------------------------------------
     # Workflow Definition Methods
     # -------------------------------------------------------------------------
@@ -713,39 +729,6 @@ class StorageProtocol(Protocol):
     # Message Subscription Methods (for wait_message)
     # -------------------------------------------------------------------------
 
-    async def register_message_subscription_and_release_lock(
-        self,
-        instance_id: str,
-        worker_id: str,
-        channel: str,
-        timeout_at: datetime | None = None,
-        activity_id: str | None = None,
-    ) -> None:
-        """
-        Atomically register message subscription and release workflow lock.
-
-        This method performs the following operations in a SINGLE database transaction:
-        1. Register message subscription (INSERT into workflow_message_subscriptions)
-        2. Update current activity (UPDATE workflow_instances.current_activity_id)
-        3. Update status to 'waiting_for_event'
-        4. Release lock (UPDATE workflow_instances set locked_by=NULL)
-
-        This ensures that when a workflow calls wait_message(), the subscription is
-        registered and the lock is released atomically, preventing race conditions
-        in distributed environments (distributed coroutines pattern).
-
-        Args:
-            instance_id: Workflow instance ID
-            worker_id: Worker ID that currently holds the lock
-            channel: Channel name to wait on
-            timeout_at: Optional timeout timestamp
-            activity_id: Current activity ID to record
-
-        Raises:
-            RuntimeError: If the worker doesn't hold the lock (sanity check)
-        """
-        ...
-
     async def find_waiting_instances_by_channel(
         self,
         channel: str,
@@ -911,9 +894,8 @@ class StorageProtocol(Protocol):
 
         Removes entries from:
         - workflow_timer_subscriptions
-        - workflow_message_subscriptions
-        - channel_subscriptions (new)
-        - channel_message_claims (new)
+        - channel_subscriptions
+        - channel_message_claims
 
         Args:
             instance_id: Workflow instance ID to clean up

edda/storage/sqlalchemy_storage.py

@@ -8,7 +8,7 @@ and transactional outbox pattern.
 
 import json
 import logging
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
@@ -285,31 +285,6 @@ class OutboxEvent(Base):
     )
 
 
-class WorkflowMessageSubscription(Base):
-    """Message subscriptions (for wait_message)."""
-
-    __tablename__ = "workflow_message_subscriptions"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    instance_id: Mapped[str] = mapped_column(String(255))
-    channel: Mapped[str] = mapped_column(String(255))
-    activity_id: Mapped[str | None] = mapped_column(String(255), nullable=True)
-    timeout_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
-
-    __table_args__ = (
-        ForeignKeyConstraint(
-            ["instance_id"],
-            ["workflow_instances.instance_id"],
-            ondelete="CASCADE",
-        ),
-        UniqueConstraint("instance_id", "channel", name="unique_instance_channel"),
-        Index("idx_message_subscriptions_channel", "channel"),
-        Index("idx_message_subscriptions_timeout", "timeout_at"),
-        Index("idx_message_subscriptions_instance", "instance_id"),
-    )
-
-
 class WorkflowGroupMembership(Base):
     """Group memberships (Erlang pg style for broadcast messaging)."""
 
@@ -508,6 +483,9 @@ class TransactionContext:
     session: "AsyncSession | None" = None
     """The actual session for this transaction"""
 
+    post_commit_callbacks: list[Callable[[], Awaitable[None]]] = field(default_factory=list)
+    """Callbacks to execute after successful top-level commit"""
+
 
 # Context variable for transaction state (asyncio-safe)
 _transaction_context: ContextVar[TransactionContext | None] = ContextVar(
@@ -861,7 +839,7 @@ class SQLAlchemyStorage:
         Example:
             >>> # SQLite: datetime(timeout_at) <= datetime('now')
             >>> # PostgreSQL/MySQL: timeout_at <= NOW()
-            >>> self._make_datetime_comparable(WorkflowMessageSubscription.timeout_at)
+            >>> self._make_datetime_comparable(ChannelSubscription.timeout_at)
             >>>     <= self._get_current_time_expr()
         """
         if self.engine.dialect.name == "sqlite":
@@ -913,11 +891,16 @@ class SQLAlchemyStorage:
         if ctx is None or ctx.depth == 0:
             raise RuntimeError("Not in a transaction")
 
+        # Capture callbacks before any state changes
+        callbacks_to_execute: list[Callable[[], Awaitable[None]]] = []
+
         if ctx.depth == 1:
             # Top-level transaction - commit the session
             logger.debug("Committing top-level transaction")
             await ctx.session.commit()  # type: ignore[union-attr]
             await ctx.session.close()  # type: ignore[union-attr]
+            # Capture callbacks to execute after clearing context
+            callbacks_to_execute = ctx.post_commit_callbacks.copy()
         else:
             # Nested transaction - commit the savepoint
             nested_tx = ctx.savepoint_stack.pop()
@@ -929,6 +912,12 @@ class SQLAlchemyStorage:
         if ctx.depth == 0:
             # All transactions completed - clear context
             _transaction_context.set(None)
+            # Execute post-commit callbacks after successful top-level commit
+            for callback in callbacks_to_execute:
+                try:
+                    await callback()
+                except Exception as e:
+                    logger.error(f"Post-commit callback failed: {e}")
 
     async def rollback_transaction(self) -> None:
         """
@@ -968,6 +957,26 @@ class SQLAlchemyStorage:
         ctx = _transaction_context.get()
         return ctx is not None and ctx.depth > 0
 
+    def register_post_commit_callback(self, callback: Callable[[], Awaitable[None]]) -> None:
+        """
+        Register a callback to be executed after the current transaction commits.
+
+        The callback will be executed after the top-level transaction commits successfully.
+        If the transaction is rolled back, the callback will NOT be executed.
+        If not in a transaction, the callback will be executed immediately.
+
+        Args:
+            callback: An async function to call after commit.
+
+        Raises:
+            RuntimeError: If not in a transaction.
+        """
+        ctx = _transaction_context.get()
+        if ctx is None or ctx.depth == 0:
+            raise RuntimeError("Cannot register post-commit callback: not in a transaction")
+        ctx.post_commit_callbacks.append(callback)
+        logger.debug(f"Registered post-commit callback: {callback}")
+
     async def _commit_if_not_in_transaction(self, session: AsyncSession) -> None:
         """
         Commit session if not in a transaction (auto-commit mode).
@@ -2247,12 +2256,17 @@ class SQLAlchemyStorage:
         Only running or waiting_for_event workflows can be cancelled.
         This method atomically:
         1. Checks current status
-        2. Updates status to 'cancelled' if allowed
+        2. Updates status to 'cancelled' if allowed (with atomic status check)
         3. Clears locks
         4. Records cancellation metadata
         5. Removes event subscriptions (if waiting for event)
         6. Removes timer subscriptions (if waiting for timer)
 
+        The UPDATE includes a status condition in WHERE clause to prevent
+        TOCTOU (time-of-check to time-of-use) race conditions. If the status
+        changes between SELECT and UPDATE, the UPDATE will affect 0 rows
+        and the cancellation will fail safely.
+
         Args:
             instance_id: Workflow instance to cancel
             cancelled_by: Who/what triggered the cancellation
@@ -2262,6 +2276,14 @@ class SQLAlchemyStorage:
 
         Note: Uses LOCK operation session (separate from external session).
         """
+        cancellable_statuses = (
+            "running",
+            "waiting_for_event",
+            "waiting_for_timer",
+            "waiting_for_message",
+            "compensating",
+        )
+
         session = self._get_session_for_operation(is_lock_operation=True)
         async with self._session_scope(session) as session, session.begin():
             # Get current instance status
@@ -2278,35 +2300,43 @@ class SQLAlchemyStorage:
 
             # Only allow cancellation of running, waiting, or compensating workflows
             # compensating workflows can be marked as cancelled after compensation completes
-            if current_status not in (
-                "running",
-                "waiting_for_event",
-                "waiting_for_timer",
-                "waiting_for_message",
-                "compensating",
-            ):
+            if current_status not in cancellable_statuses:
                 # Already completed, failed, or cancelled
                 return False
 
             # Update status to cancelled and record metadata
+            # IMPORTANT: Include status condition in WHERE clause to prevent TOCTOU race
+            # If another worker changed the status between SELECT and UPDATE,
+            # this UPDATE will affect 0 rows and we'll return False
             cancellation_metadata = {
                 "cancelled_by": cancelled_by,
                 "cancelled_at": datetime.now(UTC).isoformat(),
                 "previous_status": current_status,
             }
 
-            await session.execute(
+            update_result = await session.execute(
                 update(WorkflowInstance)
-                .where(WorkflowInstance.instance_id == instance_id)
+                .where(
+                    and_(
+                        WorkflowInstance.instance_id == instance_id,
+                        WorkflowInstance.status == current_status,  # Atomic check
+                    )
+                )
                 .values(
                     status="cancelled",
                     output_data=json.dumps(cancellation_metadata),
                     locked_by=None,
                     locked_at=None,
+                    lock_expires_at=None,
                     updated_at=func.now(),
                 )
             )
 
+            if update_result.rowcount == 0:  # type: ignore[attr-defined]
+                # Status changed between SELECT and UPDATE (race condition)
+                # Another worker may have resumed/modified the workflow
+                return False
+
             # Remove timer subscriptions if waiting for timer
             if current_status == "waiting_for_timer":
                 await session.execute(
@@ -2315,12 +2345,13 @@ class SQLAlchemyStorage:
                     )
                 )
 
-            # Remove message subscriptions if waiting for message
-            await session.execute(
-                delete(WorkflowMessageSubscription).where(
-                    WorkflowMessageSubscription.instance_id == instance_id
+            # Clear channel subscriptions if waiting for event/message
+            if current_status in ("waiting_for_event", "waiting_for_message"):
+                await session.execute(
+                    update(ChannelSubscription)
+                    .where(ChannelSubscription.instance_id == instance_id)
+                    .values(activity_id=None, timeout_at=None)
                 )
-            )
 
             return True
 
@@ -2328,100 +2359,6 @@ class SQLAlchemyStorage:
     # Message Subscription Methods
     # -------------------------------------------------------------------------
 
-    async def register_message_subscription_and_release_lock(
-        self,
-        instance_id: str,
-        worker_id: str,
-        channel: str,
-        timeout_at: datetime | None = None,
-        activity_id: str | None = None,
-    ) -> None:
-        """
-        Atomically register a message subscription and release the workflow lock.
-
-        This is called when a workflow executes wait_message() and needs to:
-        1. Verify lock ownership (RuntimeError if mismatch - full rollback)
-        2. Register a subscription for the channel
-        3. Update the workflow status to waiting_for_message
-        4. Release the lock
-
-        All operations happen in a single transaction for atomicity.
-
-        Args:
-            instance_id: Workflow instance ID
-            worker_id: Worker ID that must hold the current lock (verified before release)
-            channel: Channel name to subscribe to
-            timeout_at: Optional absolute timeout time
-            activity_id: Activity ID for the wait operation
-
-        Raises:
-            RuntimeError: If the worker does not hold the lock (entire operation rolls back)
-        """
-        session = self._get_session_for_operation(is_lock_operation=True)
-        async with self._session_scope(session) as session, session.begin():
-            # 1. Verify we hold the lock (sanity check - fail fast if not)
-            result = await session.execute(
-                select(WorkflowInstance.locked_by).where(
-                    WorkflowInstance.instance_id == instance_id
-                )
-            )
-            row = result.one_or_none()
-
-            if row is None:
-                raise RuntimeError(f"Workflow instance {instance_id} not found")
-
-            current_lock_holder = row[0]
-            if current_lock_holder != worker_id:
-                raise RuntimeError(
-                    f"Cannot release lock: worker {worker_id} does not hold lock "
-                    f"for {instance_id} (held by: {current_lock_holder})"
-                )
-
-            # 2. Register subscription (delete then insert for cross-database compatibility)
-            await session.execute(
-                delete(WorkflowMessageSubscription).where(
-                    and_(
-                        WorkflowMessageSubscription.instance_id == instance_id,
-                        WorkflowMessageSubscription.channel == channel,
-                    )
-                )
-            )
-
-            subscription = WorkflowMessageSubscription(
-                instance_id=instance_id,
-                channel=channel,
-                activity_id=activity_id,
-                timeout_at=timeout_at,
-            )
-            session.add(subscription)
-
-            # 3. Update workflow status and activity
-            await session.execute(
-                update(WorkflowInstance)
-                .where(WorkflowInstance.instance_id == instance_id)
-                .values(
-                    status="waiting_for_message",
-                    current_activity_id=activity_id,
-                    updated_at=func.now(),
-                )
-            )
-
-            # 4. Release the lock (with ownership check for extra safety)
-            await session.execute(
-                update(WorkflowInstance)
-                .where(
-                    and_(
-                        WorkflowInstance.instance_id == instance_id,
-                        WorkflowInstance.locked_by == worker_id,
-                    )
-                )
-                .values(
-                    locked_by=None,
-                    locked_at=None,
-                    lock_expires_at=None,
-                )
-            )
-
     async def find_waiting_instances_by_channel(self, channel: str) -> list[dict[str, Any]]:
         """
         Find all workflow instances waiting on a specific channel.
@@ -2434,9 +2371,13 @@ class SQLAlchemyStorage:
         """
         session = self._get_session_for_operation()
         async with self._session_scope(session) as session:
+            # Query ChannelSubscription table for waiting instances
             result = await session.execute(
-                select(WorkflowMessageSubscription).where(
-                    WorkflowMessageSubscription.channel == channel
+                select(ChannelSubscription).where(
+                    and_(
+                        ChannelSubscription.channel == channel,
+                        ChannelSubscription.activity_id.isnot(None),  # Only waiting subscriptions
+                    )
                 )
             )
             subscriptions = result.scalars().all()
@@ -2446,7 +2387,7 @@ class SQLAlchemyStorage:
                     "channel": sub.channel,
                     "activity_id": sub.activity_id,
                     "timeout_at": sub.timeout_at.isoformat() if sub.timeout_at else None,
-                    "created_at": sub.created_at.isoformat() if sub.created_at else None,
+                    "created_at": sub.subscribed_at.isoformat() if sub.subscribed_at else None,
                 }
                 for sub in subscriptions
             ]
@@ -2459,8 +2400,7 @@ class SQLAlchemyStorage:
         """
         Remove a message subscription.
 
-        This method removes from the legacy WorkflowMessageSubscription table
-        and clears waiting state from the ChannelSubscription table.
+        This method clears waiting state from the ChannelSubscription table.
 
         Args:
             instance_id: Workflow instance ID
@@ -2468,16 +2408,6 @@ class SQLAlchemyStorage:
         """
         session = self._get_session_for_operation()
         async with self._session_scope(session) as session:
-            # Remove from legacy WorkflowMessageSubscription table
-            await session.execute(
-                delete(WorkflowMessageSubscription).where(
-                    and_(
-                        WorkflowMessageSubscription.instance_id == instance_id,
-                        WorkflowMessageSubscription.channel == channel,
-                    )
-                )
-            )
-
             # Clear waiting state from ChannelSubscription table
             # Don't delete the subscription - just clear the waiting state
             await session.execute(
@@ -2527,10 +2457,11 @@ class SQLAlchemyStorage:
         session = self._get_session_for_operation()
         async with self._session_scope(session) as session:
             result = await session.execute(
-                select(WorkflowMessageSubscription).where(
+                select(ChannelSubscription).where(
                     and_(
-                        WorkflowMessageSubscription.instance_id == instance_id,
-                        WorkflowMessageSubscription.channel == channel,
+                        ChannelSubscription.instance_id == instance_id,
+                        ChannelSubscription.channel == channel,
+                        ChannelSubscription.activity_id.isnot(None),  # Only waiting subscriptions
                     )
                 )
             )
@@ -2555,10 +2486,13 @@ class SQLAlchemyStorage:
             async with self._session_scope(session) as session:
                 # Re-check subscription (may have been removed by another worker)
                 result = await session.execute(
-                    select(WorkflowMessageSubscription).where(
+                    select(ChannelSubscription).where(
                         and_(
-                            WorkflowMessageSubscription.instance_id == instance_id,
-                            WorkflowMessageSubscription.channel == channel,
+                            ChannelSubscription.instance_id == instance_id,
+                            ChannelSubscription.channel == channel,
+                            ChannelSubscription.activity_id.isnot(
+                                None
+                            ),  # Only waiting subscriptions
                         )
                     )
                 )
@@ -2607,14 +2541,16 @@ class SQLAlchemyStorage:
                 )
                 session.add(history_entry)
 
-                # Remove subscription
+                # Clear waiting state from subscription (don't delete)
                 await session.execute(
-                    delete(WorkflowMessageSubscription).where(
+                    update(ChannelSubscription)
+                    .where(
                         and_(
-                            WorkflowMessageSubscription.instance_id == instance_id,
-                            WorkflowMessageSubscription.channel == channel,
+                            ChannelSubscription.instance_id == instance_id,
+                            ChannelSubscription.channel == channel,
                         )
                     )
+                    .values(activity_id=None, timeout_at=None)
                 )
 
                 # Update status to 'running' (ready for resumption)
@@ -2641,8 +2577,6 @@ class SQLAlchemyStorage:
         """
         Find all message subscriptions that have timed out.
 
-        This method queries both the legacy WorkflowMessageSubscription table and
-        the ChannelSubscription table for expired subscriptions.
         JOINs with WorkflowInstance to ensure instance exists and avoid N+1 queries.
 
         Returns:
@@ -2650,47 +2584,8 @@ class SQLAlchemyStorage:
         """
         session = self._get_session_for_operation()
         async with self._session_scope(session) as session:
-            results: list[dict[str, Any]] = []
-
-            # Query legacy WorkflowMessageSubscription table with JOIN to verify instance exists
-            legacy_result = await session.execute(
-                select(
-                    WorkflowMessageSubscription.instance_id,
-                    WorkflowMessageSubscription.channel,
-                    WorkflowMessageSubscription.activity_id,
-                    WorkflowMessageSubscription.timeout_at,
-                    WorkflowMessageSubscription.created_at,
-                    WorkflowInstance.workflow_name,
-                )
-                .join(
-                    WorkflowInstance,
-                    WorkflowMessageSubscription.instance_id == WorkflowInstance.instance_id,
-                )
-                .where(
-                    and_(
-                        WorkflowMessageSubscription.timeout_at.isnot(None),
-                        self._make_datetime_comparable(WorkflowMessageSubscription.timeout_at)
-                        <= self._get_current_time_expr(),
-                    )
-                )
-            )
-            legacy_rows = legacy_result.all()
-            results.extend(
-                [
-                    {
-                        "instance_id": row[0],
-                        "channel": row[1],
-                        "activity_id": row[2],
-                        "timeout_at": row[3],
-                        "created_at": row[4],
-                        "workflow_name": row[5],
-                    }
-                    for row in legacy_rows
-                ]
-            )
-
             # Query ChannelSubscription table with JOIN
-            channel_result = await session.execute(
+            result = await session.execute(
                 select(
                     ChannelSubscription.instance_id,
                     ChannelSubscription.channel,
@@ -2712,22 +2607,18 @@ class SQLAlchemyStorage:
                     )
                 )
             )
-            channel_rows = channel_result.all()
-            results.extend(
-                [
-                    {
-                        "instance_id": row[0],
-                        "channel": row[1],
-                        "activity_id": row[2],
-                        "timeout_at": row[3],
-                        "created_at": row[4],  # subscribed_at as created_at for compatibility
-                        "workflow_name": row[5],
-                    }
-                    for row in channel_rows
-                ]
-            )
-
-            return results
+            rows = result.all()
+            return [
+                {
+                    "instance_id": row[0],
+                    "channel": row[1],
+                    "activity_id": row[2],
+                    "timeout_at": row[3],
+                    "created_at": row[4],  # subscribed_at as created_at for compatibility
+                    "workflow_name": row[5],
+                }
+                for row in rows
+            ]
 
     # -------------------------------------------------------------------------
     # Group Membership Methods (Erlang pg style)
@@ -2882,13 +2773,6 @@ class SQLAlchemyStorage:
                 )
             )
 
-            # Remove message subscriptions (legacy)
-            await session.execute(
-                delete(WorkflowMessageSubscription).where(
-                    WorkflowMessageSubscription.instance_id == instance_id
-                )
-            )
-
             # Remove channel subscriptions
             await session.execute(
                 delete(ChannelSubscription).where(ChannelSubscription.instance_id == instance_id)

{edda_framework-0.8.0.dist-info → edda_framework-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.8.0
+Version: 0.9.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -65,6 +65,7 @@ Description-Content-Type: text/markdown
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![Documentation](https://img.shields.io/badge/docs-latest-green.svg)](https://i2y.github.io/edda/)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/i2y/edda)
 
 ## Overview
 
@@ -665,72 +666,12 @@ async def order_with_timeout(ctx: WorkflowContext, order_id: str):
 
 **For technical details**, see [Multi-Worker Continuations](local-docs/distributed-coroutines.md).
 
-### Message Passing (Workflow-to-Workflow)
+### Channel-based Messaging
 
-Edda provides actor-model style message passing for direct workflow-to-workflow communication:
+Edda provides channel-based messaging for workflow-to-workflow communication with two delivery modes:
 
 ```python
-from edda import workflow, wait_message, send_message_to, WorkflowContext
-
-# Receiver workflow - waits for approval message
-@workflow
-async def approval_workflow(ctx: WorkflowContext, request_id: str):
-    # Wait for message on "approval" channel
-    msg = await wait_message(ctx, channel="approval")
-
-    if msg.data["approved"]:
-        return {"status": "approved", "approver": msg.data["approver"]}
-    return {"status": "rejected"}
-
-# Sender workflow - sends approval decision
-@workflow
-async def manager_workflow(ctx: WorkflowContext, request_id: str):
-    # Review and make decision
-    decision = await review_request(ctx, request_id)
-
-    # Send message to waiting workflow
-    await send_message_to(
-        ctx,
-        target_instance_id=request_id,
-        channel="approval",
-        data={"approved": decision, "approver": "manager-123"},
-    )
-```
-
-**Group Communication (Erlang pg style)** - for fan-out messaging without knowing receiver instance IDs:
-
-```python
-from edda import workflow, join_group, wait_message, publish_to_group
-
-# Receiver workflow - joins a group and listens
-@workflow
-async def notification_service(ctx: WorkflowContext, service_id: str):
-    # Join group at startup (loose coupling - sender doesn't need to know us)
-    await join_group(ctx, group="order_watchers")
-
-    while True:
-        msg = await wait_message(ctx, channel="order.created")
-        await send_notification(ctx, msg.data)
-
-# Sender workflow - publishes to all group members
-@workflow
-async def order_processor(ctx: WorkflowContext, order_id: str):
-    result = await process_order(ctx, order_id)
-
-    # Broadcast to all watchers (doesn't need to know instance IDs)
-    count = await publish_to_group(
-        ctx,
-        group="order_watchers",
-        channel="order.created",
-        data={"order_id": order_id, "status": "completed"},
-    )
-    print(f"Notified {count} watchers")
-```
-
-**Channel API with Delivery Modes** - subscribe to channels with explicit delivery semantics:
-
-```python
-from edda import workflow, subscribe, receive, publish, WorkflowContext
+from edda import workflow, subscribe, receive, publish, send_to, WorkflowContext
 
 # Job Worker - processes jobs exclusively (competing mode)
 @workflow
@@ -754,8 +695,11 @@ async def notification_handler(ctx: WorkflowContext, handler_id: str):
         await send_notification(ctx, msg.data)
         await ctx.recur(handler_id)
 
-# Publisher - send messages to channel
+# Publish to channel (all subscribers or one competing subscriber)
 await publish(ctx, channel="jobs", data={"task": "send_report"})
+
+# Direct message to specific workflow instance
+await send_to(ctx, instance_id="workflow-123", channel="approval", data={"approved": True})
 ```
 
 **Delivery modes**:
@@ -765,7 +709,7 @@ await publish(ctx, channel="jobs", data={"task": "send_report"})
 **Key features**:
 - **Channel-based messaging**: Messages are delivered to workflows waiting on specific channels
 - **Competing vs Broadcast**: Choose semantics per subscription
-- **Group communication**: Erlang pg-style groups for loose coupling and fan-out
+- **Direct messaging**: `send_to()` for workflow-to-workflow communication
 - **Database-backed**: All messages are persisted for durability
 - **Lock-first delivery**: Safe for multi-worker environments
 

{edda_framework-0.8.0.dist-info → edda_framework-0.9.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 edda/__init__.py,sha256=hGC6WR2R36M8LWC97F-0Rw4Ln0QUUT_1xC-7acOy_Fk,2237
 edda/activity.py,sha256=nRm9eBrr0lFe4ZRQ2whyZ6mo5xd171ITIVhqytUhOpw,21025
 edda/app.py,sha256=kZ-VEvjIe3GjUA8RhT6OimuezNyPf2IhrvQ2kL44zJs,45201
-edda/channels.py,sha256=ozaXCcWMLwgu_i6p8I79C9FnfsoQ0uv2BpaPPonTJdc,33863
+edda/channels.py,sha256=Budi0FyxalmcAMwj50mX3WzRce5OuLKXGws0Hp_snfw,34745
 edda/compensation.py,sha256=iKLlnTxiF1YSatmYQW84EkPB1yMKUEZBtgjuGnghLtY,11824
-edda/context.py,sha256=kxWok86IwLF7hvxlE803t7ayPySTzCKoW113TmwON1k,19752
+edda/context.py,sha256=IavmrbCdTAozP4QWlQ5-rCHR9yJAT-aohqyrOnbVLBU,20858
 edda/exceptions.py,sha256=-ntBLGpVQgPFG5N1o8m_7weejAYkNrUdxTkOP38vsHk,1766
 edda/hooks.py,sha256=HUZ6FTM__DZjwuomDfTDEroQ3mugEPuJHcGm7CTQNvg,8193
 edda/locking.py,sha256=NAFJmw-JaSVsXn4Y4czJyv_s9bWG8cdrzDBWIEag5X8,13661
@@ -25,9 +25,9 @@ edda/serialization/__init__.py,sha256=hnOVJN-mJNIsSa_XH9jwhIydOsWvIfCaFaSd37HUpl
 edda/serialization/base.py,sha256=xJy2CY9gdJDCF0tmCor8NomL2Lr_w7cveVvxccuc-tA,1998
 edda/serialization/json.py,sha256=Dq96V4n1yozexjCPd_CL6Iuvh1u3jJhef6sTcNxXZeA,2842
 edda/storage/__init__.py,sha256=Q-kNJsjF8hMc2Q5MYFlLBENKExlNlKkbmUkwBOosj9I,216
-edda/storage/models.py,sha256=E_KFygX6DP2qRwgLGLiKPhcXdKtvnfKeqA2kMXcAchE,13188
-edda/storage/protocol.py,sha256=0E5QSUDtSMlJX_lF6m3VAUx3WO6Qjm-Kq6_bXI7P52I,39841
-edda/storage/sqlalchemy_storage.py,sha256=eswQxCyY2DdUNYdrkxW_7Pev6CHCohNb72kGJjf29tA,140825
+edda/storage/models.py,sha256=vUwjiAOvp9uFNQgLK57kEGo7uzXplDZikOfnlOyed2M,12146
+edda/storage/protocol.py,sha256=NTUuLZ5_OlBiASaJIRuz5x7NykpCOjQgDWWNrRQzong,39021
+edda/storage/sqlalchemy_storage.py,sha256=KvSGapeKJ3hhClXNxFKHByD3Key5aidxBMUjs6-EJvE,136811
 edda/viewer_ui/__init__.py,sha256=N1-T33SXadOXcBsDSgJJ9Iqz4y4verJngWryQu70c5c,517
 edda/viewer_ui/app.py,sha256=CqHKsUj5pcysHCk0aRfkEqV4DIV4l3GzOPKBJ5DTYOQ,95624
 edda/viewer_ui/components.py,sha256=A0IxLwgj_Lu51O57OfzOwME8jzoJtKegEVvSnWc7uPo,45174
@@ -36,8 +36,8 @@ edda/viewer_ui/theme.py,sha256=mrXoXLRzgSnvE2a58LuMcPJkhlvHEDMWVa8Smqtk4l0,8118
 edda/visualizer/__init__.py,sha256=DOpDstNhR0VcXAs_eMKxaL30p_0u4PKZ4o2ndnYhiRo,343
 edda/visualizer/ast_analyzer.py,sha256=plmx7C9X_X35xLY80jxOL3ljg3afXxBePRZubqUIkxY,13663
 edda/visualizer/mermaid_generator.py,sha256=XWa2egoOTNDfJEjPcwoxwQmblUqXf7YInWFjFRI1QGo,12457
-edda_framework-0.8.0.dist-info/METADATA,sha256=o5ANdknKkLtOAGnKZ_IIQ0D3Q2iKyccdYVB-jjf8LLA,37506
-edda_framework-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-edda_framework-0.8.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.8.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.8.0.dist-info/RECORD,,
+edda_framework-0.9.0.dist-info/METADATA,sha256=esgoKFgUTWqAZWIHxgtKGl5j8VTaWiJw_oz93Dtm064,35741
+edda_framework-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+edda_framework-0.9.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.9.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.9.0.dist-info/RECORD,,