letschatty 0.4.351__py3-none-any.whl → 0.4.353__py3-none-any.whl

letschatty/models/company/assets/automation.py

@@ -14,27 +14,18 @@ class Automation(BaseModel):
     chatty_ai_agent_config: Optional[ChattyAIConfigForAutomation] = Field(default=None)
     area: Optional[Area] = Field(default=None)
     agent_id: Optional[StrObjectId] = Field(default=None)
-    chain_of_thought : Optional[str] = Field(default=None)
+    chain_of_thought: Optional[str] = Field(default=None)
+    # Funnel transition automations
+    target_funnel_id: Optional[StrObjectId] = Field(
+        default=None,
+        description="Target funnel to move the chat to (for cross-funnel transitions)"
+    )
+    target_stage_id: Optional[StrObjectId] = Field(
+        default=None,
+        description="Target stage within the target funnel"
+    )
     # client_info: Optional[ClientInfo] = Field(default=None) me gustaría que levante el mail y/o otros atributos
 
-    @property
-    def has_automation(self) -> bool:
-        """
-        Check if there's an actual automation defined (tags, products, or flow).
-
-        Returns:
-            bool: True if there's at least one tag, product, or flow defined
-        """
-        return (
-            len(self.tags) > 0 or
-            len(self.products) > 0 or
-            len(self.flow) > 0 or
-            self.quality_score is not None or
-            self.chatty_ai_agent_config is not None or
-            self.area is not None or
-            self.highlight_description is not None
-        )
-
     @model_validator(mode='after')
     def check_agent_id(self):
         if self.area == Area.WITH_AGENT and not self.agent_id:

letschatty/models/company/assets/chat_assets.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from zoneinfo import ZoneInfo
 from bson import ObjectId
 import json
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 from letschatty.models.utils.types.serializer_type import SerializerType
 from letschatty.models.company.assets.ai_agents_v2.chatty_ai_mode import ChattyAIMode
 
@@ -67,7 +67,8 @@ class AssignedAssetToChat(BaseModel):
 
 
 class SaleAssignedToChat(AssignedAssetToChat):
-    product_id: StrObjectId = Field(frozen=True)
+    product_id: Optional[StrObjectId] = Field(default=None)
+    product_ids: List[StrObjectId] = Field(default_factory=list)
 
 class ContactPointAssignedToChat(AssignedAssetToChat):
     source_id: StrObjectId = Field(frozen=True)

letschatty/models/company/assets/company_assets.py

@@ -5,6 +5,8 @@ class CompanyAssetType(StrEnum):
     USERS = "users"
     BUSINESS_AREAS = "business_areas"
     FUNNELS = "funnels"
+    FUNNEL_STAGES = "funnel_stages"
+    FUNNEL_MEMBERS = "funnel_members"
     PRODUCTS = "products"
     SALES = "sales"
     TAGS = "tags"

letschatty/models/company/assets/sale.py

@@ -5,7 +5,7 @@ from ...utils.types.identifier import StrObjectId
 
 class Sale(CompanyAssetModel):
     chat_id: StrObjectId
-    product_id: StrObjectId
+    product_id: Optional[StrObjectId] = Field(default=None)
     quantity: int
     total_amount: float
     currency: str
@@ -16,7 +16,7 @@ class Sale(CompanyAssetModel):
     creator_id: StrObjectId
 
 class SaleRequest(BaseModel):
-    product_id: StrObjectId
+    product_id: Optional[StrObjectId] = Field(default=None)
     quantity: int
     creator_id: StrObjectId
     total_amount: float
@@ -36,4 +36,4 @@ class SaleRequest(BaseModel):
             "paid_amount": 100,
             "installments": 1,
             "details": {}
-        }
+        }

letschatty/models/company/empresa.py

@@ -1,3 +1,5 @@
+from letschatty.models.company.integrations.shopify.company_shopify_integration import ShopifyIntegration
+from letschatty.models.company.integrations.tienda_nube.company_tienda_nube_integration import TiendaNubeIntegration
 from pydantic import Field, ConfigDict, field_validator, SecretStr, model_validator
 from typing import Optional, List, Dict
 
@@ -34,7 +36,8 @@ class EmpresaModel(ChattyAssetModel):
     continuous_conversation_template_name: Optional[str] = Field(default = None, description="The name of the continuous conversation template")
     default_follow_up_strategy_id: Optional[StrObjectId] = Field(default = None, description="The id of the default follow up strategy")
     messaging_settings: MessagingSettings = Field(default = MessagingSettings(), description="The messaging settings for the company")
