wappa 0.1.0__py3-none-any.whl

wappa/domain/interfaces/repository_factory.py

@@ -0,0 +1,108 @@
+"""
+Repository factory interface.
+
+Defines contract for creating context-aware repository instances.
+"""
+
+from abc import ABC, abstractmethod
+
+from .expiry_repository import IExpiryRepository
+from .pubsub_repository import IPubSubRepository
+from .shared_state_repository import ISharedStateRepository
+from .state_repository import IStateRepository
+from .tables_repository import ITablesRepository
+from .user_repository import IUserRepository
+
+
+class IRepositoryFactory(ABC):
+    """
+    Interface for creating context-aware repository instances.
+
+    Ensures all repositories are bound to the correct tenant and user context.
+    """
+
+    @abstractmethod
+    def create_user_repository(self, tenant_id: str, user_id: str) -> IUserRepository:
+        """
+        Create user repository with context binding.
+
+        Args:
+            tenant_id: Tenant identifier
+            user_id: User identifier
+
+        Returns:
+            Context-bound user repository instance
+        """
+        pass
+
+    @abstractmethod
+    def create_state_repository(self, tenant_id: str, user_id: str) -> IStateRepository:
+        """
+        Create state repository with context binding.
+
+        Args:
+            tenant_id: Tenant identifier
+            user_id: User identifier
+
+        Returns:
+            Context-bound state repository instance
+        """
+        pass
+
+    @abstractmethod
+    def create_shared_state_repository(
+        self, tenant_id: str, user_id: str
+    ) -> ISharedStateRepository:
+        """
+        Create shared state repository with context binding.
+
+        Args:
+            tenant_id: Tenant identifier
+            user_id: User identifier
+
+        Returns:
+            Context-bound shared state repository instance
+        """
+        pass
+
+    @abstractmethod
+    def create_expiry_repository(self, tenant_id: str) -> IExpiryRepository:
+        """
+        Create expiry repository with context binding.
+
+        Args:
+            tenant_id: Tenant identifier
+
+        Returns:
+            Context-bound expiry repository instance
+        """
+        pass
+
+    @abstractmethod
+    def create_pubsub_repository(
+        self, tenant_id: str, user_id: str | None = None
+    ) -> IPubSubRepository:
+        """
+        Create pub/sub repository with context binding.
+
+        Args:
+            tenant_id: Tenant identifier
+            user_id: Optional user identifier (for user-specific channels)
+
+        Returns:
+            Context-bound pub/sub repository instance
+        """
+        pass
+
+    @abstractmethod
+    def create_tables_repository(self, tenant_id: str) -> ITablesRepository:
+        """
+        Create tables repository with context binding.
+
+        Args:
+            tenant_id: Tenant identifier
+
+        Returns:
+            Context-bound tables repository instance
+        """
+        pass

wappa/domain/interfaces/shared_state_repository.py

