Evolution API webhook sample code.

[xxats]

I'm implementing a webhook using the Evolution API.
However, the doc only shows you to register a webhook.
I urgently need sample code.

[MeeTyHA]

Hi, Now I am integrating the whatsapp using Evolution API.
This is webhook code that I implemented.

import { NextRequest, NextResponse } from 'next/server';
import { supabaseAdmin as supabase } from '@/auth/context/supabase/lib';
import uuidv4 from '@/utils/uuidv4';
import { evolutionAPIService } from '@/services/evolution-api';

// Helper function to get server timestamp in ISO format
function getServerTimestamp(): string {
  return new Date().toISOString();
}

// Helper function to normalize timestamp to server time
// This ensures all timestamps are based on the server's timezone and clock
function normalizeTimestamp(timestamp?: string | number | Date): string {
  // If no timestamp provided, use server time
  if (!timestamp) {
    return getServerTimestamp();
  }
  
  // If it's already a string in ISO format, return as is
  if (typeof timestamp === 'string' && timestamp.includes('T')) {
    return timestamp;
  }
  
  // If it's a number (Unix timestamp), convert to server time
  if (typeof timestamp === 'number') {
    return new Date(timestamp).toISOString();
  }
  
  // If it's a Date object, convert to ISO string
  if (timestamp instanceof Date) {
    return timestamp.toISOString();
  }
  
  // Fallback to server time
  return getServerTimestamp();
}

// Helper function to sanitize filename for Supabase storage
function sanitizeFileName(fileName: string): string {
  return fileName
    // Remove or replace accented characters
    .normalize('NFD')
    .replace(/[\u0300-\u036f]/g, '')
    // Replace spaces with underscores
    .replace(/\s+/g, '_')
    // Remove special characters except dots, hyphens, and underscores
    .replace(/[^a-zA-Z0-9._-]/g, '')
    // Remove multiple consecutive dots
    .replace(/\.{2,}/g, '.')
    // Remove leading/trailing dots
    .replace(/^\.+|\.+$/g, '')
    // Ensure it's not empty
    || 'file';
}

// Helper function to create a safe filename for storage while preserving original name
function createSafeFileName(originalFileName: string): { safeName: string; originalName: string } {
  const fileExt = originalFileName.split('.').pop() || '';
  const nameWithoutExt = originalFileName.substring(0, originalFileName.lastIndexOf('.'));
  
  // Create a safe filename for storage
  const safeName = `${uuidv4()}.${fileExt}`;
  
  return {
    safeName,
    originalName: originalFileName
  };
}

// Helper function to download media from Evolution API and store in Supabase
async function downloadAndStoreMedia(
  instanceName: string,
  messageKey: any,
  mediaType: string, 
  mimeType?: string, 
  fileName?: string
): Promise<{ publicUrl: string; attachment: any } | null> {
  try {
    console.log(`Downloading media from Evolution API - Instance: ${instanceName}, MessageId: ${messageKey?.id}`);
    
    // Download the media file from Evolution API
    const mediaBuffer = await evolutionAPIService.downloadMedia(
      instanceName,
      messageKey?.id || '',
      mediaType as 'image' | 'video' | 'audio' | 'document'
    );
    
    const fileBuffer = new Uint8Array(mediaBuffer);
    console.log(`Media buffer received - Size: ${fileBuffer.length} bytes`);
    
    // Generate file name and extension
    const fileExt = mimeType?.split('/')[1] || 'bin';
    const { safeName, originalName } = fileName ? createSafeFileName(fileName) : { safeName: `${uuidv4()}.${fileExt}`, originalName: `file.${fileExt}` };
    const filePath = `whatsapp-media/${safeName}`;
    
    console.log(`Uploading to Supabase storage - Path: ${filePath}, OriginalFileName: ${originalName}`);
    
    // Upload to Supabase storage
    const { data: uploadData, error: uploadError } = await supabase.storage
      .from('chat-attachments')
      .upload(filePath, fileBuffer, {
        contentType: mimeType || 'application/octet-stream',
      });
    
    if (uploadError) {
      console.error('Supabase upload error:', uploadError);
      return null;
    }
    
    console.log(`Supabase upload successful - Data:`, uploadData);
    
    // Get public URL
    const { data: { publicUrl } } = supabase.storage
      .from('chat-attachments')
      .getPublicUrl(filePath);
    
    // Create attachment object with original file name
    const attachment = {
      name: originalName,
      size: mediaBuffer.byteLength,
      type: mimeType || 'application/octet-stream',
      path: filePath,
      preview: publicUrl,
      createdAt: normalizeTimestamp(),
      modifiedAt: normalizeTimestamp(),
    };
    
    console.log(`Media uploaded successfully: ${publicUrl}`);
    return { publicUrl, attachment };
  } catch (error) {
    console.error('Error downloading and storing media from Evolution API:', error);
    console.error('Detailed error info:', {
      instanceName,
      messageId: messageKey?.id,
      mediaType,
      mimeType,
      error: error instanceof Error ? error.message : String(error),
      stack: error instanceof Error ? error.stack : undefined
    });
    return null;
  }
}