-
+    shopify_integration: ShopifyIntegration = Field(default = ShopifyIntegration(), description="The Shopify integration for the company")
+    tienda_nube_integration: TiendaNubeIntegration = Field(default = TiendaNubeIntegration(), description="The Tienda Nube integration for the company")
 
     model_config = ConfigDict(
         validate_by_name=True,

letschatty/models/company/integrations/product_sync_status.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import ClassVar, Optional
+
+from pydantic import Field
+
+from letschatty.models.company.integrations.sync_status_enum import SyncStatusEnum
+from letschatty.models.base_models import CompanyAssetModel
+
+
+class ProductSyncStatus(CompanyAssetModel):
+    """Generic product sync status for any e-commerce integration."""
+
+    COLLECTION: ClassVar[str] = "product_sync_statuses"
+
+    integration_type: str = Field(
+        description="Integration type (shopify, tiendanube, etc.)"
+    )
+    status: SyncStatusEnum = Field(description="Current sync status")
+
+    products_created: int = Field(default=0)
+    products_updated: int = Field(default=0)
+
+    name: str = Field(default="")
+
+    finished_at: Optional[datetime] = Field(default=None)
+

letschatty/models/company/integrations/shopify/company_shopify_integration.py

@@ -0,0 +1,62 @@
+from typing import List, Optional
+from datetime import datetime
+from zoneinfo import ZoneInfo
+from pydantic import BaseModel, Field
+
+class ShopifyWebhookSubscription(BaseModel):
+    """Represents a single webhook subscription"""
+    topic: str = Field(description="Webhook topic (e.g., 'products/create')")
+    webhook_id: Optional[str] = Field(default=None, description="Shopify webhook ID")
+    subscribed_at: datetime = Field(default_factory=lambda: datetime.now(tz=ZoneInfo("UTC")))
+    is_active: bool = Field(default=True, description="Whether subscription is active")
+
+class ShopifyIntegration(BaseModel):
+    """Shopify integration for the company"""
+    shopify_store_url: str = Field(default="")
+    oauth_state: str = Field(default="")
+    oauth_state_at: datetime = Field(default_factory=lambda: datetime.now(tz=ZoneInfo("UTC")))
+    access_token: Optional[str] = Field(default=None)
+    connected_at: Optional[datetime] = Field(default=None)
+    scope: Optional[str] = Field(default=None)
+    
+    # Webhook subscriptions
+    webhook_subscriptions: List[ShopifyWebhookSubscription] = Field(
+        default_factory=list,
+        description="List of active webhook subscriptions"
+    )
+    
+    # Scheduled sync settings
+    product_sync_enabled: bool = Field(
+        default=False,
+        description="Whether scheduled product sync is enabled"
+    )
+    product_sync_interval_hours: int = Field(
+        default=24,
+        description="Interval in hours for scheduled product sync"
+    )
+    last_product_sync_at: Optional[datetime] = Field(
+        default=None,
+        description="Timestamp of last product sync"
+    )
+    
+    @property
+    def is_connected(self) -> bool:
+        """Check if the integration is fully connected"""
+        return bool(self.access_token and self.shopify_store_url)
+    
+    def get_subscribed_topics(self) -> List[str]:
+        """Get list of currently subscribed webhook topics"""
+        return [sub.topic for sub in self.webhook_subscriptions if sub.is_active]
+    
+    def reset(self) -> None:
+        """Reset integration to disconnected state"""
+        self.shopify_store_url = ""
+        self.oauth_state = ""
+        self.oauth_state_at = datetime.now(tz=ZoneInfo("UTC"))
+        self.access_token = None
+        self.connected_at = None
+        self.scope = None
+        self.webhook_subscriptions = []
+        self.product_sync_enabled = False
+        self.product_sync_interval_hours = 24
+        self.last_product_sync_at = None

letschatty/models/company/integrations/shopify/shopify_product_sync_status.py

@@ -0,0 +1,18 @@
+from pydantic import Field
+
+from letschatty.models.company.integrations.product_sync_status import ProductSyncStatus
+from letschatty.models.company.integrations.sync_status_enum import SyncStatusEnum
+
+
+# Backwards-compatible alias (Shopify-specific name, generic enum)
+ShopifyProductSyncStatusEnum = SyncStatusEnum
+
+
+class ShopifyProductSyncStatus(ProductSyncStatus):
+    """Shopify-flavored wrapper for the generic ProductSyncStatus."""
+
+    integration_type: str = Field(
+        default="shopify",
+        frozen=True,
+        description="Integration type for this sync status"
+    )

letschatty/models/company/integrations/shopify/shopify_webhook_topics.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+class ShopifyWebhookTopic(str, Enum):
+    """Shopify webhook topics for products and orders"""
+    
+    # Product webhooks
+    PRODUCTS_CREATE = "products/create"
+    PRODUCTS_UPDATE = "products/update"
+    PRODUCTS_DELETE = "products/delete"
+    
+    # Order webhooks
+    ORDERS_CREATE = "orders/create"
+    ORDERS_UPDATE = "orders/updated"
+    ORDERS_DELETE = "orders/delete"
+    ORDERS_FULFILLED = "orders/fulfilled"
+    ORDERS_PARTIALLY_FULFILLED = "orders/partially_fulfilled"
+    ORDERS_PAID = "orders/paid"
+    ORDERS_CANCELLED = "orders/cancelled"
+    
+    @classmethod
+    def get_product_topics(cls) -> list[str]:
+        """Get all product-related webhook topics"""
+        return [
+            cls.PRODUCTS_CREATE.value,
+            cls.PRODUCTS_UPDATE.value,
+            cls.PRODUCTS_DELETE.value,
+        ]
+    
+    @classmethod
+    def get_order_topics(cls) -> list[str]:
+        """Get all order-related webhook topics"""
+        return [
+            cls.ORDERS_CREATE.value,
+            cls.ORDERS_UPDATE.value,
+            cls.ORDERS_DELETE.value,
+            cls.ORDERS_FULFILLED.value,
+            cls.ORDERS_PARTIALLY_FULFILLED.value,
+            cls.ORDERS_PAID.value,
+            cls.ORDERS_CANCELLED.value,
+        ]

letschatty/models/company/integrations/sync_status_enum.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SyncStatusEnum(str, Enum):
+    STARTED = "STARTED"
+    RUNNING = "RUNNING"
+    FINISHED = "FINISHED"
+    FAILED = "FAILED"
+

letschatty/models/company/integrations/tienda_nube/company_tienda_nube_integration.py

@@ -0,0 +1,62 @@
+from typing import List, Optional
+from datetime import datetime
+from zoneinfo import ZoneInfo
+from pydantic import BaseModel, Field
+
+class TiendaNubeWebhookSubscription(BaseModel):
+    """Represents a single webhook subscription"""
+    topic: str = Field(description="Webhook topic (e.g., 'product/created')")
+    webhook_id: Optional[str] = Field(default=None, description="Tienda Nube webhook ID")
+    subscribed_at: datetime = Field(default_factory=lambda: datetime.now(tz=ZoneInfo("UTC")))
+    is_active: bool = Field(default=True, description="Whether subscription is active")
+
+class TiendaNubeIntegration(BaseModel):
+    """Tienda Nube integration for the company"""
+    store_id: str = Field(default="")
+    oauth_state: str = Field(default="")
+    oauth_state_at: datetime = Field(default_factory=lambda: datetime.now(tz=ZoneInfo("UTC")))
+    access_token: Optional[str] = Field(default=None)
+    connected_at: Optional[datetime] = Field(default=None)
+    scope: Optional[str] = Field(default=None)
+    
+    # Webhook subscriptions
+    webhook_subscriptions: List[TiendaNubeWebhookSubscription] = Field(
+        default_factory=list,
+        description="List of active webhook subscriptions"
+    )
+    
+    # Scheduled sync settings
+    product_sync_enabled: bool = Field(
+        default=False,
+        description="Whether scheduled product sync is enabled"
+    )
+    product_sync_interval_hours: int = Field(
+        default=24,
+        description="Interval in hours for scheduled product sync"
+    )
+    last_product_sync_at: Optional[datetime] = Field(
+        default=None,
+        description="Timestamp of last product sync"
+    )
+    
+    @property
+    def is_connected(self) -> bool:
+        """Check if the integration is fully connected"""
+        return bool(self.access_token and self.store_id)
+    
+    def get_subscribed_topics(self) -> List[str]:
+        """Get list of currently subscribed webhook topics"""
+        return [sub.topic for sub in self.webhook_subscriptions if sub.is_active]
+    
+    def reset(self) -> None:
+        """Reset integration to disconnected state"""
+        self.store_id = ""
+        self.oauth_state = ""
+        self.oauth_state_at = datetime.now(tz=ZoneInfo("UTC"))
+        self.access_token = None
+        self.connected_at = None
+        self.scope = None
+        self.webhook_subscriptions = []
+        self.product_sync_enabled = False
+        self.product_sync_interval_hours = 24
+        self.last_product_sync_at = None

letschatty/models/company/integrations/tienda_nube/tienda_nube_product_sync_status.py

@@ -0,0 +1,18 @@
+from pydantic import Field
+
+from letschatty.models.company.integrations.product_sync_status import ProductSyncStatus
+from letschatty.models.company.integrations.sync_status_enum import SyncStatusEnum
+
+
+# Backwards-compatible alias (Tienda Nube-specific name, generic enum)
+TiendaNubeProductSyncStatusEnum = SyncStatusEnum
+
+
+class TiendaNubeProductSyncStatus(ProductSyncStatus):
+    """Tienda Nube-flavored wrapper for the generic ProductSyncStatus."""
+
+    integration_type: str = Field(
+        default="tiendanube",
+        frozen=True,
+        description="Integration type for this sync status"
+    )

letschatty/models/company/integrations/tienda_nube/tienda_nube_webhook_topics.py

@@ -0,0 +1,46 @@
+from enum import Enum
+
+class TiendaNubeWebhookTopic(str, Enum):
+    """Tienda Nube webhook topics for products and orders"""
+    
+    # Product webhooks
+    PRODUCT_CREATED = "product/created"
+    PRODUCT_UPDATED = "product/updated"
+    PRODUCT_DELETED = "product/deleted"
+    
+    # Order webhooks
+    ORDER_CREATED = "order/created"
+    ORDER_UPDATED = "order/updated"
+    ORDER_PAID = "order/paid"
+    ORDER_PACKED = "order/packed"
+    ORDER_FULFILLED = "order/fulfilled"
+    ORDER_CANCELLED = "order/cancelled"
+    ORDER_EDITED = "order/edited"
+    ORDER_PENDING = "order/pending"
+    ORDER_VOIDED = "order/voided"
+    ORDER_UNPACKED = "order/unpacked"
+    
+    @classmethod
+    def get_product_topics(cls) -> list[str]:
+        """Get all product-related webhook topics"""
+        return [
+            cls.PRODUCT_CREATED.value,
+            cls.PRODUCT_UPDATED.value,
+            cls.PRODUCT_DELETED.value,
+        ]
+    
+    @classmethod
+    def get_order_topics(cls) -> list[str]:
+        """Get all order-related webhook topics"""
+        return [
+            cls.ORDER_CREATED.value,
+            cls.ORDER_UPDATED.value,
+            cls.ORDER_PAID.value,
+            cls.ORDER_PACKED.value,
+            cls.ORDER_FULFILLED.value,
+            cls.ORDER_CANCELLED.value,
+            cls.ORDER_EDITED.value,
+            cls.ORDER_PENDING.value,
+            cls.ORDER_VOIDED.value,
+            cls.ORDER_UNPACKED.value,
+        ]

letschatty/models/data_base/collection_interface.py

@@ -4,7 +4,6 @@ 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
@@ -27,116 +26,58 @@ 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
 
-    # All methods are now async-only for better performance
-    async def insert(self, asset: T) -> StrObjectId:
-        """Async insert operation"""
+    def insert(self, asset: T) -> StrObjectId:
         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 = await self.async_collection.insert_one(document)
+        result = self.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
 
-    async def update(self, asset: T) -> StrObjectId:
-        """Async update operation"""
+    def update(self, asset: T) -> StrObjectId:
         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)
-        result = await self.async_collection.update_one(
-            {"_id": ObjectId(asset.id)},
-            {"$set": document}
-        )
+        document.pop('_id', None)  # Still needed
+        result = self.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
 
-    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)})
+    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)})
+
         if doc:
             return self.create_instance(doc)
         else:
-            raise NotFoundError(f"No document found with id {doc_id} in collection")
+            raise NotFoundError(f"No document found with id {doc_id} in db collection {self.collection.name} and db {self.db.name}")
 
-    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}")
+    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}")
         if company_id:
-            query = query.copy()
+            query = query.copy()  # Create a copy to avoid modifying the original
             query["company_id"] = company_id
-        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")
+        docs = list(self.collection.find(filter=query).limit(limit))
+        logger.debug(f"Found {len(docs)} documents in collection {self.collection.name}")
         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:
@@ -157,31 +98,18 @@ class ChattyAssetCollectionInterface(Generic[T, P], ABC):
         docs = self.collection.find(query)
         return [self.create_instance(doc) for doc in docs]
 
-    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]
+    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}")