hazo_chat 5.2.4 → 6.0.0

package/dist/api/messages.js

@@ -24,6 +24,7 @@ import { cookies } from 'next/headers';
 import { createCrudService } from 'hazo_connect/server';
 import { is_valid_uuid } from './validation.js';
 import { serialize_error } from '../lib/utils.js';
+import { generateRequestId, withContext } from 'hazo_core';
 // ============================================================================
 // Constants for validation
 // ============================================================================
@@ -40,14 +41,6 @@ const MAX_LIMIT = 100;
 // ============================================================================
 // Helper Functions
 // ============================================================================
-/** Generate a UUID v4 */
-function generateUUID() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0;
-        const v = c === 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
 /** Create a standardized error response */
 function createErrorResponse(error, status, error_code) {
     return NextResponse.json({
@@ -108,145 +101,147 @@ export function createMessagesHandler(options) {
      * - direction (optional): 'older' or 'newer' relative to cursor (default: 'older')
      */
     async function GET(request) {
-        try {
-            // Get current user ID
-            const current_user_id = getUserIdFromRequest
-                ? await getUserIdFromRequest(request)
-                : await defaultGetUserIdFromRequest();
-            if (!current_user_id) {
-                logger.error('[hazo_chat/messages GET] No user ID - not authenticated');
-                return createErrorResponse('User not authenticated', 401, 'UNAUTHENTICATED');
-            }
-            // Get query params
-            const { searchParams } = new URL(request.url);
-            const chat_group_id = searchParams.get('chat_group_id');
-            const reference_id = searchParams.get('reference_id') || '';
-            const reference_type = searchParams.get('reference_type') || '';
-            const cursor = searchParams.get('cursor') || '';
-            const direction = searchParams.get('direction') || 'older';
-            const limit_param = searchParams.get('limit');
-            // Validate required params
-            if (!chat_group_id) {
-                logger.error('[hazo_chat/messages GET] Missing chat_group_id');
-                return createErrorResponse('chat_group_id is required', 400, 'MISSING_CHAT_GROUP');
-            }
-            // Validate UUID formats before database queries
-            if (!is_valid_uuid(chat_group_id)) {
-                logger.debug('[hazo_chat/messages GET] Invalid chat_group_id format:', { chat_group_id });
-                return createErrorResponse('chat_group_id must be a valid UUID', 400, 'INVALID_UUID_FORMAT');
-            }
-            if (!is_valid_uuid(current_user_id)) {
-                logger.debug('[hazo_chat/messages GET] Invalid user_id format:', { current_user_id });
-                return createErrorResponse('Invalid user ID format', 400, 'INVALID_UUID_FORMAT');
-            }
-            // Get hazo_connect instance early for membership check
-            const hazoConnect = getHazoConnect();
-            // Verify user is a member of the chat group
-            const membership = await verifyGroupMembership(hazoConnect, current_user_id, chat_group_id, logger);
-            if (!membership) {
-                logger.warn('[hazo_chat/messages GET] User is not a member of chat group:', {
+        return withContext({}, async () => {
+            try {
+                // Get current user ID
+                const current_user_id = getUserIdFromRequest
+                    ? await getUserIdFromRequest(request)
+                    : await defaultGetUserIdFromRequest();
+                if (!current_user_id) {
+                    logger.error('[hazo_chat/messages GET] No user ID - not authenticated');
+                    return createErrorResponse('User not authenticated', 401, 'UNAUTHENTICATED');
+                }
+                // Get query params
+                const { searchParams } = new URL(request.url);
+                const chat_group_id = searchParams.get('chat_group_id');
+                const reference_id = searchParams.get('reference_id') || '';
+                const reference_type = searchParams.get('reference_type') || '';
+                const cursor = searchParams.get('cursor') || '';
+                const direction = searchParams.get('direction') || 'older';
+                const limit_param = searchParams.get('limit');
+                // Validate required params
+                if (!chat_group_id) {
+                    logger.error('[hazo_chat/messages GET] Missing chat_group_id');
+                    return createErrorResponse('chat_group_id is required', 400, 'MISSING_CHAT_GROUP');
+                }
+                // Validate UUID formats before database queries
+                if (!is_valid_uuid(chat_group_id)) {
+                    logger.debug('[hazo_chat/messages GET] Invalid chat_group_id format:', { chat_group_id });
+                    return createErrorResponse('chat_group_id must be a valid UUID', 400, 'INVALID_UUID_FORMAT');
+                }
+                if (!is_valid_uuid(current_user_id)) {
+                    logger.debug('[hazo_chat/messages GET] Invalid user_id format:', { current_user_id });
+                    return createErrorResponse('Invalid user ID format', 400, 'INVALID_UUID_FORMAT');
+                }
+                // Get hazo_connect instance early for membership check
+                const hazoConnect = getHazoConnect();
+                // Verify user is a member of the chat group
+                const membership = await verifyGroupMembership(hazoConnect, current_user_id, chat_group_id, logger);
+                if (!membership) {
+                    logger.warn('[hazo_chat/messages GET] User is not a member of chat group:', {
+                        current_user_id,
+                        chat_group_id,
+                    });
+                    return createErrorResponse('Access denied - not a member of this chat group', 403, 'FORBIDDEN');
+                }
+                // Validate input lengths
+                if (reference_id && reference_id.length > MAX_REFERENCE_ID_LENGTH) {
+                    return createErrorResponse(`reference_id exceeds maximum length of ${MAX_REFERENCE_ID_LENGTH}`, 400, 'INVALID_REFERENCE_ID');
+                }
+                if (reference_type && reference_type.length > MAX_REFERENCE_TYPE_LENGTH) {
+                    return createErrorResponse(`reference_type exceeds maximum length of ${MAX_REFERENCE_TYPE_LENGTH}`, 400, 'INVALID_REFERENCE_TYPE');
+                }
+                // Parse and validate limit
+                let limit = DEFAULT_LIMIT;
+                if (limit_param) {
+                    const parsed_limit = parseInt(limit_param, 10);
+                    if (isNaN(parsed_limit) || parsed_limit < 1) {
+                        return createErrorResponse('limit must be a positive integer', 400, 'INVALID_LIMIT');
+                    }
+                    limit = Math.min(parsed_limit, MAX_LIMIT);
+                }
+                logger.debug('[hazo_chat/messages GET] Fetching messages:', {
                     current_user_id,
                     chat_group_id,
+                    reference_id,
+                    reference_type,
+                    cursor,
+                    direction,
+                    limit,
                 });
-                return createErrorResponse('Access denied - not a member of this chat group', 403, 'FORBIDDEN');
-            }
-            // Validate input lengths
-            if (reference_id && reference_id.length > MAX_REFERENCE_ID_LENGTH) {
-                return createErrorResponse(`reference_id exceeds maximum length of ${MAX_REFERENCE_ID_LENGTH}`, 400, 'INVALID_REFERENCE_ID');
-            }
-            if (reference_type && reference_type.length > MAX_REFERENCE_TYPE_LENGTH) {
-                return createErrorResponse(`reference_type exceeds maximum length of ${MAX_REFERENCE_TYPE_LENGTH}`, 400, 'INVALID_REFERENCE_TYPE');
-            }
-            // Parse and validate limit
-            let limit = DEFAULT_LIMIT;
-            if (limit_param) {
-                const parsed_limit = parseInt(limit_param, 10);
-                if (isNaN(parsed_limit) || parsed_limit < 1) {
-                    return createErrorResponse('limit must be a positive integer', 400, 'INVALID_LIMIT');
-                }
-                limit = Math.min(parsed_limit, MAX_LIMIT);
-            }
-            logger.debug('[hazo_chat/messages GET] Fetching messages:', {
-                current_user_id,
-                chat_group_id,
-                reference_id,
-                reference_type,
-                cursor,
-                direction,
-                limit,
-            });
-            // Create CRUD service (hazoConnect already obtained above)
-            const chatService = createCrudService(hazoConnect, 'hazo_chat');
-            let messages = [];
-            try {
-                // Build query with proper filtering
-                const all_messages = await chatService.list((qb) => {
-                    let builder = qb.select('*');
-                    // Filter by chat group - this is the primary filter
-                    builder = builder.where('chat_group_id', 'eq', chat_group_id);
-                    // Exclude soft-deleted messages at the database level
-                    builder = builder.where('deleted_at', 'is', null);
-                    // Filter by reference if provided
-                    if (reference_id) {
-                        builder = builder.where('reference_id', 'eq', reference_id);
-                    }
-                    if (reference_type) {
-                        builder = builder.where('reference_type', 'eq', reference_type);
-                    }
-                    // Apply cursor-based pagination
-                    if (cursor) {
-                        if (direction === 'newer') {
-                            builder = builder.where('created_at', 'gt', cursor);
+                // Create CRUD service (hazoConnect already obtained above)
+                const chatService = createCrudService(hazoConnect, 'hazo_chat');
+                let messages = [];
+                try {
+                    // Build query with proper filtering
+                    const all_messages = await chatService.list((qb) => {
+                        let builder = qb.select('*');
+                        // Filter by chat group - this is the primary filter
+                        builder = builder.where('chat_group_id', 'eq', chat_group_id);
+                        // Exclude soft-deleted messages at the database level
+                        builder = builder.where('deleted_at', 'is', null);
+                        // Filter by reference if provided
+                        if (reference_id) {
+                            builder = builder.where('reference_id', 'eq', reference_id);
+                        }
+                        if (reference_type) {
+                            builder = builder.where('reference_type', 'eq', reference_type);
+                        }
+                        // Apply cursor-based pagination
+                        if (cursor) {
+                            if (direction === 'newer') {
+                                builder = builder.where('created_at', 'gt', cursor);
+                            }
+                            else {
+                                builder = builder.where('created_at', 'lt', cursor);
+                            }
+                        }
+                        // Order by created_at
+                        // For 'older' direction, we want desc to get the most recent first before cursor
+                        // For 'newer' or initial load, we want asc
+                        if (direction === 'older' && cursor) {
+                            builder = builder.order('created_at', 'desc');
                         }
                         else {
-                            builder = builder.where('created_at', 'lt', cursor);
+                            builder = builder.order('created_at', 'asc');
                         }
-                    }
-                    // Order by created_at
-                    // For 'older' direction, we want desc to get the most recent first before cursor
-                    // For 'newer' or initial load, we want asc
+                        return builder;
+                    });
+                    // Apply limit (deleted messages already filtered at DB level)
+                    messages = all_messages.slice(0, limit);
+                    // If we fetched in desc order, reverse to return in asc order
                     if (direction === 'older' && cursor) {
-                        builder = builder.order('created_at', 'desc');
+                        messages.reverse();
                     }
-                    else {
-                        builder = builder.order('created_at', 'asc');
-                    }
-                    return builder;
-                });
-                // Apply limit (deleted messages already filtered at DB level)
-                messages = all_messages.slice(0, limit);
-                // If we fetched in desc order, reverse to return in asc order
-                if (direction === 'older' && cursor) {
-                    messages.reverse();
                 }
+                catch (dbError) {
+                    logger.error('[hazo_chat/messages GET] Database error:', { dbError: serialize_error(dbError) });
+                    throw dbError;
+                }
+                logger.debug('[hazo_chat/messages GET] Found messages:', { count: messages.length });
+                // Determine if there are more messages
+                const has_more = messages.length === limit;
+                // Get cursors for next/prev page
+                const next_cursor = messages.length > 0 ? messages[messages.length - 1].created_at : null;
+                const prev_cursor = messages.length > 0 ? messages[0].created_at : null;
+                return NextResponse.json({
+                    success: true,
+                    messages,
+                    current_user_id,
+                    pagination: {
+                        limit,
+                        has_more,
+                        next_cursor,
+                        prev_cursor,
+                    },
+                });
             }
-            catch (dbError) {
-                logger.error('[hazo_chat/messages GET] Database error:', { dbError: serialize_error(dbError) });
-                throw dbError;
+            catch (error) {
+                const error_message = error instanceof Error ? error.message : 'Unknown error';
+                logger.error('[hazo_chat/messages GET] Error:', { error_message, error: serialize_error(error) });
+                return createErrorResponse('Failed to fetch messages', 500, 'INTERNAL_ERROR');
             }
-            logger.debug('[hazo_chat/messages GET] Found messages:', { count: messages.length });
-            // Determine if there are more messages
-            const has_more = messages.length === limit;
-            // Get cursors for next/prev page
-            const next_cursor = messages.length > 0 ? messages[messages.length - 1].created_at : null;
-            const prev_cursor = messages.length > 0 ? messages[0].created_at : null;
-            return NextResponse.json({
-                success: true,
-                messages,
-                current_user_id,
-                pagination: {
-                    limit,
-                    has_more,
-                    next_cursor,
-                    prev_cursor,
-                },
-            });
-        }
-        catch (error) {
-            const error_message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error('[hazo_chat/messages GET] Error:', { error_message, error: serialize_error(error) });
-            return createErrorResponse('Failed to fetch messages', 500, 'INTERNAL_ERROR');
-        }
+        }); // end withContext
     }
     /**
      * POST handler - Create a new chat message
@@ -258,123 +253,125 @@ export function createMessagesHandler(options) {
      * - reference_type (optional): Reference type (default: 'chat')
      */
     async function POST(request) {
-        try {
-            // Get current user ID (sender)
-            const sender_user_id = getUserIdFromRequest
-                ? await getUserIdFromRequest(request)
-                : await defaultGetUserIdFromRequest();
-            if (!sender_user_id) {
-                logger.error('[hazo_chat/messages POST] No user ID - not authenticated');
-                return createErrorResponse('User not authenticated', 401, 'UNAUTHENTICATED');
-            }
-            // Parse request body
-            const body = await request.json();
-            const { chat_group_id, message_text, reference_id, reference_type } = body;
-            // Validate required fields
-            if (!chat_group_id) {
-                logger.error('[hazo_chat/messages POST] Missing chat_group_id');
-                return createErrorResponse('chat_group_id is required', 400, 'MISSING_CHAT_GROUP');
-            }
-            // Validate UUID formats before database queries
-            if (!is_valid_uuid(chat_group_id)) {
-                logger.debug('[hazo_chat/messages POST] Invalid chat_group_id format:', { chat_group_id });
-                return createErrorResponse('chat_group_id must be a valid UUID', 400, 'INVALID_UUID_FORMAT');
-            }
-            if (!is_valid_uuid(sender_user_id)) {
-                logger.debug('[hazo_chat/messages POST] Invalid user_id format:', { sender_user_id });
-                return createErrorResponse('Invalid user ID format', 400, 'INVALID_UUID_FORMAT');
-            }
-            // Get hazo_connect instance early for membership check
-            const hazoConnect = getHazoConnect();
-            // Verify user is a member of the chat group
-            const membership = await verifyGroupMembership(hazoConnect, sender_user_id, chat_group_id, logger);
-            if (!membership) {
-                logger.warn('[hazo_chat/messages POST] User is not a member of chat group:', {
-                    sender_user_id,
-                    chat_group_id,
-                });
-                return createErrorResponse('Access denied - not a member of this chat group', 403, 'FORBIDDEN');
-            }
-            // Validate message_text
-            if (!message_text || typeof message_text !== 'string') {
-                logger.error('[hazo_chat/messages POST] Missing message_text');
-                return createErrorResponse('message_text is required', 400, 'MISSING_MESSAGE');
-            }
-            const trimmed_message = message_text.trim();
-            if (trimmed_message === '') {
-                logger.error('[hazo_chat/messages POST] Empty message_text');
-                return createErrorResponse('message_text cannot be empty or whitespace-only', 400, 'EMPTY_MESSAGE');
-            }
-            if (trimmed_message.length > MAX_MESSAGE_LENGTH) {
-                logger.error('[hazo_chat/messages POST] Message too long:', { length: trimmed_message.length });
-                return createErrorResponse(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`, 400, 'MESSAGE_TOO_LONG');
-            }
-            // Validate reference_id length
-            if (reference_id && reference_id.length > MAX_REFERENCE_ID_LENGTH) {
-                return createErrorResponse(`reference_id exceeds maximum length of ${MAX_REFERENCE_ID_LENGTH}`, 400, 'INVALID_REFERENCE_ID');
-            }
-            // Validate reference_type length
-            if (reference_type && reference_type.length > MAX_REFERENCE_TYPE_LENGTH) {
-                return createErrorResponse(`reference_type exceeds maximum length of ${MAX_REFERENCE_TYPE_LENGTH}`, 400, 'INVALID_REFERENCE_TYPE');
-            }
-            // Create CRUD service (hazoConnect already obtained above)
-            const chatService = createCrudService(hazoConnect, 'hazo_chat');
-            // Generate message ID and timestamps
-            const message_id = generateUUID();
-            const now = new Date().toISOString();
-            // Create message record
-            const message_record = {
-                id: message_id,
-                reference_id: reference_id || '',
-                reference_type: reference_type || 'chat',
-                sender_user_id,
-                chat_group_id,
-                message_text: trimmed_message,
-                reference_list: null,
-                read_at: null,
-                deleted_at: null,
-                created_at: now,
-                changed_at: now,
-            };
-            logger.info('[hazo_chat/messages POST] Saving message:', {
-                id: message_id,
-                sender_user_id,
-                chat_group_id,
-                reference_id: reference_id || '',
-                reference_type: reference_type || 'chat',
-                message_length: trimmed_message.length,
-            });
-            // Save to database
+        return withContext({}, async () => {
             try {
-                await chatService.insert(message_record);
-            }
-            catch (dbError) {
-                logger.error('[hazo_chat/messages POST] Database error:', { dbError: serialize_error(dbError) });
-                throw dbError;
-            }
-            logger.info('[hazo_chat/messages POST] Message saved successfully:', { message_id });
-            return NextResponse.json({
-                success: true,
-                message: {
+                // Get current user ID (sender)
+                const sender_user_id = getUserIdFromRequest
+                    ? await getUserIdFromRequest(request)
+                    : await defaultGetUserIdFromRequest();
+                if (!sender_user_id) {
+                    logger.error('[hazo_chat/messages POST] No user ID - not authenticated');
+                    return createErrorResponse('User not authenticated', 401, 'UNAUTHENTICATED');
+                }
+                // Parse request body
+                const body = await request.json();
+                const { chat_group_id, message_text, reference_id, reference_type } = body;
+                // Validate required fields
+                if (!chat_group_id) {
+                    logger.error('[hazo_chat/messages POST] Missing chat_group_id');
+                    return createErrorResponse('chat_group_id is required', 400, 'MISSING_CHAT_GROUP');
+                }
+                // Validate UUID formats before database queries
+                if (!is_valid_uuid(chat_group_id)) {
+                    logger.debug('[hazo_chat/messages POST] Invalid chat_group_id format:', { chat_group_id });
+                    return createErrorResponse('chat_group_id must be a valid UUID', 400, 'INVALID_UUID_FORMAT');
+                }
+                if (!is_valid_uuid(sender_user_id)) {
+                    logger.debug('[hazo_chat/messages POST] Invalid user_id format:', { sender_user_id });
+                    return createErrorResponse('Invalid user ID format', 400, 'INVALID_UUID_FORMAT');
+                }
+                // Get hazo_connect instance early for membership check
+                const hazoConnect = getHazoConnect();
+                // Verify user is a member of the chat group
+                const membership = await verifyGroupMembership(hazoConnect, sender_user_id, chat_group_id, logger);
+                if (!membership) {
+                    logger.warn('[hazo_chat/messages POST] User is not a member of chat group:', {
+                        sender_user_id,
+                        chat_group_id,
+                    });
+                    return createErrorResponse('Access denied - not a member of this chat group', 403, 'FORBIDDEN');
+                }
+                // Validate message_text
+                if (!message_text || typeof message_text !== 'string') {
+                    logger.error('[hazo_chat/messages POST] Missing message_text');
+                    return createErrorResponse('message_text is required', 400, 'MISSING_MESSAGE');
+                }
+                const trimmed_message = message_text.trim();
+                if (trimmed_message === '') {
+                    logger.error('[hazo_chat/messages POST] Empty message_text');
+                    return createErrorResponse('message_text cannot be empty or whitespace-only', 400, 'EMPTY_MESSAGE');
+                }
+                if (trimmed_message.length > MAX_MESSAGE_LENGTH) {
+                    logger.error('[hazo_chat/messages POST] Message too long:', { length: trimmed_message.length });
+                    return createErrorResponse(`Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`, 400, 'MESSAGE_TOO_LONG');
+                }
+                // Validate reference_id length
+                if (reference_id && reference_id.length > MAX_REFERENCE_ID_LENGTH) {
+                    return createErrorResponse(`reference_id exceeds maximum length of ${MAX_REFERENCE_ID_LENGTH}`, 400, 'INVALID_REFERENCE_ID');
+                }
+                // Validate reference_type length
+                if (reference_type && reference_type.length > MAX_REFERENCE_TYPE_LENGTH) {
+                    return createErrorResponse(`reference_type exceeds maximum length of ${MAX_REFERENCE_TYPE_LENGTH}`, 400, 'INVALID_REFERENCE_TYPE');
+                }
+                // Create CRUD service (hazoConnect already obtained above)
+                const chatService = createCrudService(hazoConnect, 'hazo_chat');
+                // Generate message ID and timestamps
+                const message_id = generateRequestId().slice(4); // strips 'req_' prefix for UUID-like storage
+                const now = new Date().toISOString();
+                // Create message record
+                const message_record = {
                     id: message_id,
-                    sender_user_id,
-                    chat_group_id,
                     reference_id: reference_id || '',
                     reference_type: reference_type || 'chat',
+                    sender_user_id,
+                    chat_group_id,
                     message_text: trimmed_message,
                     reference_list: null,
                     read_at: null,
                     deleted_at: null,
                     created_at: now,
                     changed_at: now,
-                },
-            });
-        }
-        catch (error) {
-            const error_message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error('[hazo_chat/messages POST] Error:', { error_message, error: serialize_error(error) });
-            return createErrorResponse('Failed to save message', 500, 'INTERNAL_ERROR');
-        }
+                };
+                logger.info('[hazo_chat/messages POST] Saving message:', {
+                    id: message_id,
+                    sender_user_id,
+                    chat_group_id,
+                    reference_id: reference_id || '',
+                    reference_type: reference_type || 'chat',
+                    message_length: trimmed_message.length,
+                });
+                // Save to database
+                try {
+                    await chatService.insert(message_record);
+                }
+                catch (dbError) {
+                    logger.error('[hazo_chat/messages POST] Database error:', { dbError: serialize_error(dbError) });
+                    throw dbError;
+                }
+                logger.info('[hazo_chat/messages POST] Message saved successfully:', { message_id });
+                return NextResponse.json({
+                    success: true,
+                    message: {
+                        id: message_id,
+                        sender_user_id,
+                        chat_group_id,
+                        reference_id: reference_id || '',
+                        reference_type: reference_type || 'chat',
+                        message_text: trimmed_message,
+                        reference_list: null,
+                        read_at: null,
+                        deleted_at: null,
+                        created_at: now,
+                        changed_at: now,
+                    },
+                });
+            }
+            catch (error) {
+                const error_message = error instanceof Error ? error.message : 'Unknown error';
+                logger.error('[hazo_chat/messages POST] Error:', { error_message, error: serialize_error(error) });
+                return createErrorResponse('Failed to save message', 500, 'INTERNAL_ERROR');
+            }
+        }); // end withContext
     }
     return { GET, POST };
 }
@@ -399,114 +396,116 @@ export function createMarkAsReadHandler(options) {
      * Note: In Next.js 13+ App Router, params may be a Promise
      */
     async function PATCH(request, context) {
-        try {
-            // Get current user ID
-            const current_user_id = getUserIdFromRequest
-                ? await getUserIdFromRequest(request)
-                : await defaultGetUserIdFromRequest();
-            if (!current_user_id) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] No user ID - not authenticated');
-                return NextResponse.json({ success: false, error: 'User not authenticated' }, { status: 401 });
-            }
-            // Handle params as Promise (Next.js 15+) or direct object (Next.js 13-14)
-            const params = context.params instanceof Promise ? await context.params : context.params;
-            const message_id = params.id;
-            if (!message_id) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] Missing message ID');
-                return NextResponse.json({ success: false, error: 'Message ID is required' }, { status: 400 });
-            }
-            // Validate UUID formats before database queries
-            if (!is_valid_uuid(message_id)) {
-                logger.debug('[hazo_chat/messages/[id]/read PATCH] Invalid message_id format:', { message_id });
-                return NextResponse.json({ success: false, error: 'message_id must be a valid UUID', error_code: 'INVALID_UUID_FORMAT' }, { status: 400 });
-            }
-            if (!is_valid_uuid(current_user_id)) {
-                logger.debug('[hazo_chat/messages/[id]/read PATCH] Invalid user_id format:', { current_user_id });
-                return NextResponse.json({ success: false, error: 'Invalid user ID format', error_code: 'INVALID_UUID_FORMAT' }, { status: 400 });
-            }
-            logger.info('[hazo_chat/messages/[id]/read PATCH] Marking message as read:', {
-                message_id,
-                current_user_id,
-            });
-            // Get hazo_connect instance and create CRUD service
-            const hazoConnect = getHazoConnect();
-            const chatService = createCrudService(hazoConnect, 'hazo_chat');
-            // First, fetch the message to verify ownership
-            let message = null;
+        return withContext({}, async () => {
             try {
-                const messages = await chatService.list((qb) => qb.select('*').where('id', 'eq', message_id));
-                message = messages[0] || null;
-            }
-            catch (dbError) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] Database error fetching message:', { dbError: serialize_error(dbError) });
-                throw dbError;
-            }
-            if (!message) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] Message not found:', { message_id });
-                return NextResponse.json({ success: false, error: 'Message not found' }, { status: 404 });
-            }
-            // Verify that the current user is a member of the chat group
-            const membership = await verifyGroupMembership(hazoConnect, current_user_id, message.chat_group_id, logger);
-            if (!membership) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] User is not a member of chat group:', {
-                    message_id,
-                    current_user_id,
-                    chat_group_id: message.chat_group_id,
-                });
-                return NextResponse.json({ success: false, error: 'Unauthorized - not a member of this chat group' }, { status: 403 });
-            }
-            // Cannot mark your own messages as read
-            if (message.sender_user_id === current_user_id) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] User cannot mark own message as read:', {
+                // Get current user ID
+                const current_user_id = getUserIdFromRequest
+                    ? await getUserIdFromRequest(request)
+                    : await defaultGetUserIdFromRequest();
+                if (!current_user_id) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] No user ID - not authenticated');
+                    return NextResponse.json({ success: false, error: 'User not authenticated' }, { status: 401 });
+                }
+                // Handle params as Promise (Next.js 15+) or direct object (Next.js 13-14)
+                const params = context.params instanceof Promise ? await context.params : context.params;
+                const message_id = params.id;
+                if (!message_id) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] Missing message ID');
+                    return NextResponse.json({ success: false, error: 'Message ID is required' }, { status: 400 });
+                }
+                // Validate UUID formats before database queries
+                if (!is_valid_uuid(message_id)) {
+                    logger.debug('[hazo_chat/messages/[id]/read PATCH] Invalid message_id format:', { message_id });
+                    return NextResponse.json({ success: false, error: 'message_id must be a valid UUID', error_code: 'INVALID_UUID_FORMAT' }, { status: 400 });
+                }
+                if (!is_valid_uuid(current_user_id)) {
+                    logger.debug('[hazo_chat/messages/[id]/read PATCH] Invalid user_id format:', { current_user_id });
+                    return NextResponse.json({ success: false, error: 'Invalid user ID format', error_code: 'INVALID_UUID_FORMAT' }, { status: 400 });
+                }
+                logger.info('[hazo_chat/messages/[id]/read PATCH] Marking message as read:', {
                     message_id,
                     current_user_id,
                 });
-                return NextResponse.json({ success: false, error: 'Cannot mark your own messages as read' }, { status: 400 });
-            }
-            // Don't update if already read
-            if (message.read_at) {
-                logger.info('[hazo_chat/messages/[id]/read PATCH] Message already read:', { message_id });
+                // Get hazo_connect instance and create CRUD service
+                const hazoConnect = getHazoConnect();
+                const chatService = createCrudService(hazoConnect, 'hazo_chat');
+                // First, fetch the message to verify ownership
+                let message = null;
+                try {
+                    const messages = await chatService.list((qb) => qb.select('*').where('id', 'eq', message_id));
+                    message = messages[0] || null;
+                }
+                catch (dbError) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] Database error fetching message:', { dbError: serialize_error(dbError) });
+                    throw dbError;
+                }
+                if (!message) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] Message not found:', { message_id });
+                    return NextResponse.json({ success: false, error: 'Message not found' }, { status: 404 });
+                }
+                // Verify that the current user is a member of the chat group
+                const membership = await verifyGroupMembership(hazoConnect, current_user_id, message.chat_group_id, logger);
+                if (!membership) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] User is not a member of chat group:', {
+                        message_id,
+                        current_user_id,
+                        chat_group_id: message.chat_group_id,
+                    });
+                    return NextResponse.json({ success: false, error: 'Unauthorized - not a member of this chat group' }, { status: 403 });
+                }
+                // Cannot mark your own messages as read
+                if (message.sender_user_id === current_user_id) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] User cannot mark own message as read:', {
+                        message_id,
+                        current_user_id,
+                    });
+                    return NextResponse.json({ success: false, error: 'Cannot mark your own messages as read' }, { status: 400 });
+                }
+                // Don't update if already read
+                if (message.read_at) {
+                    logger.debug('[hazo_chat/messages/[id]/read PATCH] Message already read:', { message_id });
+                    return NextResponse.json({
+                        success: true,
+                        message: {
+                            ...message,
+                            read_at: message.read_at,
+                        },
+                    });
+                }
+                // Update the read_at timestamp using the adapter-agnostic CRUD service
+                const now = new Date().toISOString();
+                try {
+                    const updated_rows = await chatService.updateById(message_id, {
+                        read_at: now,
+                        changed_at: now,
+                    });
+                    if (updated_rows.length === 0) {
+                        logger.warn('[hazo_chat/messages/[id]/read PATCH] No rows updated - message may not exist:', { message_id });
+                    }
+                    else {
+                        logger.debug('[hazo_chat/messages/[id]/read PATCH] Successfully updated', { rows: updated_rows.length });
+                    }
+                }
+                catch (dbError) {
+                    logger.error('[hazo_chat/messages/[id]/read PATCH] Database error updating message:', { dbError: serialize_error(dbError) });
+                    throw dbError;
+                }
+                logger.debug('[hazo_chat/messages/[id]/read PATCH] Message marked as read successfully:', { message_id });
                 return NextResponse.json({
                     success: true,
                     message: {
                         ...message,
-                        read_at: message.read_at,
+                        read_at: now,
+                        changed_at: now,
                     },
                 });
             }
-            // Update the read_at timestamp using the adapter-agnostic CRUD service
-            const now = new Date().toISOString();
-            try {
-                const updated_rows = await chatService.updateById(message_id, {
-                    read_at: now,
-                    changed_at: now,
-                });
-                if (updated_rows.length === 0) {
-                    logger.warn('[hazo_chat/messages/[id]/read PATCH] No rows updated - message may not exist:', { message_id });
-                }
-                else {
-                    logger.info('[hazo_chat/messages/[id]/read PATCH] Successfully updated', { rows: updated_rows.length });
-                }
+            catch (error) {
+                const error_message = error instanceof Error ? error.message : 'Unknown error';
+                logger.error('[hazo_chat/messages/[id]/read PATCH] Error:', { error_message, error: serialize_error(error) });
+                return NextResponse.json({ success: false, error: 'Failed to mark message as read' }, { status: 500 });
             }
-            catch (dbError) {
-                logger.error('[hazo_chat/messages/[id]/read PATCH] Database error updating message:', { dbError: serialize_error(dbError) });
-                throw dbError;
-            }
-            logger.info('[hazo_chat/messages/[id]/read PATCH] Message marked as read successfully:', { message_id });
-            return NextResponse.json({
-                success: true,
-                message: {
-                    ...message,
-                    read_at: now,
-                    changed_at: now,
-                },
-            });
-        }
-        catch (error) {
-            const error_message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error('[hazo_chat/messages/[id]/read PATCH] Error:', { error_message, error: serialize_error(error) });
-            return NextResponse.json({ success: false, error: 'Failed to mark message as read' }, { status: 500 });
-        }
+        }); // end withContext
     }
     return { PATCH };
 }
@@ -547,117 +546,119 @@ export function createDeleteHandler(options) {
      * Only the sender can delete their own messages.
      */
     async function DELETE(request, context) {
-        try {
-            // Get current user ID
-            const current_user_id = getUserIdFromRequest
-                ? await getUserIdFromRequest(request)
-                : await defaultGetUserIdFromRequest();
-            if (!current_user_id) {
-                logger.error('[hazo_chat/messages/[id] DELETE] No user ID - not authenticated');
-                return createErrorResponse('User not authenticated', 401, 'UNAUTHENTICATED');
-            }
-            // Handle params as Promise (Next.js 15+) or direct object (Next.js 13-14)
-            const params = context.params instanceof Promise ? await context.params : context.params;
-            const message_id = params.id;
-            if (!message_id) {
-                logger.error('[hazo_chat/messages/[id] DELETE] Missing message ID');
-                return createErrorResponse('Message ID is required', 400, 'MISSING_MESSAGE_ID');
-            }
-            // Validate UUID formats before database queries
-            if (!is_valid_uuid(message_id)) {
-                logger.debug('[hazo_chat/messages/[id] DELETE] Invalid message_id format:', { message_id });
-                return createErrorResponse('message_id must be a valid UUID', 400, 'INVALID_UUID_FORMAT');
-            }
-            if (!is_valid_uuid(current_user_id)) {
-                logger.debug('[hazo_chat/messages/[id] DELETE] Invalid user_id format:', { current_user_id });
-                return createErrorResponse('Invalid user ID format', 400, 'INVALID_UUID_FORMAT');
-            }
-            logger.info('[hazo_chat/messages/[id] DELETE] Deleting message:', {
-                message_id,
-                current_user_id,
-            });
-            // Get hazo_connect instance and create CRUD service
-            const hazoConnect = getHazoConnect();
-            const chatService = createCrudService(hazoConnect, 'hazo_chat');
-            // Fetch the message to verify ownership
-            let message = null;
+        return withContext({}, async () => {
             try {
-                const messages = await chatService.list((qb) => qb.select('*').where('id', 'eq', message_id));
-                message = messages[0] || null;
-            }
-            catch (dbError) {
-                logger.error('[hazo_chat/messages/[id] DELETE] Database error fetching message:', { dbError: serialize_error(dbError) });
-                throw dbError;
-            }
-            if (!message) {
-                logger.error('[hazo_chat/messages/[id] DELETE] Message not found:', { message_id });
-                return createErrorResponse('Message not found', 404, 'MESSAGE_NOT_FOUND');
-            }
-            // Verify that the current user is a member of the chat group
-            const membership = await verifyGroupMembership(hazoConnect, current_user_id, message.chat_group_id, logger);
-            if (!membership) {
-                logger.error('[hazo_chat/messages/[id] DELETE] User is not a member of chat group:', {
-                    message_id,
-                    current_user_id,
-                    chat_group_id: message.chat_group_id,
-                });
-                return createErrorResponse('Unauthorized - not a member of this chat group', 403, 'FORBIDDEN');
-            }
-            // Verify that the current user is the sender (only senders can delete their messages)
-            if (message.sender_user_id !== current_user_id) {
-                logger.error('[hazo_chat/messages/[id] DELETE] User is not the sender:', {
+                // Get current user ID
+                const current_user_id = getUserIdFromRequest
+                    ? await getUserIdFromRequest(request)
+                    : await defaultGetUserIdFromRequest();
+                if (!current_user_id) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] No user ID - not authenticated');
+                    return createErrorResponse('User not authenticated', 401, 'UNAUTHENTICATED');
+                }
+                // Handle params as Promise (Next.js 15+) or direct object (Next.js 13-14)
+                const params = context.params instanceof Promise ? await context.params : context.params;
+                const message_id = params.id;
+                if (!message_id) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] Missing message ID');
+                    return createErrorResponse('Message ID is required', 400, 'MISSING_MESSAGE_ID');
+                }
+                // Validate UUID formats before database queries
+                if (!is_valid_uuid(message_id)) {
+                    logger.debug('[hazo_chat/messages/[id] DELETE] Invalid message_id format:', { message_id });
+                    return createErrorResponse('message_id must be a valid UUID', 400, 'INVALID_UUID_FORMAT');
+                }
+                if (!is_valid_uuid(current_user_id)) {
+                    logger.debug('[hazo_chat/messages/[id] DELETE] Invalid user_id format:', { current_user_id });
+                    return createErrorResponse('Invalid user ID format', 400, 'INVALID_UUID_FORMAT');
+                }
+                logger.info('[hazo_chat/messages/[id] DELETE] Deleting message:', {
                     message_id,
                     current_user_id,
-                    sender_user_id: message.sender_user_id,
                 });
-                return createErrorResponse('Unauthorized - only the sender can delete their messages', 403, 'UNAUTHORIZED');
-            }
-            // Check if already deleted
-            if (message.deleted_at) {
-                logger.info('[hazo_chat/messages/[id] DELETE] Message already deleted:', { message_id });
+                // Get hazo_connect instance and create CRUD service
+                const hazoConnect = getHazoConnect();
+                const chatService = createCrudService(hazoConnect, 'hazo_chat');
+                // Fetch the message to verify ownership
+                let message = null;
+                try {
+                    const messages = await chatService.list((qb) => qb.select('*').where('id', 'eq', message_id));
+                    message = messages[0] || null;
+                }
+                catch (dbError) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] Database error fetching message:', { dbError: serialize_error(dbError) });
+                    throw dbError;
+                }
+                if (!message) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] Message not found:', { message_id });
+                    return createErrorResponse('Message not found', 404, 'MESSAGE_NOT_FOUND');
+                }
+                // Verify that the current user is a member of the chat group
+                const membership = await verifyGroupMembership(hazoConnect, current_user_id, message.chat_group_id, logger);
+                if (!membership) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] User is not a member of chat group:', {
+                        message_id,
+                        current_user_id,
+                        chat_group_id: message.chat_group_id,
+                    });
+                    return createErrorResponse('Unauthorized - not a member of this chat group', 403, 'FORBIDDEN');
+                }
+                // Verify that the current user is the sender (only senders can delete their messages)
+                if (message.sender_user_id !== current_user_id) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] User is not the sender:', {
+                        message_id,
+                        current_user_id,
+                        sender_user_id: message.sender_user_id,
+                    });
+                    return createErrorResponse('Unauthorized - only the sender can delete their messages', 403, 'UNAUTHORIZED');
+                }
+                // Check if already deleted
+                if (message.deleted_at) {
+                    logger.debug('[hazo_chat/messages/[id] DELETE] Message already deleted:', { message_id });
+                    return NextResponse.json({
+                        success: true,
+                        message: {
+                            ...message,
+                            message_text: null,
+                        },
+                    });
+                }
+                // Soft delete: set deleted_at timestamp and clear message_text using adapter-agnostic CRUD service
+                const now = new Date().toISOString();
+                try {
+                    const updated_rows = await chatService.updateById(message_id, {
+                        deleted_at: now,
+                        message_text: null,
+                        changed_at: now,
+                    });
+                    if (updated_rows.length === 0) {
+                        logger.warn('[hazo_chat/messages/[id] DELETE] No rows updated - message may not exist:', { message_id });
+                    }
+                    else {
+                        logger.debug('[hazo_chat/messages/[id] DELETE] Successfully deleted', { rows: updated_rows.length });
+                    }
+                }
+                catch (dbError) {
+                    logger.error('[hazo_chat/messages/[id] DELETE] Database error deleting message:', { dbError: serialize_error(dbError) });
+                    throw dbError;
+                }
+                logger.debug('[hazo_chat/messages/[id] DELETE] Message deleted successfully:', { message_id });
                 return NextResponse.json({
                     success: true,
                     message: {
                         ...message,
+                        deleted_at: now,
                         message_text: null,
+                        changed_at: now,
                     },
                 });
             }
-            // Soft delete: set deleted_at timestamp and clear message_text using adapter-agnostic CRUD service
-            const now = new Date().toISOString();
-            try {
-                const updated_rows = await chatService.updateById(message_id, {
-                    deleted_at: now,
-                    message_text: null,
-                    changed_at: now,
-                });
-                if (updated_rows.length === 0) {
-                    logger.warn('[hazo_chat/messages/[id] DELETE] No rows updated - message may not exist:', { message_id });
-                }
-                else {
-                    logger.info('[hazo_chat/messages/[id] DELETE] Successfully deleted', { rows: updated_rows.length });
-                }
+            catch (error) {
+                const error_message = error instanceof Error ? error.message : 'Unknown error';
+                logger.error('[hazo_chat/messages/[id] DELETE] Error:', { error_message, error: serialize_error(error) });
+                return createErrorResponse('Failed to delete message', 500, 'INTERNAL_ERROR');
             }
-            catch (dbError) {
-                logger.error('[hazo_chat/messages/[id] DELETE] Database error deleting message:', { dbError: serialize_error(dbError) });
-                throw dbError;
-            }
-            logger.info('[hazo_chat/messages/[id] DELETE] Message deleted successfully:', { message_id });
-            return NextResponse.json({
-                success: true,
-                message: {
-                    ...message,
-                    deleted_at: now,
-                    message_text: null,
-                    changed_at: now,
-                },
-            });
-        }
-        catch (error) {
-            const error_message = error instanceof Error ? error.message : 'Unknown error';
-            logger.error('[hazo_chat/messages/[id] DELETE] Error:', { error_message, error: serialize_error(error) });
-            return createErrorResponse('Failed to delete message', 500, 'INTERNAL_ERROR');
-        }
+        }); // end withContext
     }
     return { DELETE };
 }