@@ -0,0 +1,122 @@
+"""
+Shared state repository interface.
+
+Defines contract for shared state management in Redis.
+"""
+
+from abc import abstractmethod
+from datetime import timedelta
+from typing import Any
+
+from pydantic import BaseModel
+
+from .base_repository import IBaseRepository
+
+
+class ISharedStateRepository(IBaseRepository):
+    """
+    Interface for shared state management.
+
+    Handles shared state and tool scratch-space with context binding.
+    Uses the 'symphony_shared_state' Redis pool (database 3).
+    """
+
+    @abstractmethod
+    async def get_shared_state(
+        self,
+        state_name: str,
+        models: type[BaseModel] | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Get shared state for user with optional BaseModel deserialization.
+
+        Args:
+            state_name: Name of the state (e.g., 'conversation', 'context')
+            models: Optional BaseModel class for full object reconstruction
+
+        Returns:
+            Shared state dictionary or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_shared_state(
+        self,
+        state_name: str,
+        state_data: dict[str, Any],
+        ttl: timedelta | None = None,
+    ) -> bool:
+        """
+        Set shared state for user.
+
+        Args:
+            state_name: Name of the state
+            state_data: State data dictionary
+            ttl: Optional time-to-live
+
+        Returns:
+            True if successful
+        """
+        pass
+
+    @abstractmethod
+    async def get_state_field(self, state_name: str, field: str) -> Any | None:
+        """
+        Get specific field from shared state.
+
+        Args:
+            state_name: Name of the state
+            field: Field name
+
+        Returns:
+            Field value or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_state_field(self, state_name: str, field: str, value: Any) -> bool:
+        """
+        Set specific field in shared state.
+
+        Args:
+            state_name: Name of the state
+            field: Field name
+            value: Field value
+
+        Returns:
+            True if successful
+        """
+        pass
+
+    @abstractmethod
+    async def delete_shared_state(self, state_name: str) -> bool:
+        """
+        Delete complete shared state.
+
+        Args:
+            state_name: Name of the state
+
+        Returns:
+            True if state was deleted
+        """
+        pass
+
+    @abstractmethod
+    async def get_user_states(self) -> list[str]:
+        """
+        Get all active state names for user.
+
+        Returns:
+            List of state names
+        """
+        pass
+
+    @abstractmethod
+    async def clear_user_states(self) -> bool:
+        """
+        Clear all shared states for user.
+
+        Returns:
+            True if states were cleared
+        """
+        pass

wappa/domain/interfaces/state_repository.py

@@ -0,0 +1,123 @@
+"""
+State repository interface.
+
+Defines contract for handler state management in Redis.
+"""
+
+from abc import abstractmethod
+from datetime import timedelta
+from typing import Any
+
+from pydantic import BaseModel
+
+from .base_repository import IBaseRepository
+
+
+class IStateRepository(IBaseRepository):
+    """
+    Interface for handler state management.
+
+    Handles flow states and handler-specific data with context binding.
+    Uses the 'handlers' Redis pool (database 2).
+    """
+
+    @abstractmethod
+    async def get_handler_state(
+        self,
+        handler_type: str,
+        models: type[BaseModel] | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Get handler state for user with optional BaseModel deserialization.
+
+        Args:
+            handler_type: Type of handler (e.g., 'registration', 'reservation')
+            models: Optional BaseModel class for full object reconstruction
+                   e.g., DemoHotelRegistrationState (will automatically handle nested models)
+
+        Returns:
+            Handler state dictionary or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_handler_state(
+        self,
+        handler_type: str,
+        state_data: dict[str, Any],
+        ttl: timedelta | None = None,
+    ) -> bool:
+        """
+        Set handler state for user.
+
+        Args:
+            handler_type: Type of handler
+            state_data: State data dictionary
+            ttl: Optional time-to-live
+
+        Returns:
+            True if successful
+        """
+        pass
+
+    @abstractmethod
+    async def get_state_field(self, handler_type: str, field: str) -> Any | None:
+        """
+        Get specific field from handler state.
+
+        Args:
+            handler_type: Type of handler
+            field: Field name
+
+        Returns:
+            Field value or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_state_field(self, handler_type: str, field: str, value: Any) -> bool:
+        """
+        Set specific field in handler state.
+
+        Args:
+            handler_type: Type of handler
+            field: Field name
+            value: Field value
+
+        Returns:
+            True if successful
+        """
+        pass
+
+    @abstractmethod
+    async def delete_handler_state(self, handler_type: str) -> bool:
+        """
+        Delete complete handler state.
+
+        Args:
+            handler_type: Type of handler
+
+        Returns:
+            True if state was deleted
+        """
+        pass
+
+    @abstractmethod
+    async def get_user_handlers(self) -> list[str]:
+        """
+        Get all active handler types for user.
+
+        Returns:
+            List of handler type names
+        """
+        pass
+
+    @abstractmethod
+    async def clear_user_states(self) -> bool:
+        """
+        Clear all handler states for user.
+
+        Returns:
+            True if states were cleared
+        """
+        pass

wappa/domain/interfaces/tables_repository.py

@@ -0,0 +1,215 @@
+"""
+Tables repository interface.
+
+Defines contract for table data operations (generic DataFrames/rows).
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import BaseModel
+
+from .base_repository import IBaseRepository
+
+
+class ITablesRepository(IBaseRepository, ABC):
+    """
+    Interface for table data repository operations.
+
+    Provides contract for generic table/DataFrame data management,
+    following the existing RedisTable functionality patterns.
+    """
+
+    @abstractmethod
+    async def get_table_data(
+        self,
+        table_name: str,
+        pkid: str,
+        models: type[BaseModel] | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Get full table row data.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+            models: Optional BaseModel class for full object reconstruction
+
+        Returns:
+            Table row data dictionary or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_table_data(
+        self,
+        table_name: str,
+        pkid: str,
+        data: dict[str, Any],
+        ttl: int | None = None,
+    ) -> bool:
+        """
+        Set table row data (upsert behavior).
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+            data: Data to store
+            ttl: Optional TTL in seconds
+
+        Returns:
+            True if stored successfully
+        """
+        pass
+
+    @abstractmethod
+    async def get_table_field(
+        self, table_name: str, pkid: str, field: str
+    ) -> Any | None:
+        """
+        Get a specific field from table row data.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+            field: Field name to retrieve
+
+        Returns:
+            Field value or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def update_table_field(
+        self,
+        table_name: str,
+        pkid: str,
+        field: str,
+        value: Any,
+        ttl: int | None = None,
+    ) -> bool:
+        """
+        Update single field in table row.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+            field: Field name to update
+            value: New field value
+            ttl: Optional TTL in seconds
+
+        Returns:
+            True if updated successfully
+        """
+        pass
+
+    @abstractmethod
+    async def increment_table_field(
+        self,
+        table_name: str,
+        pkid: str,
+        field: str,
+        increment: int = 1,
+        ttl: int | None = None,
+    ) -> int | None:
+        """
+        Atomically increment integer field.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+            field: Field name to increment
+            increment: Amount to increment by (default: 1)
+            ttl: Optional TTL in seconds
+
+        Returns:
+            New field value after increment, or None if failed
+        """
+        pass
+
+    @abstractmethod
+    async def append_to_table_list_field(
+        self,
+        table_name: str,
+        pkid: str,
+        field: str,
+        value: Any,
+        ttl: int | None = None,
+    ) -> bool:
+        """
+        Append value to list field.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+            field: Field name containing the list
+            value: Value to append
+            ttl: Optional TTL in seconds
+
+        Returns:
+            True if appended successfully
+        """
+        pass
+
+    @abstractmethod
+    async def table_data_exists(self, table_name: str, pkid: str) -> bool:
+        """
+        Check if table row exists.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+
+        Returns:
+            True if table row exists
+        """
+        pass
+
+    @abstractmethod
+    async def delete_table_data(self, table_name: str, pkid: str) -> int:
+        """
+        Delete table row.
+
+        Args:
+            table_name: Name of the table
+            pkid: Primary key identifier
+
+        Returns:
+            Number of keys deleted
+        """
+        pass
+
+    @abstractmethod
+    async def find_table_by_field(
+        self,
+        table_name: str,
+        field: str,
+        value: Any,
+        models: type[BaseModel] | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Find first row in table where field matches value.
+
+        Args:
+            table_name: Name of the table
+            field: Field name to search
+            value: Value to match
+            models: Optional BaseModel class for full object reconstruction
+
+        Returns:
+            First matching row data or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def delete_all_tables_by_pkid(self, pkid: str) -> int:
+        """
+        Delete all table rows across all tables with same pkid.
+
+        Args:
+            pkid: Primary key identifier
+
+        Returns:
+            Number of keys deleted
+        """
+        pass

wappa/domain/interfaces/user_repository.py

@@ -0,0 +1,114 @@
+"""
+User repository interface.
+
+Defines contract for user state management in Redis.
+"""
+
+from abc import abstractmethod
+from datetime import timedelta
+from typing import Any
+
+from pydantic import BaseModel
+
+from .base_repository import IBaseRepository
+
+
+class IUserRepository(IBaseRepository):
+    """
+    Interface for user state management.
+
+    Handles user-specific data with context binding (tenant_id + user_id).
+    Uses the 'user' Redis pool (database 1).
+    """
+
+    @abstractmethod
+    async def get_user_data(
+        self, models: type[BaseModel] | None = None
+    ) -> dict[str, Any] | None:
+        """
+        Get complete user data hash with optional BaseModel deserialization.
+
+        Args:
+            models: Optional BaseModel class for full object reconstruction
+                   e.g., User (will automatically handle nested UserContact, UserLocation)
+
+        Returns:
+            User data dictionary or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_user_data(
+        self, data: dict[str, Any], ttl: timedelta | None = None
+    ) -> bool:
+        """
+        Set complete user data hash.
+
+        Args:
+            data: User data dictionary
+            ttl: Optional time-to-live
+
+        Returns:
+            True if successful
+        """
+        pass
+
+    @abstractmethod
+    async def get_user_field(self, field: str) -> Any | None:
+        """
+        Get specific field from user data.
+
+        Args:
+            field: Field name
+
+        Returns:
+            Field value or None if not found
+        """
+        pass
+
+    @abstractmethod
+    async def set_user_field(self, field: str, value: Any) -> bool:
+        """
+        Set specific field in user data.
+
+        Args:
+            field: Field name
+            value: Field value
+
+        Returns:
+            True if successful
+        """
+        pass
+
+    @abstractmethod
+    async def delete_user_field(self, field: str) -> bool:
+        """
+        Delete specific field from user data.
+
+        Args:
+            field: Field name
+
+        Returns:
+            True if field was deleted
+        """
+        pass
+
+    @abstractmethod
+    async def user_exists(self) -> bool:
+        """
+        Check if user data exists.
+
+        Returns:
+            True if user data exists
+        """
+        pass
+
+    @abstractmethod
+    async def delete_user(self) -> bool:
+        """
+        Delete all user data.
+
+        Returns:
+            True if user was deleted
+        """
+        pass

wappa/domain/interfaces/webhooks/__init__.py

@@ -0,0 +1 @@
+"""Webhook interface definitions."""