letschatty 0.4.329__py3-none-any.whl → 0.4.333__py3-none-any.whl

letschatty/models/data_base/collection_interface.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Dict, List, Generic, TypeVar, Type, Optional,
 from bson.objectid import ObjectId
 from pymongo.collection import Collection
 from pymongo.database import Database
+from motor.motor_asyncio import AsyncIOMotorDatabase, AsyncIOMotorCollection
 
 from letschatty.models.chat.chat import Chat
 from ...models.base_models.chatty_asset_model import ChattyAssetModel, CompanyAssetModel, ChattyAssetPreview
@@ -26,58 +27,116 @@ P = TypeVar('P', bound=ChattyAssetPreview)
 class ChattyAssetCollectionInterface(Generic[T, P], ABC):
     def __init__(self, database: str, collection: str, connection: MongoConnection, type: Type[T], preview_type: Optional[Type[P]] = None):
         logger.info(f"Initializing collection {collection} in database {database}")
+        # Sync database and collection (existing)
         self.db: Database = connection.client[database]
         self.collection: Collection = connection.client[database][collection]
+
+        # NEW: Async database and collection
+        # Store connection reference to ensure we use current event loop
+        self._connection = connection
+        self._database_name = database
+        self._collection_name = collection
+        self._async_db: Optional[AsyncIOMotorDatabase] = None
+        self._async_collection: Optional[AsyncIOMotorCollection] = None
+
         self.type = type
         self.preview_type = preview_type
+
+    @property
+    def async_db(self) -> AsyncIOMotorDatabase:
+        """Get async database, ensuring it uses the current event loop"""
+        # Always ensure connection's async client is using current loop (for Lambda compatibility)
+        self._connection._ensure_async_client_loop()
+        # Recreate database reference to ensure it uses the current client
+        self._async_db = self._connection.async_client[self._database_name]
+        return self._async_db
+
+    @property
+    def async_collection(self) -> AsyncIOMotorCollection:
+        """Get async collection, ensuring it uses the current event loop"""
+        # Always ensure connection's async client is using current loop (for Lambda compatibility)
+        self._connection._ensure_async_client_loop()
+        # Recreate collection reference to ensure it uses the current client
+        self._async_collection = self._connection.async_client[self._database_name][self._collection_name]
+        return self._async_collection
     @abstractmethod
     def create_instance(self, data: dict) -> T:
         """Factory method to create instance from data"""
         pass
 
-    def insert(self, asset: T) -> StrObjectId:
+    # All methods are now async-only for better performance
+    async def insert(self, asset: T) -> StrObjectId:
+        """Async insert operation"""
         if not isinstance(asset, self.type):
             raise ValueError(f"Asset must be of type {self.type.__name__}")
         document = asset.model_dump_json(serializer=SerializerType.DATABASE)
         logger.debug(f"Inserting document: {document}")
-        result = self.collection.insert_one(document)
+        result = await self.async_collection.insert_one(document)
         if not result.inserted_id:
             raise Exception("Failed to insert document")
         logger.debug(f"Inserted document with id {result.inserted_id}")
         return result.inserted_id
 
-    def update(self, asset: T) -> StrObjectId:
+    async def update(self, asset: T) -> StrObjectId:
+        """Async update operation"""
         logger.debug(f"Updating document with id {asset.id}")
         if not isinstance(asset, self.type):
             raise ValueError(f"Asset must be of type {self.type.__name__}")
         asset.update_now()
         document = asset.model_dump_json(serializer=SerializerType.DATABASE)
-        document.pop('_id', None)  # Still needed
-        result = self.collection.update_one({"_id": ObjectId(asset.id)}, {"$set": document})
+        document.pop('_id', None)
+        result = await self.async_collection.update_one(
+            {"_id": ObjectId(asset.id)},
+            {"$set": document}
+        )
         if result.matched_count == 0:
             raise NotFoundError(f"No document found with id {asset.id}")
         if result.modified_count == 0:
             logger.debug(f"No changes were made to the document with id {asset.id} probably because the values were the same")
         return asset.id
 
-    def get_by_id(self, doc_id: str) -> T:
-        logger.debug(f"Getting document with id {doc_id} from collection {self.collection.name} and db {self.db.name}")
-        doc = self.collection.find_one({"_id": ObjectId(doc_id)})
-
+    async def get_by_id(self, doc_id: str) -> T:
+        """Get by ID operation"""
+        logger.debug(f"Getting document with id {doc_id} from collection {self.async_collection.name}")
+        doc = await self.async_collection.find_one({"_id": ObjectId(doc_id)})
         if doc:
             return self.create_instance(doc)
         else:
