geek-cafe-saas-sdk 0.6.0__py3-none-any.whl

geek_cafe_saas_sdk/domains/messaging/handlers/chat_messages/update/app.py

@@ -0,0 +1,127 @@
+"""
+Lambda handler for updating chat messages.
+
+Supports multiple operations:
+- Edit message content
+- Add/remove reactions
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ChatMessageService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ChatMessageService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Update a chat message.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatMessageService for testing
+    
+    Path parameters:
+        id: Chat message ID
+    
+    Expected body (camelCase from frontend):
+    {
+        "action": "update" | "add_reaction" | "remove_reaction",
+        
+        // For action="update":
+        "content": "Updated message content",
+        
+        // For action="add_reaction":
+        "emoji": "👍",
+        
+        // For action="remove_reaction":
+        "emoji": "👍"
+    }
+    
+    Returns 200 with updated chat message
+    """
+    return handler_wrapper.execute(event, context, update_chat_message, injected_service)
+
+
+def update_chat_message(
+    event: Dict[str, Any],
+    service: ChatMessageService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for updating chat messages.
+    
+    Routes to different service methods based on action parameter.
+    """
+    # Extract path parameter
+    path_params = event.get("pathParameters") or {}
+    message_id = path_params.get("id")
+    
+    if not message_id:
+        from geek_cafe_saas_sdk.core.service_result import ServiceResult
+        from geek_cafe_saas_sdk.core.service_errors import ValidationError
+        return ServiceResult.exception_result(
+            ValidationError("Message ID is required in path")
+        )
+    
+    payload = event["parsed_body"]
+    action = payload.get("action", "update")
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    
+    # Route to appropriate service method based on action
+    
+    if action == "add_reaction":
+        # Add a reaction to the message
+        emoji = payload.get("emoji")
+        if not emoji:
+            from geek_cafe_saas_sdk.core.service_result import ServiceResult
+            from geek_cafe_saas_sdk.core.service_errors import ValidationError
+            return ServiceResult.exception_result(
+                ValidationError("emoji is required for add_reaction action")
+            )
+        
+        return service.add_reaction(
+            message_id=message_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            emoji=emoji
+        )
+    
+    elif action == "remove_reaction":
+        # Remove a reaction from the message
+        emoji = payload.get("emoji")
+        if not emoji:
+            from geek_cafe_saas_sdk.core.service_result import ServiceResult
+            from geek_cafe_saas_sdk.core.service_errors import ValidationError
+            return ServiceResult.exception_result(
+                ValidationError("emoji is required for remove_reaction action")
+            )
+        
+        return service.remove_reaction(
+            message_id=message_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            emoji=emoji
+        )
+    
+    else:
+        # Edit message content (only sender can edit)
+        updates = {}
+        
+        if "content" in payload:
+            updates["content"] = payload["content"]
+        
+        return service.update(
+            resource_id=message_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            updates=updates
+        )

geek_cafe_saas_sdk/domains/messaging/handlers/contact_threads/create/app.py

@@ -0,0 +1,94 @@
+"""
+Lambda handler for creating contact threads.
+
+Supports both guest contact forms (API key auth) and authenticated users.
+Auth strategy is controlled by AUTH_TYPE environment variable:
+- AUTH_TYPE=api_key - For public contact forms (validates x-api-key)
+- AUTH_TYPE=secure - For authenticated app users (API Gateway authorizer)
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ContactThreadService
+
+# Factory automatically selects handler based on AUTH_TYPE env var
+handler_wrapper = create_handler(
+    service_class=ContactThreadService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Create a new contact thread.
+    
+    Two deployment modes:
+    
+    1. Public Contact Form (AUTH_TYPE=api_key):
+       - Validates x-api-key header
+       - Creates contact from guest/anonymous user
+       - Used for website contact forms
+    
+    2. Authenticated App (AUTH_TYPE=secure):
+       - Trusts API Gateway Cognito authorizer
+       - Creates contact from logged-in user
+       - Used for in-app support tickets
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ContactThreadService for testing
+    
+    Expected body (camelCase from frontend):
+    {
+        "subject": "Contact inquiry",
+        "sender": {
+            "id": "guest-session-xyz",
+            "name": "John Doe",
+            "email": "john@example.com"
+        },
+        "initialMessage": "Message content",
+        "inboxId": "support" | "sales" | "billing",
+        "priority": "low" | "medium" | "high" | "urgent",
+        "source": "web" | "mobile" | "api"
+    }
+    
+    Returns 201 with created contact thread
+    """
+    return handler_wrapper.execute(event, context, create_contact_thread, injected_service)
+
+
+def create_contact_thread(
+    event: Dict[str, Any],
+    service: ContactThreadService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for creating contact threads.
+    
+    Handles both guest users (API key) and authenticated users (Cognito).
+    """
+    payload = event["parsed_body"]
+
+    # Determine tenant and user ID
+    # For authenticated users, use token data
+    # For guest contact forms, use payload data
+    tenant_id = user_context.get("tenant_id") or payload.get("tenant_id", "default")
+    
+    authenticated_user_id = user_context.get("user_id")
+    if authenticated_user_id:
+        user_id = authenticated_user_id
+    else:
+        # For API key requests, allow userId from sender
+        sender = payload.get("sender", {})
+        user_id = sender.get("id", "anonymous")
+
+    # Create the contact thread
+    result = service.create(
+        tenant_id=tenant_id,
+        user_id=user_id,
+        payload=payload
+    )
+
+    return result

geek_cafe_saas_sdk/domains/messaging/handlers/contact_threads/delete/app.py

@@ -0,0 +1,66 @@
+"""
+Lambda handler for deleting (soft delete) contact threads.
+
+Requires authentication and appropriate access permissions.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ContactThreadService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ContactThreadService,
+    require_body=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Delete (soft delete) a contact thread.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ContactThreadService for testing
+    
+    Path parameters:
+        id: Contact thread ID
+    
+    Returns 200 with success boolean
+    """
+    return handler_wrapper.execute(event, context, delete_contact_thread, injected_service)
+
+
+def delete_contact_thread(
+    event: Dict[str, Any],
+    service: ContactThreadService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for deleting a contact thread.
+    
+    Performs soft delete (sets deleted timestamp).
+    """
+    # Extract path parameter
+    path_params = event.get("pathParameters") or {}
+    thread_id = path_params.get("id")
+    
+    if not thread_id:
+        from geek_cafe_saas_sdk.core.service_result import ServiceResult
+        from geek_cafe_saas_sdk.core.service_errors import ValidationError
+        return ServiceResult.exception_result(
+            ValidationError("Thread ID is required in path")
+        )
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    user_inboxes = user_context.get("inboxes", [])
+    
+    # Delete the contact thread
+    return service.delete(
+        resource_id=thread_id,
+        tenant_id=tenant_id,
+        user_id=user_id,
+        user_inboxes=user_inboxes
+    )

geek_cafe_saas_sdk/domains/messaging/handlers/contact_threads/get/app.py

@@ -0,0 +1,67 @@
+"""
+Lambda handler for getting a contact thread by ID.
+
+Requires authentication (defaults to secure mode).
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ContactThreadService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ContactThreadService,
+    require_body=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Get a contact thread by ID.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ContactThreadService for testing
+    
+    Path parameters:
+        id: Contact thread ID
+    
+    Returns 200 with contact thread details
+    """
+    return handler_wrapper.execute(event, context, get_contact_thread, injected_service)
+
+
+def get_contact_thread(
+    event: Dict[str, Any],
+    service: ContactThreadService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for getting a contact thread.
+    
+    Access control is enforced via inbox access or sender/assignee checks.
+    """
+    # Extract path parameter
+    path_params = event.get("pathParameters") or {}
+    thread_id = path_params.get("id")
+    
+    if not thread_id:
+        from geek_cafe_saas_sdk.core.service_result import ServiceResult
+        from geek_cafe_saas_sdk.core.service_errors import ValidationError
+        return ServiceResult.exception_result(
+            ValidationError("Thread ID is required in path")
+        )
+    
+    # Get user's inbox access
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    user_inboxes = user_context.get("inboxes", [])
+    
+    # Get the contact thread with access control
+    return service.get_by_id(
+        resource_id=thread_id,
+        tenant_id=tenant_id,
+        user_id=user_id,
+        user_inboxes=user_inboxes
+    )

geek_cafe_saas_sdk/domains/messaging/handlers/contact_threads/list/app.py

@@ -0,0 +1,95 @@
+"""
+Lambda handler for listing contact threads.
+
+Supports multiple query patterns via query parameters:
+- inbox + status (default): List threads in an inbox by status
+- assigned: List threads assigned to current user
+- sender_email: List all threads from a specific email
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ContactThreadService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ContactThreadService,
+    require_body=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    List contact threads based on query parameters.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ContactThreadService for testing
+    
+    Query parameters:
+        inbox_id: Inbox ID (support, sales, billing)
+        status: Status filter (open, in_progress, resolved, closed)
+        assigned: "me" to get threads assigned to current user
+        sender_email: Email address to find all threads from sender
+        limit: Maximum number of results (default 50)
+    
+    Examples:
+        GET /contact-threads?inbox_id=support&status=open
+        GET /contact-threads?assigned=me
+        GET /contact-threads?sender_email=guest@example.com
+    
+    Returns 200 with list of contact threads
+    """
+    return handler_wrapper.execute(event, context, list_contact_threads, injected_service)
+
+
+def list_contact_threads(
+    event: Dict[str, Any],
+    service: ContactThreadService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for listing contact threads.
+    
+    Routes to different service methods based on query parameters.
+    """
+    query_params = event.get("queryStringParameters") or {}
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    limit = int(query_params.get("limit", "50"))
+    
+    # Route to appropriate service method
+    
+    # Pattern 1: List by assigned user
+    if query_params.get("assigned") == "me":
+        status = query_params.get("status")
+        return service.list_by_assigned_user(
+            assigned_to=user_id,
+            tenant_id=tenant_id,
+            status=status,
+            limit=limit
+        )
+    
+    # Pattern 2: List by sender email
+    if "sender_email" in query_params:
+        sender_email = query_params.get("sender_email")
+        return service.list_by_sender_email(
+            sender_email=sender_email,
+            tenant_id=tenant_id,
+            limit=limit
+        )
+    
+    # Pattern 3: List by inbox and status (default)
+    inbox_id = query_params.get("inbox_id", "support")
+    status = query_params.get("status", "open")
+    priority = query_params.get("priority")
+    
+    return service.list_by_inbox_and_status(
+        inbox_id=inbox_id,
+        status=status,
+        tenant_id=tenant_id,
+        priority=priority,
+        limit=limit
+    )

geek_cafe_saas_sdk/domains/messaging/handlers/contact_threads/update/app.py

@@ -0,0 +1,156 @@
+"""
+Lambda handler for updating contact threads.
+
+Supports multiple update operations:
+- Update general fields (subject, priority, tags, etc.)
+- Add messages to thread
+- Assign to staff member
+- Update status
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ContactThreadService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ContactThreadService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Update a contact thread.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ContactThreadService for testing
+    
+    Path parameters:
+        id: Contact thread ID
+    
+    Expected body (camelCase from frontend):
+    {
+        "action": "update" | "add_message" | "assign" | "update_status",
+        
+        // For action="update":
+        "subject": "Updated subject",
+        "priority": "urgent",
+        "tags": ["bug", "urgent"],
+        
+        // For action="add_message":
+        "message": {
+            "content": "Reply message",
+            "senderName": "Support Staff",
+            "isStaffReply": true
+        },
+        
+        // For action="assign":
+        "assignedTo": "staff_user_id",
+        
+        // For action="update_status":
+        "status": "resolved"
+    }
+    
+    Returns 200 with updated contact thread
+    """
+    return handler_wrapper.execute(event, context, update_contact_thread, injected_service)
+
+
+def update_contact_thread(
+    event: Dict[str, Any],
+    service: ContactThreadService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for updating contact threads.
+    
+    Routes to different service methods based on action parameter.
+    """
+    # Extract path parameter
+    path_params = event.get("pathParameters") or {}
+    thread_id = path_params.get("id")
+    
+    if not thread_id:
+        from geek_cafe_saas_sdk.core.service_result import ServiceResult
+        from geek_cafe_saas_sdk.core.service_errors import ValidationError
+        return ServiceResult.exception_result(
+            ValidationError("Thread ID is required in path")
+        )
+    
+    payload = event["parsed_body"]
+    action = payload.get("action", "update")
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    user_inboxes = user_context.get("inboxes", [])
+    
+    # Route to appropriate service method based on action
+    
+    if action == "add_message":
+        # Add a message to the thread
+        message_data = payload.get("message", {})
+        return service.add_message(
+            thread_id=thread_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            message_data=message_data,
+            user_inboxes=user_inboxes
+        )
+    
+    elif action == "assign":
+        # Assign thread to a staff member
+        assigned_to = payload.get("assigned_to")
+        if not assigned_to:
+            from geek_cafe_saas_sdk.core.service_result import ServiceResult
+            from geek_cafe_saas_sdk.core.service_errors import ValidationError
+            return ServiceResult.exception_result(
+                ValidationError("assigned_to is required for assign action")
+            )
+        
+        return service.assign_thread(
+            thread_id=thread_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            assigned_to=assigned_to,
+            user_inboxes=user_inboxes
+        )
+    
+    elif action == "update_status":
+        # Update thread status
+        status = payload.get("status")
+        if not status:
+            from geek_cafe_saas_sdk.core.service_result import ServiceResult
+            from geek_cafe_saas_sdk.core.service_errors import ValidationError
+            return ServiceResult.exception_result(
+                ValidationError("status is required for update_status action")
+            )
+        
+        return service.update_status(
+            thread_id=thread_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            status=status,
+            user_inboxes=user_inboxes
+        )
+    
+    else:
+        # General update (update multiple fields)
+        # Extract allowed fields
+        updates = {}
+        allowed_fields = ['subject', 'status', 'priority', 'assigned_to', 'tags', 'inbox_id']
+        
+        for field in allowed_fields:
+            if field in payload:
+                updates[field] = payload[field]
+        
+        return service.update(
+            resource_id=thread_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            updates=updates,
+            user_inboxes=user_inboxes
+        )

geek_cafe_saas_sdk/domains/messaging/models/__init__.py

@@ -0,0 +1,13 @@
+# Messaging Domain Models
+
+from .chat_channel import ChatChannel
+from .chat_channel_member import ChatChannelMember
+from .chat_message import ChatMessage
+from .contact_thread import ContactThread
+
+__all__ = [
+    "ChatChannel",
+    "ChatChannelMember",
+    "ChatMessage",
+    "ContactThread",
+]