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

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

@@ -0,0 +1,64 @@
+"""
+Lambda handler for getting a chat channel by ID.
+
+Requires authentication.
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ChatChannelService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ChatChannelService,
+    require_body=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Get a chat channel by ID.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatChannelService for testing
+    
+    Path parameters:
+        id: Chat channel ID
+    
+    Returns 200 with chat channel details
+    """
+    return handler_wrapper.execute(event, context, get_chat_channel, injected_service)
+
+
+def get_chat_channel(
+    event: Dict[str, Any],
+    service: ChatChannelService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for getting a chat channel.
+    
+    Access control: public channels visible to all, private channels only to members.
+    """
+    # Extract path parameter
+    path_params = event.get("pathParameters") or {}
+    channel_id = path_params.get("id")
+    
+    if not channel_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("Channel ID is required in path")
+        )
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    
+    # Get the chat channel with access control
+    return service.get_by_id(
+        resource_id=channel_id,
+        tenant_id=tenant_id,
+        user_id=user_id
+    )

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

@@ -0,0 +1,97 @@
+"""
+Lambda handler for listing chat channels.
+
+Supports multiple query patterns:
+- List by channel type (public, private, direct)
+- List user's channels
+- List default channels
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ChatChannelService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ChatChannelService,
+    require_body=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    List chat channels based on query parameters.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatChannelService for testing
+    
+    Query parameters:
+        channel_type: Filter by type (public, private, direct)
+        user_channels: "true" to get only user's channels
+        default: "true" to get only default channels
+        include_archived: "true" to include archived channels
+        limit: Maximum number of results (default 50)
+    
+    Examples:
+        GET /chat-channels?channel_type=public
+        GET /chat-channels?user_channels=true
+        GET /chat-channels?default=true
+    
+    Returns 200 with list of chat channels
+    """
+    return handler_wrapper.execute(event, context, list_chat_channels, injected_service)
+
+
+def list_chat_channels(
+    event: Dict[str, Any],
+    service: ChatChannelService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for listing chat channels.
+    
+    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", "100"))
+    
+    # Route to appropriate service method
+    
+    # Pattern 1: List default channels
+    if query_params.get("default") == "true":
+        return service.list_default_channels(
+            tenant_id=tenant_id,
+            limit=limit
+        )
+    
+    # Pattern 2: List user's channels
+    if query_params.get("user_channels") == "true":
+        include_archived = query_params.get("include_archived") == "true"
+        return service.list_user_channels(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            include_archived=include_archived,
+            limit=limit
+        )
+    
+    # Pattern 3: List by channel type
+    if "channel_type" in query_params:
+        channel_type = query_params.get("channel_type")
+        return service.list_by_type(
+            tenant_id=tenant_id,
+            channel_type=channel_type,
+            user_id=user_id,
+            limit=limit
+        )
+    
+    # Pattern 4: List all accessible channels (default)
+    return service.list_all(
+        tenant_id=tenant_id,
+        user_id=user_id,
+        limit=limit
+    )

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

@@ -0,0 +1,149 @@
+"""
+Lambda handler for updating chat channels.
+
+Supports multiple operations:
+- Update channel properties
+- Add/remove members
+- Archive/unarchive
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.messaging.services import ChatChannelService
+
+# Factory creates handler (defaults to secure auth)
+handler_wrapper = create_handler(
+    service_class=ChatChannelService,
+    require_body=True,
+    convert_case=True
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Update a chat channel.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatChannelService for testing
+    
+    Path parameters:
+        id: Chat channel ID
+    
+    Expected body (camelCase from frontend):
+    {
+        "action": "update" | "add_member" | "remove_member" | "archive" | "unarchive",
+        
+        // For action="update":
+        "name": "Updated Name",
+        "description": "Updated description",
+        "topic": "New topic",
+        "isAnnouncement": true,
+        
+        // For action="add_member":
+        "memberId": "user_456",
+        
+        // For action="remove_member":
+        "memberId": "user_456"
+    }
+    
+    Returns 200 with updated chat channel
+    """
+    return handler_wrapper.execute(event, context, update_chat_channel, injected_service)
+
+
+def update_chat_channel(
+    event: Dict[str, Any],
+    service: ChatChannelService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for updating chat channels.
+    
+    Routes to different service methods based on action parameter.
+    """
+    # Extract path parameter
+    path_params = event.get("pathParameters") or {}
+    channel_id = path_params.get("id")
+    
+    if not channel_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("Channel 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_member":
+        # Add a member to the channel
+        member_id = payload.get("member_id")
+        if not member_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("member_id is required for add_member action")
+            )
+        
+        return service.add_member(
+            channel_id=channel_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            member_to_add=member_id
+        )
+    
+    elif action == "remove_member":
+        # Remove a member from the channel
+        member_id = payload.get("member_id")
+        if not member_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("member_id is required for remove_member action")
+            )
+        
+        return service.remove_member(
+            channel_id=channel_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            member_to_remove=member_id
+        )
+    
+    elif action == "archive":
+        # Archive the channel
+        return service.archive(
+            channel_id=channel_id,
+            tenant_id=tenant_id,
+            user_id=user_id
+        )
+    
+    elif action == "unarchive":
+        # Unarchive the channel
+        return service.unarchive(
+            channel_id=channel_id,
+            tenant_id=tenant_id,
+            user_id=user_id
+        )
+    
+    else:
+        # General update (update channel properties)
+        updates = {}
+        allowed_fields = ['name', 'description', 'topic', 'icon', 'is_announcement', 'is_default']
+        
+        for field in allowed_fields:
+            if field in payload:
+                updates[field] = payload[field]
+        
+        return service.update(
+            resource_id=channel_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            updates=updates
+        )

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

@@ -0,0 +1,67 @@
+"""
+Lambda handler for creating chat messages.
+
+Requires authentication.
+"""
+
+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]:
+    """
+    Create a new chat message.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatMessageService for testing
+    
+    Expected body (camelCase from frontend):
+    {
+        "channelId": "channel_123",
+        "content": "Hello world!",
+        "senderName": "User Name",
+        "parentMessageId": "msg_parent_123" (optional for threaded replies),
+        "mentions": ["user_456", "user_789"],
+        "attachments": [
+            {"type": "image", "url": "https://..."}
+        ]
+    }
+    
+    Returns 201 with created chat message
+    """
+    return handler_wrapper.execute(event, context, create_chat_message, injected_service)
+
+
+def create_chat_message(
+    event: Dict[str, Any],
+    service: ChatMessageService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for creating chat messages.
+    
+    Validates channel membership before creating message.
+    """
+    payload = event["parsed_body"]
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    
+    # Create the chat message
+    result = service.create(
+        tenant_id=tenant_id,
+        user_id=user_id,
+        payload=payload
+    )
+    
+    return result

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

@@ -0,0 +1,65 @@
+"""
+Lambda handler for deleting (soft delete) chat messages.
+
+Requires authentication. Only message sender can delete.
+"""
+
+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=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Delete (soft delete) 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
+    
+    Returns 200 with success boolean
+    """
+    return handler_wrapper.execute(event, context, delete_chat_message, injected_service)
+
+
+def delete_chat_message(
+    event: Dict[str, Any],
+    service: ChatMessageService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for deleting a chat message.
+    
+    Performs soft delete (sets deleted timestamp).
+    Only message sender can delete.
+    """
+    # 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")
+        )
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    
+    # Delete the chat message
+    return service.delete(
+        resource_id=message_id,
+        tenant_id=tenant_id,
+        user_id=user_id
+    )

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

@@ -0,0 +1,64 @@
+"""
+Lambda handler for getting a chat message by ID.
+
+Requires authentication and channel access.
+"""
+
+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=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Get a chat message by ID.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatMessageService for testing
+    
+    Path parameters:
+        id: Chat message ID
+    
+    Returns 200 with chat message details
+    """
+    return handler_wrapper.execute(event, context, get_chat_message, injected_service)
+
+
+def get_chat_message(
+    event: Dict[str, Any],
+    service: ChatMessageService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for getting a chat message.
+    
+    Verifies user has access to the channel before returning message.
+    """
+    # 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")
+        )
+    
+    user_id = user_context.get("user_id")
+    tenant_id = user_context.get("tenant_id")
+    
+    # Get the chat message with access control
+    return service.get_by_id(
+        resource_id=message_id,
+        tenant_id=tenant_id,
+        user_id=user_id
+    )

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

@@ -0,0 +1,102 @@
+"""
+Lambda handler for listing chat messages.
+
+Supports multiple query patterns:
+- List messages in a channel (with pagination)
+- List threaded replies to a message
+- List user's message history
+"""
+
+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=False
+)
+
+
+def handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    List chat messages based on query parameters.
+    
+    Args:
+        event: Lambda event from API Gateway
+        context: Lambda context
+        injected_service: Optional ChatMessageService for testing
+    
+    Query parameters:
+        channel_id: Channel ID to list messages from
+        parent_message_id: Parent message ID to list thread replies
+        sender_id: User ID to list message history
+        limit: Maximum number of results (default 50)
+        ascending: "true" for oldest first, "false" for newest first
+    
+    Examples:
+        GET /chat-messages?channel_id=channel_123&limit=50
+        GET /chat-messages?parent_message_id=msg_123
+        GET /chat-messages?sender_id=user_123
+    
+    Returns 200 with list of chat messages
+    """
+    return handler_wrapper.execute(event, context, list_chat_messages, injected_service)
+
+
+def list_chat_messages(
+    event: Dict[str, Any],
+    service: ChatMessageService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for listing chat messages.
+    
+    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"))
+    ascending = query_params.get("ascending", "true") == "true"
+    
+    # Route to appropriate service method
+    
+    # Pattern 1: List threaded replies to a parent message
+    if "parent_message_id" in query_params:
+        parent_message_id = query_params.get("parent_message_id")
+        return service.list_thread_replies(
+            parent_message_id=parent_message_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            limit=limit
+        )
+    
+    # Pattern 2: List user's message history
+    if "sender_id" in query_params:
+        sender_id = query_params.get("sender_id")
+        return service.list_by_sender(
+            sender_id=sender_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            limit=limit
+        )
+    
+    # Pattern 3: List messages in a channel (default, most common)
+    if "channel_id" in query_params:
+        channel_id = query_params.get("channel_id")
+        return service.list_by_channel(
+            channel_id=channel_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            limit=limit,
+            ascending=ascending
+        )
+    
+    # No valid query parameters
+    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("Must provide channel_id, parent_message_id, or sender_id")
+    )