export async function POST(req: NextRequest) {
  try {
    const body = await req.json();
    console.log('Evolution API webhook received:', JSON.stringify(body, null, 2));

    // Handle different event types
    if (body.event === 'messages.upsert') {
      await handleMessage(body);
    } else if (body.event === 'messages.update' || body.event === 'message-receipt.update') {
      await handleMessageUpdate(body);
    } else if (body.event === 'connection.update') {
      await handleConnectionUpdate(body);
    } else if (body.event === 'presence.update') {
      await handlePresenceUpdate(body);
    } else if (body.event === 'qrcode.updated') {
      await handleQRCodeUpdate(body);
    } else {
      console.log('Unhandled event type:', body.event);
    }

    return NextResponse.json({ success: true });
  } catch (error) {
    console.error('Evolution webhook error:', error);
    return NextResponse.json({ error: 'Failed to process webhook' }, { status: 500 });
  }
}

async function handleMessage(data: any) {
  try {
    const { instance, data: messageData } = data;
    const instanceName = instance;
    
    if (!messageData?.message) {
      console.log('No messages in webhook data');
      return;
    }

    const message = messageData;
    
    // Extract phone number - handle different formats
    let from = message.key?.remoteJid;
    if (from) {
      from = from.replace('@s.whatsapp.net', '').replace('@g.us', '');
    }

    // Skip group messages for now
    if (message.key?.remoteJid?.includes('@g.us')) {
      console.log('Skipping group message');
      return;
    }

    // Extract message content based on type
    let messageText = '';
    let contentType = 'text';
    let attachments: any[] = [];

    if (message.message?.conversation) {
      messageText = message.message.conversation;
      contentType = 'text';
    } else if (message.message?.extendedTextMessage?.text) {
      messageText = message.message.extendedTextMessage.text;
      contentType = 'text';
    } else if (message.message?.imageMessage) {
      const imageMessage = message.message.imageMessage;
      messageText = imageMessage.caption || '[Image]';
      contentType = 'image';
      
      console.log(`Processing image message - MessageId: ${message.key?.id}, MimeType: ${imageMessage.mimetype}, Caption: ${imageMessage.caption}`);
      
      // Handle image download and storage
      try {
        const mediaResult = await downloadAndStoreMedia(instanceName, message.key, 'image', imageMessage.mimetype);
        if (mediaResult) {
          messageText = mediaResult.publicUrl;
          attachments = [mediaResult.attachment];
          console.log(`Image processed successfully - URL: ${mediaResult.publicUrl}, Size: ${mediaResult.attachment.size} bytes`);
        } else {
          console.error('Failed to download and store image - mediaResult is null');
          messageText = '[Image - Failed to process]';
        }
      } catch (error) {
        console.error('Error downloading image:', error);
        console.error('Image processing failed for message:', {
          messageId: message.key?.id,
          instanceName,
          mimeType: imageMessage.mimetype,
          error: error instanceof Error ? error.message : String(error)
        });
        messageText = '[Image - Processing failed]';
      }
    } else if (message.message?.videoMessage) {
      const videoMessage = message.message.videoMessage;
      messageText = videoMessage.caption || '[Video]';
      contentType = 'video';
      
      // Handle video download and storage
      try {
        const mediaResult = await downloadAndStoreMedia(instanceName, message.key, 'video', videoMessage.mimetype);
        if (mediaResult) {
          messageText = mediaResult.publicUrl;
          attachments = [mediaResult.attachment];
        }
      } catch (error) {
        console.error('Error downloading video:', error);
      }
    } else if (message.message?.audioMessage) {
      const audioMessage = message.message.audioMessage;
      
      // Extract original filename from WhatsApp audio message
      // WhatsApp audio messages may have a filename or we can generate one based on server timestamp
      const serverTimestamp = Math.floor(Date.now() / 1000); // Unix timestamp in seconds
      const originalFileName = audioMessage.fileName || `audio_${serverTimestamp}.${audioMessage.mimetype?.split('/')[1] || 'mp3'}`;
      
      messageText = originalFileName;
      contentType = 'audio';
      
      console.log(`Processing audio message - MessageId: ${message.key?.id}, MimeType: ${audioMessage.mimetype}, FileName: ${originalFileName}`);
      
      // Handle audio download and storage
      try {
        const mediaResult = await downloadAndStoreMedia(instanceName, message.key, 'audio', audioMessage.mimetype, originalFileName);
        if (mediaResult) {
          messageText = mediaResult.publicUrl;
          attachments = [mediaResult.attachment];
          console.log(`Audio processed successfully - URL: ${mediaResult.publicUrl}, Size: ${mediaResult.attachment.size} bytes, Name: ${mediaResult.attachment.name}`);
        } else {
          console.error('Failed to download and store audio - mediaResult is null');
          messageText = '[Audio - Failed to process]';
        }
      } catch (error) {
        console.error('Error downloading audio:', error);
        console.error('Audio processing failed for message:', {
          messageId: message.key?.id,
          instanceName,
          mimeType: audioMessage.mimetype,
          fileName: originalFileName,
          error: error instanceof Error ? error.message : String(error)
        });
        messageText = '[Audio - Processing failed]';
      }
    } else if (message.message?.documentMessage) {
      const documentMessage = message.message.documentMessage;
      const originalFileName = documentMessage.fileName || 'Document';
      messageText = originalFileName;
      contentType = 'file';
      
      // Handle document download and storage
      try {
        const mediaResult = await downloadAndStoreMedia(instanceName, message.key, 'document', documentMessage.mimetype, originalFileName);
        if (mediaResult) {
          messageText = mediaResult.publicUrl;
          attachments = [mediaResult.attachment];
        }
      } catch (error) {
        console.error('Error downloading document:', error);
      }
    } else if (message.message?.stickerMessage) {
      const stickerMessage = message.message.stickerMessage;
      messageText = '[Sticker]';
      contentType = 'sticker';
      
      // Handle sticker download and storage
      try {
        const mediaResult = await downloadAndStoreMedia(instanceName, message.key, 'document', stickerMessage.mimetype);
        if (mediaResult) {
          messageText = mediaResult.publicUrl;
          attachments = [mediaResult.attachment];
        }
      } catch (error) {
        console.error('Error downloading sticker:', error);
      }
    } else if (message.message?.reactionMessage) {
      contentType = 'reaction';
    } else {
      console.log('Unknown message type:', Object.keys(message.message || {}));
      messageText = '[Unknown message type]';
    }

    if (!from || (!messageText && contentType === 'text') || !instanceName) {
      console.log('Missing required message data:', { from, messageText, instanceName, contentType });
      return;
    }

    // Determine if this is an outgoing message (sent by the team)
    const isOutgoing = message.key?.fromMe;
    
    console.log('Processing message:', { from, messageText, instanceName, contentType, isOutgoing });

    // Find the team that owns this instance
    const { data: team, error: teamError } = await supabase
      .from('teams')
      .select('id')
      .eq('whatsapp_instance_name', instanceName)
      .single();

    if (teamError || !team) {
      console.error('Team not found for instance:', instanceName, teamError);
      return;
    }

    // Find or create the contact by phone number
    let { data: contact, error: contactError } = await supabase
      .from('contacts')
      .select('id, team_id, name')
      .eq('phoneNumber', from)
      .eq('team_id', team.id)
      .single();

    if (contactError || !contact) {
      console.log('Contact not found, creating new one:', from);
      
      // Create new contact
      const newContactId = uuidv4();
      const { data: newContact, error: createContactError } = await supabase
        .from('contacts')
        .insert({
          id: newContactId,
          phoneNumber: from,
          name: from, // Use phone number as name initially
          team_id: team.id,
          status: 'active',
          created_at: normalizeTimestamp(),
          updated_at: normalizeTimestamp(),
        })
        .select('id, team_id, name')
        .single();

      if (createContactError) {
        console.error('Error creating contact:', createContactError);
        return;
      }

      contact = newContact;
      console.log('Created new contact:', contact.id);
    }

    // Find or create conversation for this contact
    let { data: participantRow, error: participantError } = await supabase
      .from('conversation_participants')
      .select('conversation_id, conversations(id, status)')
      .eq('user_id', contact.id)
      .eq('team_id', contact.team_id);

    if (participantError) {
      console.error('Error finding conversation participant:', participantError);
      return;
    }

    let conversationId = participantRow?.[0]?.conversation_id;

    if (!conversationId) {
      console.log('No conversation found, creating new one for contact:', contact.id);
      
      // Create new conversation
      const newConversationId = uuidv4();
      const { error: createConversationError } = await supabase
        .from('conversations')
        .insert({
          id: newConversationId,
          status: 'serving',
          unread_count: 0,
          team_id: contact.team_id,
          created_at: normalizeTimestamp(),
          updated_at: normalizeTimestamp(),
        });

      if (createConversationError) {
        console.error('Error creating conversation:', createConversationError);
        return;
      }

      // Add contact as participant
      const { error: addParticipantError } = await supabase
        .from('conversation_participants')
        .insert({
          conversation_id: newConversationId,
          user_id: contact.id,
          team_id: contact.team_id,
          created_at: normalizeTimestamp(),
        });

      if (addParticipantError) {
        console.error('Error adding conversation participant:', addParticipantError);
        return;
      }

      conversationId = newConversationId;
      console.log('Created new conversation:', conversationId);
    }

    if(contentType === 'reaction') {
      const reactionMessage = message.message.reactionMessage;
      const reactionMessageId = reactionMessage.key.id;
      messageText = reactionMessage.text;
      // Fetch the current reactions for the message
      const { data: messageRows, error: fetchError } = await supabase
        .from('conversation_messages')
        .select('reactions')
        .eq('whatsapp_message_id', reactionMessageId)
        .maybeSingle();

      if (fetchError) throw fetchError;

      // Prepare the new reactions array
      let newReactions = [];
      if (messageRows && Array.isArray(messageRows.reactions)) {
        // Remove any previous reaction by this user
        newReactions = messageRows.reactions.filter(
          (r: { userId: string }) => r.userId !== contact.id
        );
      }
      // Add the new reaction
      if(messageText) newReactions.push({ emoji: messageText, userId: contact.id });
      else newReactions = newReactions.filter((r: { userId: string }) => r.userId !== contact.id);

      const { error: reactionError } = await supabase
        .from('conversation_messages')
        .update({ reactions: newReactions, updated_at: normalizeTimestamp() })
        .eq('whatsapp_message_id', reactionMessageId);

      if (reactionError) throw reactionError;
      return;
    }
    
    // Extract reply information from the message
    let replyId = message?.contextInfo?.stanzaId || null;

    // Insert the new message into the conversation
    const newId = uuidv4();
    const { error: msgError } = await supabase
      .from('conversation_messages')
      .insert({
        id: newId,
        conversation_id: conversationId,
        sender_id: isOutgoing ? null : contact.id, // null for outgoing messages (sent by team), contact.id for incoming
        body: messageText,
        attachments: attachments,
        content_type: contentType,
        created_at: normalizeTimestamp(),
        team_id: contact.team_id,
        whatsapp_message_id: message.key?.id,
        reply_id: replyId,
      });

    if (msgError) {
      console.error('Error inserting message:', msgError);
      return;
    }

    // Update conversation timestamp and increment unread count (only for incoming messages)
    const updateData: any = { 
      updated_at: normalizeTimestamp()
    };

    // Only increment unread count for incoming messages (not outgoing messages sent by the team)
    if (!isOutgoing) {
      const { data: currentConversation } = await supabase
        .from('conversations')
        .select('unread_count')
        .eq('id', conversationId)
        .single();

      const currentUnreadCount = currentConversation?.unread_count || 0;
      updateData.unread_count = currentUnreadCount + 1;
    }
    
    await supabase
      .from('conversations')
      .update(updateData)
      .eq('id', conversationId);

    console.log(`${isOutgoing ? 'Outgoing' : 'Incoming'} message processed successfully:`, newId);

    // Update participant presence/last activity on incoming messages
    try {
      if (!isOutgoing && contact?.id && contact?.team_id) {
        const { error: presenceUpdateError } = await supabase
          .from('conversation_participants')
          .update({ status: 'online', last_activity: normalizeTimestamp() })
          .eq('user_id', contact.id)
          .eq('team_id', contact.team_id);

        if (presenceUpdateError) {
          console.error('Failed to update participant last activity on message:', presenceUpdateError);
        } else {
          console.log('Participant presence updated to online due to incoming message');
        }
      }
    } catch (presenceErr) {
      console.warn('Error while updating participant presence on message:', presenceErr);
    }
  } catch (error) {
    console.error('Error handling message:', error);
  }
}