-            raise NotFoundError(f"No document found with id {doc_id} in db collection {self.collection.name} and db {self.db.name}")
+            raise NotFoundError(f"No document found with id {doc_id} in collection")
 
-    def get_docs(self, company_id:Optional[StrObjectId], query = {}, limit = 0) -> List[T]:
-        logger.debug(f"Getting documents from collection {self.collection.name} with company_id {company_id} and query {query}")
+    async def get_docs(self, company_id: Optional[StrObjectId], query={}, limit=0) -> List[T]:
+        """Get multiple documents operation"""
+        logger.debug(f"Getting documents from collection with company_id {company_id} and query {query}")
         if company_id:
-            query = query.copy()  # Create a copy to avoid modifying the original
+            query = query.copy()
             query["company_id"] = company_id
-        docs = list(self.collection.find(filter=query).limit(limit))
-        logger.debug(f"Found {len(docs)} documents in collection {self.collection.name}")
+        cursor = self.async_collection.find(filter=query)
+        if limit:
+            cursor = cursor.limit(limit)
+        docs = await cursor.to_list(length=limit if limit > 0 else None)
+        logger.debug(f"Found {len(docs)} documents")
         return [self.create_instance(doc) for doc in docs]
 
+    async def delete(self, doc_id: str, deletion_type: DeletionType = DeletionType.LOGICAL) -> StrObjectId:
+        """Delete operation"""
+        logger.debug(f"Deleting document with id {doc_id} - deletion type: {deletion_type}")
+        if deletion_type == DeletionType.LOGICAL:
+            result = await self.async_collection.update_one(
+                {"_id": ObjectId(doc_id)},
+                {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC")), "updated_at": datetime.now(ZoneInfo("UTC"))}}
+            )
+            if result.modified_count == 0:
+                raise NotFoundError(f"No document found with id {doc_id}")
+            return doc_id
+        elif deletion_type == DeletionType.PHYSICAL:
+            result = await self.async_collection.delete_one({"_id": ObjectId(doc_id)})
+            if result.deleted_count == 0:
+                raise NotFoundError(f"No document found with id {doc_id}")
+            return doc_id
+        else:
+            raise ValueError(f"Invalid deletion type: {deletion_type}")
+
+    # Additional methods - keeping these sync as they're less critical
     def get_preview_docs(self, projection = {}, all=True) -> List[P]:
         """We get the previews of all the documents in the collection for all companies"""
         if not self.preview_type:
@@ -98,18 +157,31 @@ class ChattyAssetCollectionInterface(Generic[T, P], ABC):
         docs = self.collection.find(query)
         return [self.create_instance(doc) for doc in docs]
 
-    def delete(self, doc_id: str, deletion_type : DeletionType = DeletionType.LOGICAL) -> StrObjectId:
-        logger.debug(f"Deleting document with id {doc_id} - deletion type: {deletion_type}")
-        if deletion_type == DeletionType.LOGICAL:
-            result = self.collection.update_one({"_id": ObjectId(doc_id)}, {"$set": {"deleted_at": datetime.now(ZoneInfo("UTC")), "updated_at": datetime.now(ZoneInfo("UTC"))}})
-            if result.modified_count == 0:
-                raise NotFoundError(f"No document found with id {doc_id}")
-            return doc_id
-        elif deletion_type == DeletionType.PHYSICAL:
-            result = self.collection.delete_one({"_id": ObjectId(doc_id)})
-            if result.deleted_count == 0:
-                raise NotFoundError(f"No document found with id {doc_id}")
-            return doc_id
-        else:
-            raise ValueError(f"Invalid deletion type: {deletion_type}")
+    async def get_by_ids(self, ids: List[StrObjectId]) -> List[T]:
+            """
+            Get multiple assets by their IDs in a single query.
+
+            Args:
+                ids: List of asset IDs
+
+            Returns:
+                List of assets objects
+            """
+            if not ids:
+                return []
+
+            # Convert string IDs to ObjectIds
+            object_ids = [ObjectId(id) for id in ids]
+
+            # Query for all filter criteria with matching IDs
+            query = {
+                "_id": {"$in": object_ids},
+                "deleted_at": None
+            }
+
+            # Use the sync collection directly (inherited from ChattyAssetCollectionInterface)
+            docs = await self.async_collection.find(query).to_list(length=None)
+
+            # Create FilterCriteria instances
+            return [self.create_instance(doc) for doc in docs]
 

letschatty/models/data_base/mongo_connection.py

@@ -1,8 +1,14 @@
 from ..base_models.singleton import SingletonMeta
 from pymongo import MongoClient
+from motor.motor_asyncio import AsyncIOMotorClient
 from typing import Optional
+from urllib.parse import quote_plus
 import os
 import atexit
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
 
 class MongoConnection(metaclass=SingletonMeta):
     def __init__(
@@ -10,26 +16,103 @@ class MongoConnection(metaclass=SingletonMeta):
         username: Optional[str] = None,
         password: Optional[str] = None,
         uri_base: Optional[str] = None,
-        instance: Optional[str] = None
+        instance: Optional[str] = None,
+        verify_on_init: bool = True
     ):
         self.username = username or os.getenv('MONGO_USERNAME')
         self.password = password or os.getenv('MONGO_PASSWORD')
         self.uri_base = uri_base or os.getenv('MONGO_URI_BASE')
         self.instance = instance or os.getenv('MONGO_INSTANCE_COMPONENT')
-        
+
         if not all([self.username, self.password, self.uri_base, self.instance]):
             raise ValueError("Missing required MongoDB connection parameters")
-            
-        uri = f"{self.uri_base}://{self.username}:{self.password}@{self.instance}.mongodb.net"
+
+        # URL-encode username and password to handle special characters per RFC 3986
+        encoded_username = quote_plus(self.username)
+        encoded_password = quote_plus(self.password)
+
+        uri = f"{self.uri_base}://{encoded_username}:{encoded_password}@{self.instance}.mongodb.net"
+
+        # Sync client (existing)
         self.client = MongoClient(uri)
+
+        # NEW: Async client for async operations
+        # Don't pass io_loop - Motor will automatically use the current event loop
+        # This is important for Lambda where the event loop changes between invocations
+        self.async_client = AsyncIOMotorClient(uri)
+
+        # Verify connections if requested
+        if verify_on_init:
+            try:
+                # Try to get running loop
+                loop = asyncio.get_running_loop()
+                # If we get here, there's a running loop
+                logger.warning(
+                    "Event loop is already running. Skipping connection verification in __init__. "
+                    "Call verify_connection_async() from async context to verify connection."
+                )
+                self._connection_verified = False
+            except RuntimeError:
+                # No running loop, safe to use run_until_complete
+                try:
+                    # Test sync client
+                    self.client.admin.command('ping')
+
+                    # Test async client in sync context
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    loop.run_until_complete(self.async_client.admin.command('ping'))
+                    self._connection_verified = True
+                    loop.close()
+                except Exception as e:
+                    self.client.close()
+                    self.async_client.close()
+                    raise ConnectionError(f"Failed to connect to MongoDB: {str(e)}")
+        else:
+            self._connection_verified = False
+
+        atexit.register(self.close)
+
+    def _ensure_async_client_loop(self):
+        """Ensure async client is using the current event loop (for Lambda compatibility)"""
         try:
-            self.client.admin.command('ping')
+            current_loop = asyncio.get_running_loop()
+            # Check if client's loop is closed or different
+            client_loop = getattr(self.async_client, '_io_loop', None)
+            if client_loop is not None:
+                try:
+                    # Try to check if the loop is closed
+                    if client_loop.is_closed():
+                        # Recreate client with current loop
+                        logger.warning("Async client's event loop is closed, recreating client")
+                        old_client = self.async_client
+                        uri = f"{self.uri_base}://{quote_plus(self.username)}:{quote_plus(self.password)}@{self.instance}.mongodb.net"
+                        self.async_client = AsyncIOMotorClient(uri)
+                        try:
+                            old_client.close()
+                        except:
+                            pass
+                except AttributeError:
+                    # _io_loop might not exist in newer Motor versions
+                    pass
+        except RuntimeError:
+            # No running loop, which is fine - Motor will handle it
+            pass
+
+    async def verify_connection_async(self) -> bool:
+        """Verify MongoDB connection asynchronously. Safe to call from async context."""
+        try:
+            # Ensure we're using the current event loop
+            self._ensure_async_client_loop()
+            await self.async_client.admin.command('ping')
+            self._connection_verified = True
+            return True
         except Exception as e:
-            self.client.close()
-            raise ConnectionError(f"Failed to connect to MongoDB: {str(e)}")
+            logger.error(f"Failed to verify MongoDB connection: {e}")
+            raise ConnectionError(f"Failed to verify MongoDB connection: {e}")
 
-        atexit.register(self.close)
-    
     def close(self) -> None:
         if hasattr(self, 'client'):
             self.client.close()
+        if hasattr(self, 'async_client'):
+            self.async_client.close()

letschatty/models/utils/custom_exceptions/custom_exceptions.py

@@ -5,6 +5,7 @@ import json
 from datetime import timedelta
 
 from letschatty.models.utils.definitions import Area
+from pydantic_core.core_schema import custom_error_schema
 logger = logging.getLogger("logger")
 
 class Context(BaseModel):
@@ -229,4 +230,16 @@ class OpenAIError(CustomException):
 
 class NewerAvailableMessageToBeProcessedByAiAgent(CustomException):
     def __init__(self, message="Duplicated incoming message call for ai agent", status_code=400, **context_data):
-        super().__init__(message, status_code=status_code, **context_data)
+        super().__init__(message, status_code=status_code, **context_data)
+
+class MissingAIAgentInChat(CustomException):
+    def __init__(self, message="Missing AI agent in chat", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
+class ChattyAIModeOff(CustomException):
+    def __init__(self, message="Chatty AI agent is in OFF mode", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)
+
+class ChatWithActiveContinuousConversation(CustomException):
+    def __init__(self, message="Chat has active continuous conversation", status_code=400, **context_data):
+        super().__init__(message, status_code=status_code, **context_data)

letschatty/services/ai_agents/smart_follow_up_context_builder_v2.py

@@ -14,13 +14,16 @@ class SmartFollowUpContextBuilder(ContextBuilder):
 
     @staticmethod
     def check_minimum_time_since_last_message(chat: Chat, follow_up_strategy: FollowUpStrategy,smart_follow_up_state: FlowStateAssignedToChat) -> bool:
-        expected_interval_minutes = follow_up_strategy.get_interval_for_followup(smart_follow_up_state.consecutive_count)
+        # consecutive_count is 0-indexed (0 = no follow-ups sent yet), but get_interval_for_followup expects 1-indexed
+        # So we add 1 to get the interval for the follow-up we're about to send
+        next_followup_number = smart_follow_up_state.consecutive_count + 1
+        expected_interval_minutes = follow_up_strategy.get_interval_for_followup(next_followup_number)
         last_message_timestamp = chat.last_message_timestamp
         if last_message_timestamp is None:
             raise HumanInterventionRequired("There's no last message in the chat, can't validate the minimum time since last message for the smart follow up")
         time_since_last_message = datetime.now(ZoneInfo('UTC')) - last_message_timestamp
         if time_since_last_message.total_seconds() < expected_interval_minutes * 60:
-            raise PostponeFollowUp(time_delta= timedelta(seconds=expected_interval_minutes * 60 - time_since_last_message.total_seconds()), message=f"Se pospuso el Smart Follow Up porque no ha pasado el tiempo mínimo esperado de {expected_interval_minutes/60} horas para el seguimiento #{smart_follow_up_state.consecutive_count}")
+            raise PostponeFollowUp(time_delta= timedelta(seconds=expected_interval_minutes * 60 - time_since_last_message.total_seconds()), message=f"Se pospuso el Smart Follow Up porque no ha pasado el tiempo mínimo esperado de {expected_interval_minutes/60} horas para el seguimiento #{next_followup_number}")
         return True
 
 

letschatty/services/chatty_assets/__init__.py

@@ -1,2 +1,14 @@
 from .base_container import ChattyAssetBaseContainer
 from .base_container_with_collection import ChattyAssetContainerWithCollection
+from .assets_collections import AssetsCollections
+from .services import (
+    ProductService,
+    TagService,
+    UserService,
+    ChatService,
+    SourceService,
+    FlowService,
+    SaleService,
+    ContactPointService,
+    AiAgentService
+)

letschatty/services/chatty_assets/asset_service.py

@@ -1,11 +1,22 @@
 from __future__ import annotations
-from typing import TypeVar, Generic, Type, Callable, Protocol, Optional
+from typing import TypeVar, Generic, Type, Callable, Protocol, Optional, ClassVar, TYPE_CHECKING, List
+
+from bson import ObjectId
+from letschatty.models.utils.types import StrObjectId
 from .base_container_with_collection import ChattyAssetCollectionInterface, ChattyAssetContainerWithCollection, CacheConfig
 from ...models.base_models import ChattyAssetModel
 from ...models.base_models.chatty_asset_model import ChattyAssetPreview
 from ...models.data_base.mongo_connection import MongoConnection
 import logging
 import os
+
+if TYPE_CHECKING:
+    from ...models.analytics.events.base import EventType
+    from ...models.company.empresa import EmpresaModel
+    from ...models.execution.execution import ExecutionContext
+    from ...models.company.assets.company_assets import CompanyAssetType
+    from ...models.utils.types.deletion_type import DeletionType
+
 logger = logging.getLogger("AssetService")
 
 # Protocol for assets that specify their preview type
@@ -44,17 +55,75 @@ class AssetCollection(Generic[T, P], ChattyAssetCollectionInterface[T, P]):
             raise ValueError(f"Data must be a dictionary, got {type(data)}: {data}")
         return self._create_instance_method(data)
 
+
 class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
-    """Generic service for handling CRUD operations for any Chatty asset"""
+    """
+    Generic service for handling CRUD operations for any Chatty asset.
+
+    Supports optional automatic event handling for API implementations.
+    Set these class attributes to enable events:
+    - asset_type_enum: CompanyAssetType (e.g., CompanyAssetType.PRODUCTS)
+    - event_type_created: EventType (e.g., EventType.PRODUCT_CREATED)
+    - event_type_updated: EventType (e.g., EventType.PRODUCT_UPDATED)
+    - event_type_deleted: EventType (e.g., EventType.PRODUCT_DELETED)
+    """
+
+    # Optional: Set these in subclasses to enable automatic event handling
+    asset_type_enum: ClassVar[Optional['CompanyAssetType']] = None
+    event_type_created: ClassVar[Optional['EventType']] = None
+    event_type_updated: ClassVar[Optional['EventType']] = None
+    event_type_deleted: ClassVar[Optional['EventType']] = None
+
+    collection: AssetCollection[T, P]  # Type annotation for better type checking
 
     def __init__(self,
-                 collection_name: str,
-                 asset_type: Type[T],
-                 connection: MongoConnection,
-                 create_instance_method: Callable[[dict], T],
-                 preview_type: Optional[Type[P]] = None,
+                 collection: AssetCollection[T, P],
                  cache_config: CacheConfig = CacheConfig.default()):
-        logger.debug(f"AssetService {self.__class__.__name__} initializing for {collection_name}")
+        """
+        Initialize AssetService with a pre-configured collection.
+
+        The item_type and preview_type are automatically extracted from the collection,
+        eliminating redundancy and simplifying the API.
+
+        Args:
+            collection: Pre-configured AssetCollection subclass
+            cache_config: Cache configuration
+        """
+        logger.debug(f"AssetService {self.__class__.__name__} initializing with collection")
+        super().__init__(
+            item_type=collection.type,
+            preview_type=collection.preview_type,
+            collection=collection,
+            cache_config=cache_config,
+        )
+        logger.debug(f"AssetService {self.__class__.__name__} initialized")
+
+    @classmethod
+    def from_config(cls,
+                    collection_name: str,
+                    asset_type: Type[T],
+                    connection: MongoConnection,
+                    create_instance_method: Callable[[dict], T],
+                    preview_type: Optional[Type[P]] = None,
+                    cache_config: CacheConfig = CacheConfig.default()) -> 'AssetService[T, P]':
+        """
+        Create an AssetService using the legacy configuration pattern.
+
+        This class method is provided for backward compatibility.
+        New code should use pre-configured AssetCollection subclasses.
+
+        Args:
+            collection_name: MongoDB collection name
+            asset_type: The asset model type
+            connection: MongoDB connection
+            create_instance_method: Factory method to create asset instances
+            preview_type: Optional preview type
+            cache_config: Cache configuration
+
+        Returns:
+            AssetService instance
+        """
+        logger.debug(f"AssetService creating from config for {collection_name}")
         asset_collection = AssetCollection(
             collection=collection_name,
             asset_type=asset_type,
@@ -62,13 +131,102 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
             create_instance_method=create_instance_method,
             preview_type=preview_type
         )
-        super().__init__(
-            item_type=asset_type,
-            preview_type=preview_type,
+        return cls(
             collection=asset_collection,
-            cache_config=cache_config,
+            cache_config=cache_config
         )
-        logger.debug(f"AssetService {self.__class__.__name__} initialized for {collection_name}")
+
+    def _should_handle_events(self) -> bool:
+        """Check if this service should handle events automatically"""
+        return (self.asset_type_enum is not None and
+                self.event_type_created is not None and
+                self.event_type_updated is not None and
+                self.event_type_deleted is not None)
+
+    def _queue_event(self, item: T, event_type: 'EventType', execution_context: 'ExecutionContext', company_info: 'EmpresaModel'):
+        """Queue an event for this asset if event handling is enabled"""
+        if not self._should_handle_events() or not self.asset_type_enum:
+            return
+
+        try:
+            from ...services.factories.analytics.events_factory import EventFactory
+            from ...services.events import events_manager
+
+            # Type guard - company_id should exist on ChattyAssetModel
+            if not hasattr(item, 'company_id'):
+                logger.warning(f"Asset {type(item).__name__} missing company_id, skipping event")
+                return
+
+            events = EventFactory.asset_events(
+                company_id=item.company_id,  # type: ignore[attr-defined]
+                executor_id=execution_context.executor.id,
+                asset=item,
+                asset_type=self.asset_type_enum,
+                event_type=event_type,
+                time=execution_context.time,
+                trace_id=execution_context.trace_id,
+                executor_type=execution_context.executor.type,
+                company_info=company_info
+            )
+            events_manager.queue_events(events)
+        except ImportError:
+            # Events not available (microservice context) - skip
+            pass
+
+    # All methods are now async-only for better performance
+    async def insert(self, item: T, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Insert with automatic event handling if configured"""
+        result = await super().insert(item, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_created:
+            self._queue_event(result, self.event_type_created, execution_context, company_info)
+        return result
+
+    async def update(self, id: str, new_item: T, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Update with automatic event handling if configured"""
+        result = await super().update(id, new_item, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_updated:
+            self._queue_event(result, self.event_type_updated, execution_context, company_info)
+        return result
+
+    async def delete(self, id: str, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None, deletion_type: Optional['DeletionType'] = None) -> T:
+        """Delete with automatic event handling if configured"""
+        from ...models.utils.types.deletion_type import DeletionType as DT
+        result = await super().delete(id, execution_context, deletion_type or DT.LOGICAL)
+        if company_info and self._should_handle_events() and self.event_type_deleted:
+            self._queue_event(result, self.event_type_deleted, execution_context, company_info)
+        return result
+
+    async def restore(self, id: str, execution_context: 'ExecutionContext', company_info: Optional['EmpresaModel'] = None) -> T:
+        """Restore with automatic event handling if configured"""
+        result = await super().restore(id, execution_context)
+        if company_info and self._should_handle_events() and self.event_type_updated:
+            self._queue_event(result, self.event_type_updated, execution_context, company_info)
+        return result
+
+    # Generic convenience methods
+    async def create_asset(self, data: dict, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic create method - creates instance from dict and inserts with events.
+        Can be called as create_asset or aliased to create_product/create_tag/etc.
+        """
+        data["company_id"] = execution_context.company_id
+        item = self.collection.create_instance(data)
+        return await self.insert(item, execution_context, company_info)
+
+    async def update_asset(self, id: str, data: dict, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic update method - creates instance from dict and updates with events.
+        Can be called as update_asset or aliased to update_product/update_tag/etc.
+        """
+        new_item = self.collection.create_instance(data)
+        return await self.update(id, new_item, execution_context, company_info)
+
+    async def delete_asset(self, id: str, execution_context: 'ExecutionContext', company_info: 'EmpresaModel') -> T:
+        """
+        Generic delete method - deletes with events.
+        Can be called as delete_asset or aliased to delete_product/delete_tag/etc.
+        """
+        return await self.delete(id, execution_context, company_info)
 
     def get_preview_type(self) -> Type[P]:
         """Get the preview type from the asset class if it has one"""
@@ -81,3 +239,22 @@ class AssetService(Generic[T, P], ChattyAssetContainerWithCollection[T, P]):
         preview_type = self.get_preview_type()
         return super().get_preview_by_id(id, company_id, preview_type)
 
+    # Additional async read methods (passthrough to base class)
+    async def get_by_id(self, id: str) -> T:
+        """Get by ID"""
+        return await super().get_by_id(id)
+
+    async def get_all(self, company_id: str) -> List[T]:
+        """Get all for company"""
+        return await super().get_all(company_id)
+
+    async def get_by_query(self, query: dict, company_id: Optional[str]) -> List[T]:
+        """Get by query"""
+        return await super().get_by_query(query, company_id)
+
+    async def get_item_dumped(self, id: str) -> dict:
+        """Get item by ID and return as JSON serialized dict for frontend"""
+        from ...models.utils.types.serializer_type import SerializerType
+        item = await self.get_by_id(id)
+        return item.model_dump_json(serializer=SerializerType.FRONTEND)
+