// Handle message delivery/read/played status updates
async function handleMessageUpdate(data: any) {
  try {
    const instance = data?.instance;
    const instanceName = typeof instance === 'string' ? instance : instance?.instanceName || instance?.name;

    // Evolution/Baileys can send various shapes; normalize into an array of updates
    const payload = data?.data;
    const updates: any[] = Array.isArray(payload)
      ? payload
      : (payload?.updates || payload?.messages || payload?.statuses || (payload ? [payload] : []));

    if (!updates || !updates.length) {
      console.log('No message updates in webhook data');
      return;
    }

    for (const update of updates) {
      const key = update?.key || update?.message?.key || {};
      const messageId: string | undefined = key?.id || update?.id || update?.messageId;
      if (!messageId) continue;

      // Possible sources for ack/status
      const ackVal = update?.update?.status ?? update?.status ?? update?.ack;
      const statusStr = typeof ackVal === 'string' ? ackVal.toLowerCase() : undefined;
      const ackNum = typeof ackVal === 'number' ? ackVal : undefined;

      // Map to canonical status
      let whatsapp_status: string | null = null;
      if (typeof ackNum === 'number') {
        // Baileys ack mapping: 1 sent, 2 delivered, 3 read, 4 played
        if (ackNum <= 0) whatsapp_status = 'pending';
        else if (ackNum === 1) whatsapp_status = 'sent';
        else if (ackNum === 2) whatsapp_status = 'delivered';
        else if (ackNum === 3) whatsapp_status = 'read';
        else if (ackNum >= 4) whatsapp_status = 'played';
      } else if (statusStr) {
        if (['sent', 'delivered', 'read', 'played', 'pending'].includes(statusStr)) {
          whatsapp_status = statusStr;
        }
      }

      // Timestamps if present
      const deliveredTs = update?.update?.deliveryTimestamp || update?.deliveryTimestamp || update?.timestamp;
      const readTs = update?.update?.readTimestamp || update?.readTimestamp || update?.userReceipt?.[0]?.readTimestamp;
      const playedTs = update?.update?.playedTimestamp || update?.playedTimestamp;

      const updatesToApply: any = { updated_at: normalizeTimestamp() };
      if (typeof ackNum === 'number') updatesToApply.whatsapp_ack = ackNum;
      if (whatsapp_status) updatesToApply.whatsapp_status = whatsapp_status;
      if (!updatesToApply.whatsapp_status && statusStr) updatesToApply.whatsapp_status = statusStr;
      if (deliveredTs || whatsapp_status === 'delivered') updatesToApply.delivered_at = normalizeTimestamp(deliveredTs || Date.now());
      if (readTs || whatsapp_status === 'read') updatesToApply.read_at = normalizeTimestamp(readTs || Date.now());
      if (playedTs || whatsapp_status === 'played') updatesToApply.played_at = normalizeTimestamp(playedTs || Date.now());

      // Persist on our message row (ignore if columns are missing)
      const { error } = await supabase
        .from('conversation_messages')
        .update(updatesToApply)
        .eq('whatsapp_message_id', messageId);

      if (error) {
        console.error('Error updating message status (ensure columns exist):', error);
      } else {
        console.log('Updated message status for', messageId, updatesToApply);
      }
    }
  } catch (error) {
    console.error('Error handling message update:', error);
  }
}

async function handleConnectionUpdate(data: any) {
  try {
    const { instance, data: connectionData } = data;
    const instanceName = instance?.instanceName;
    const state = connectionData?.state;

    if (!instanceName || !state) {
      console.log('Missing connection update data:', { instanceName, state });
      return;
    }

    console.log('Connection update:', { instanceName, state });

    // Update the team's WhatsApp status
    const { error } = await supabase
      .from('teams')
      .update({
        whatsapp_status: state,
        updated_at: normalizeTimestamp(),
      })
      .eq('whatsapp_instance_name', instanceName);

    if (error) {
      console.error('Error updating connection status:', error);
    } else {
      console.log('Updated team connection status:', { instanceName, state });
    }
  } catch (error) {
    console.error('Error handling connection update:', error);
  }
}

async function handleQRCodeUpdate(data: any) {
  try {
    const { instance, data: qrData } = data;
    const instanceName = instance?.instanceName;

    if (!instanceName) {
      return;
    }

    console.log('QR code updated for instance:', instanceName);
    
    // You could store the QR code in the database or emit it via websocket
    // For now, we'll just log it
  } catch (error) {
    console.error('Error handling QR code update:', error);
  }
} 

// Handle presence updates to set contacts online/offline
async function handlePresenceUpdate(data: any) {
  try {
    // instance can be a string or an object with instanceName
    const instance = data?.instance;
    const instanceName = typeof instance === 'string' ? instance : instance?.instanceName || instance?.name;
    const payload = data?.data || {};

    if (!instanceName || !payload) {
      console.log('Missing presence update data:', { instanceName, payloadPresent: !!payload });
      return;
    }

    // Resolve team by instanceName
    const { data: team, error: teamError } = await supabase
      .from('teams')
      .select('id')
      .eq('whatsapp_instance_name', instanceName)
      .single();

    if (teamError || !team) {
      console.error('Team not found for presence update. Instance:', instanceName, teamError);
      return;
    }

    // Build a map of jid -> presence from various possible shapes
    const presenceByJid: Record<string, string> = {};

    // Shape A: { id: '123@s.whatsapp.net', presence: 'available' }
    if (payload.id && (payload.presence || payload.lastKnownPresence)) {
      presenceByJid[payload.id] = payload.presence || payload.lastKnownPresence;
    }

    // Shape B: { id: 'group@g.us', presences: { '123@s.whatsapp.net': { lastKnownPresence: 'available' } } }
    if (payload.presences && typeof payload.presences === 'object') {
      Object.entries(payload.presences).forEach(([jid, value]) => {
        const p = (value as any)?.lastKnownPresence || (value as any)?.presence || (value as any);
        if (p) presenceByJid[jid] = p as string;
      });
    }

    // If nothing extracted but we have an id, assume available
    if (!Object.keys(presenceByJid).length && typeof payload.id === 'string') {
      presenceByJid[payload.id] = 'available';
    }

    if (!Object.keys(presenceByJid).length) {
      console.log('No presence entries found in payload');
      return;
    }

    // For each jid, update the corresponding contact participant status
    for (const [jid, presence] of Object.entries(presenceByJid)) {
      if (!jid) continue;
      const phone = jid.replace(/@.+$/, '');
      const normalizedPresence = String(presence).toLowerCase();
      // Map WhatsApp presence to our participant status
      // - unavailable -> offline
      // - available -> online
      // - composing/recording/paused -> keep as-is so UI can show typing/recording
      // - any other presence -> default to online
      let status: any;
      if (normalizedPresence === 'unavailable') status = 'offline';
      else if (normalizedPresence === 'available') status = 'online';
      else if (
        normalizedPresence === 'composing' ||
        normalizedPresence === 'recording' ||
        normalizedPresence === 'paused'
      ) {
        status = normalizedPresence;
      } else {
        status = 'online';
      }
      console.log('---------------------presence', normalizedPresence);
      // Find the contact within this team
      const { data: contact, error: contactError } = await supabase
        .from('contacts')
        .select('id')
        .eq('phoneNumber', phone)
        .eq('team_id', team.id)
        .single();

      if (contactError || !contact) {
        // Not necessarily an error (might be unknown contact yet)
        console.log('Presence for unknown contact or not in team. Phone:', phone);
        continue;
      }

      // Update all conversation_participants rows for this contact in this team
      const { error: updateError } = await supabase
        .from('conversation_participants')
        .update({ status, last_activity: normalizeTimestamp() })
        .eq('user_id', contact.id)
        .eq('team_id', team.id);

      if (updateError) {
        console.error('Error updating participant presence:', updateError);
      } else {
        console.log(`Updated presence for ${phone} -> ${status}`);
      }
    }
  } catch (error) {
    console.error('Error handling presence update:', error);
  }
}
``````````````````````````````````````````````````````````````````````````````````````````````

I hope this helps you.