elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/whatsapp/listeners/meta-message.listener.ts

@@ -0,0 +1,579 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '../../database/prisma.service';
+import { EncryptionService } from '../../integrations/encryption/encryption.service';
+import {
+  WhatsAppAgentService,
+  IncomingMessagePayload,
+} from '../whatsapp-agent.service';
+
+@Injectable()
+export class MetaMessageListener {
+  private readonly logger = new Logger(MetaMessageListener.name);
+
+  private readonly apiVersion: string;
+  private readonly tokenEncryptionKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly whatsappAgent: WhatsAppAgentService,
+    private readonly config: ConfigService,
+    private readonly encryption: EncryptionService,
+  ) {
+    this.apiVersion = this.config.get<string>('META_API_VERSION', 'v21.0');
+    this.tokenEncryptionKey = this.config.get<string>('META_TOKEN_ENCRYPTION_KEY', '');
+  }
+
+  @OnEvent('meta.whatsapp.message')
+  async handleWhatsAppMessage(payload: {
+    wabaId: string;
+    phoneNumberId: string;
+    displayPhoneNumber: string;
+    contacts: any[];
+    messages: any[];
+  }) {
+    // Resolve tenant and clinic from the Meta connection (by Meta phone number ID)
+    const metaConnection = await this.prisma.clinicMetaConnection.findFirst({
+      where: {
+        meta_phone_number_id: payload.phoneNumberId,
+        meta_type: 'whatsapp',
+        meta_is_active: true,
+      },
+      select: {
+        meta_clinic_id: true,
+        clinic: {
+          select: { clinic_tenant_id: true },
+        },
+      },
+    });
+
+    if (!metaConnection) {
+      this.logger.warn(
+        `No active Meta connection found for phoneNumberId=${payload.phoneNumberId}, dropping messages`,
+      );
+      return;
+    }
+
+    const clinicId = metaConnection.meta_clinic_id;
+    const tenantId = metaConnection.clinic.clinic_tenant_id;
+
+    for (const message of payload.messages) {
+      try {
+        const contact = payload.contacts?.[0];
+        const senderPhone = message.from as string;
+        const senderName = contact?.profile?.name || '';
+        const msgType = message.type as string;
+
+        const externalChatId = `${senderPhone}@${payload.phoneNumberId}`;
+        const { text, mediaType, mediaKey, mediaMime, mediaFilename, metadata } =
+          this.extractWhatsAppMessage(message);
+
+        const incoming: IncomingMessagePayload = {
+          tenantId,
+          clinicId,
+          externalChatId,
+          channel: 'whatsapp',
+          phoneNumberId: payload.phoneNumberId,
+          sender: {
+            phone: senderPhone,
+            name: senderName || undefined,
+          },
+          message: {
+            externalId: message.id,
+            text,
+            mediaType,
+            mediaKey,
+            mediaMime,
+            mediaFilename,
+            contentType: msgType !== 'text' ? msgType : undefined,
+            quotedText: this.extractQuotedText(message) ?? undefined,
+            adContext: message.referral ? {
+              source_url: message.referral.source_url,
+              source_type: message.referral.source_type,
+              source_id: message.referral.source_id,
+              headline: message.referral.headline,
+              body: message.referral.body,
+              media_type: message.referral.media_type,
+              media_url: message.referral.media_url,
+              thumbnail_url: message.referral.thumbnail_url,
+              ctwa_clid: message.referral.ctwa_clid,
+            } : undefined,
+            metadata,
+          },
+          timestamp: new Date(parseInt(message.timestamp) * 1000),
+        };
+
+        await this.whatsappAgent.handleIncomingMessage(incoming);
+      } catch (err: any) {
+        this.logger.error(
+          `Failed to process WhatsApp message: ${err.message}`,
+          err.stack,
+        );
+      }
+    }
+  }
+
+  @OnEvent('meta.instagram.message')
+  async handleInstagramMessage(payload: {
+    pageId: string;
+    senderId: string;
+    message: any;
+    postback: any;
+    reaction: any;
+    referral: any;
+    timestamp: number;
+  }) {
+    try {
+      // Resolve tenant and clinic from Meta connection (by Instagram page ID)
+      const metaConnection = await this.prisma.clinicMetaConnection.findFirst({
+        where: {
+          meta_instagram_page_id: payload.pageId,
+          meta_type: 'instagram',
+          meta_is_active: true,
+        },
+        select: {
+          meta_clinic_id: true,
+          meta_encrypted_access_token: true,
+          clinic: {
+            select: { clinic_tenant_id: true },
+          },
+        },
+      });
+
+      if (!metaConnection) {
+        this.logger.warn(
+          `No active Meta connection found for pageId=${payload.pageId}, dropping Instagram message`,
+        );
+        return;
+      }
+
+      // Skip echo messages (sent by our own page/account)
+      if (payload.senderId === payload.pageId || payload.message?.is_echo) {
+        this.logger.debug(`Skipping Instagram echo message from ${payload.senderId}`);
+        return;
+      }
+
+      // Fetch Instagram user profile (username, name)
+      const { displayName } = await this.resolveInstagramProfile(
+        payload.senderId,
+        metaConnection.meta_encrypted_access_token,
+      );
+
+      // Extract message content
+      const { text, mediaType, mediaKey, mediaMime, metadata } =
+        this.extractInstagramMessage(payload);
+
+      const incoming: IncomingMessagePayload = {
+        tenantId: metaConnection.clinic.clinic_tenant_id,
+        clinicId: metaConnection.meta_clinic_id,
+        externalChatId: `${payload.senderId}@${payload.pageId}`,
+        channel: 'instagram',
+        phoneNumberId: payload.pageId,
+        sender: {
+          phone: payload.senderId,
+          name: displayName,
+        },
+        message: {
+          externalId: payload.message?.mid || `ig_${payload.timestamp}`,
+          text,
+          mediaType,
+          mediaKey,
+          mediaMime,
+          contentType: mediaType,
+          metadata,
+          adContext: payload.referral ? {
+            source: payload.referral.source,
+            type: payload.referral.type,
+            ad_id: payload.referral.ad_id,
+          } : undefined,
+        },
+        timestamp: new Date(payload.timestamp * 1000),
+      };
+
+      await this.whatsappAgent.handleIncomingMessage(incoming);
+    } catch (err: any) {
+      this.logger.error(
+        `Failed to process Instagram message: ${err.message}`,
+        err.stack,
+      );
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  INSTAGRAM HELPERS                                                  */
+  /* ------------------------------------------------------------------ */
+
+  private async resolveInstagramProfile(
+    senderId: string,
+    encryptedToken: string | null,
+  ): Promise<{ displayName: string; username: string }> {
+    let senderName = '';
+    let senderUsername = '';
+
+    try {
+      if (encryptedToken && this.tokenEncryptionKey) {
+        const accessToken = this.encryption.decrypt(encryptedToken, this.tokenEncryptionKey);
+        let profileRes = await fetch(
+          `https://graph.instagram.com/${this.apiVersion}/${senderId}?fields=name,username&access_token=${accessToken}`,
+        );
+        if (!profileRes.ok) {
+          profileRes = await fetch(
+            `https://graph.facebook.com/${this.apiVersion}/${senderId}?fields=name,username&access_token=${accessToken}`,
+          );
+        }
+        if (profileRes.ok) {
+          const profile = await profileRes.json();
+          senderName = profile.name || '';
+          senderUsername = profile.username || '';
+        }
+      }
+    } catch {}
+
+    const displayName = senderName || (senderUsername ? `@${senderUsername}` : '') || senderId;
+    return { displayName, username: senderUsername };
+  }
+
+  private extractInstagramMessage(payload: {
+    message: any;
+    postback: any;
+    reaction: any;
+    referral: any;
+  }): {
+    text: string;
+    mediaType?: string;
+    mediaKey?: string;
+    mediaMime?: string;
+    metadata?: Record<string, any>;
+  } {
+    // Reaction (heart / emoji on a message)
+    if (payload.reaction) {
+      const r = payload.reaction;
+      return {
+        text: r.emoji || (r.action === 'react' ? '❤️' : ''),
+        mediaType: r.action === 'unreact' ? 'unreaction' : 'reaction',
+        metadata: {
+          emoji: r.emoji,
+          action: r.action, // 'react' or 'unreact'
+          message_id: r.mid,
+        },
+      };
+    }
+
+    // Postback (ice breaker / persistent menu)
+    if (payload.postback) {
+      return {
+        text: payload.postback.title || payload.postback.payload || '',
+        mediaType: 'postback',
+        metadata: {
+          title: payload.postback.title,
+          payload: payload.postback.payload,
+        },
+      };
+    }
+
+    const msg = payload.message;
+    if (!msg) return { text: '' };
+
+    // Story mention
+    if (msg.attachments?.[0]?.type === 'story_mention') {
+      return {
+        text: msg.text || '',
+        mediaType: 'story_mention',
+        mediaKey: msg.attachments[0].payload?.url,
+        metadata: { url: msg.attachments[0].payload?.url },
+      };
+    }
+
+    // Story reply
+    if (msg.reply_to?.story) {
+      return {
+        text: msg.text || '',
+        mediaType: 'story_reply',
+        mediaKey: msg.reply_to.story.url,
+        metadata: { story_url: msg.reply_to.story.url, story_id: msg.reply_to.story.id },
+      };
+    }
+
+    // Reel reply
+    if (msg.reply_to?.mid) {
+      // reply to a specific message
+      return {
+        text: msg.text || '',
+        mediaType: msg.attachments?.length ? this.getIgAttachmentType(msg.attachments[0]) : undefined,
+        mediaKey: msg.attachments?.[0]?.payload?.url,
+        metadata: { reply_to_mid: msg.reply_to.mid },
+      };
+    }
+
+    // Share (post/reel/profile share)
+    if (msg.attachments?.[0]?.type === 'share') {
+      const share = msg.attachments[0].payload;
+      return {
+        text: msg.text || '',
+        mediaType: 'share',
+        mediaKey: share?.url,
+        metadata: { url: share?.url },
+      };
+    }
+
+    // Unsupported / ephemeral / disappearing / deleted messages
+    if (msg.is_unsupported || msg.is_deleted || msg.attachments?.[0]?.type === 'ephemeral') {
+      return {
+        text: '',
+        mediaType: 'unsupported',
+        metadata: { is_unsupported: !!msg.is_unsupported, is_deleted: !!msg.is_deleted },
+      };
+    }
+
+    // Media attachments (image, video, audio, file, ig_reel, etc.)
+    if (msg.attachments?.length > 0) {
+      const att = msg.attachments[0];
+      const attType = this.getIgAttachmentType(att);
+      const payload = att.payload ?? {};
+
+      // IG Reels — have title, reel_video_id, url
+      if (attType === 'ig_reel') {
+        return {
+          text: payload.title || '',
+          mediaType: 'ig_reel',
+          mediaKey: payload.url,
+          metadata: {
+            url: payload.url,
+            title: payload.title,
+            reel_video_id: payload.reel_video_id,
+          },
+        };
+      }
+
+      return {
+        text: msg.text || '',
+        mediaType: attType,
+        mediaKey: payload.url,
+        mediaMime: payload.mime_type,
+        metadata: payload.sticker_id
+          ? { sticker_id: payload.sticker_id }
+          : payload.url
+            ? { url: payload.url }
+            : undefined,
+      };
+    }
+
+    // Plain text / quick reply
+    if (msg.quick_reply) {
+      return {
+        text: msg.text || msg.quick_reply.payload || '',
+        mediaType: 'quick_reply',
+        metadata: { payload: msg.quick_reply.payload },
+      };
+    }
+
+    // Plain text
+    return { text: msg.text || '' };
+  }
+
+  private getIgAttachmentType(att: any): string {
+    const type = att.type as string;
+    switch (type) {
+      case 'image': return 'image';
+      case 'video': return 'video';
+      case 'audio': return 'voice';
+      case 'file': return 'document';
+      case 'animated_image': return 'sticker';
+      case 'like_heart': return 'reaction';
+      case 'story_mention': return 'story_mention';
+      case 'share': return 'share';
+      case 'reel': return 'ig_reel';
+      case 'ig_reel': return 'ig_reel';
+      default: return type || 'attachment';
+    }
+  }
+
+  /**
+   * Extract all relevant data from a WhatsApp message.
+   * Returns text, media info, and structured metadata for non-text types.
+   */
+  private extractWhatsAppMessage(message: any): {
+    text: string;
+    mediaType?: string;
+    mediaKey?: string;
+    mediaMime?: string;
+    mediaFilename?: string;
+    metadata?: Record<string, any>;
+  } {
+    const type = message.type as string;
+
+    switch (type) {
+      case 'text':
+        return { text: message.text?.body || '' };
+
+      case 'image': {
+        const img = message.image ?? {};
+        if (img.view_once) {
+          return { text: '', mediaType: 'view_once', metadata: { original_type: 'image' } };
+        }
+        return {
+          text: img.caption || '',
+          mediaType: 'image',
+          mediaKey: img.id,
+          mediaMime: img.mime_type,
+        };
+      }
+
+      case 'video': {
+        const vid = message.video ?? {};
+        if (vid.view_once) {
+          return { text: '', mediaType: 'view_once', metadata: { original_type: 'video' } };
+        }
+        return {
+          text: vid.caption || '',
+          mediaType: 'video',
+          mediaKey: vid.id,
+          mediaMime: vid.mime_type,
+        };
+      }
+
+      case 'audio': {
+        const aud = message.audio ?? {};
+        return {
+          text: '',
+          mediaType: aud.voice ? 'voice' : 'audio',
+          mediaKey: aud.id,
+          mediaMime: aud.mime_type,
+        };
+      }
+
+      case 'document': {
+        const doc = message.document ?? {};
+        return {
+          text: doc.caption || '',
+          mediaType: 'document',
+          mediaKey: doc.id,
+          mediaMime: doc.mime_type,
+          mediaFilename: doc.filename,
+        };
+      }
+
+      case 'sticker': {
+        const stk = message.sticker ?? {};
+        return {
+          text: '',
+          mediaType: 'sticker',
+          mediaKey: stk.id,
+          mediaMime: stk.mime_type,
+          metadata: { animated: stk.animated ?? false },
+        };
+      }
+
+      case 'location': {
+        const loc = message.location ?? {};
+        return {
+          text: loc.name
+            ? `📍 ${loc.name}${loc.address ? ` — ${loc.address}` : ''}`
+            : `📍 ${loc.latitude}, ${loc.longitude}`,
+          mediaType: 'location',
+          metadata: {
+            latitude: loc.latitude,
+            longitude: loc.longitude,
+            name: loc.name,
+            address: loc.address,
+            url: loc.url,
+          },
+        };
+      }
+
+      case 'contacts': {
+        const contacts = message.contacts ?? [];
+        const names = contacts.map((c: any) =>
+          c.name?.formatted_name || `${c.name?.first_name || ''} ${c.name?.last_name || ''}`.trim(),
+        ).filter(Boolean);
+        return {
+          text: names.length > 0 ? `👤 ${names.join(', ')}` : '',
+          mediaType: 'contacts',
+          metadata: {
+            contacts: contacts.map((c: any) => ({
+              name: c.name?.formatted_name || '',
+              phones: (c.phones ?? []).map((p: any) => ({ phone: p.phone, type: p.type })),
+              emails: (c.emails ?? []).map((e: any) => ({ email: e.email, type: e.type })),
+            })),
+          },
+        };
+      }
+
+      case 'reaction': {
+        const reaction = message.reaction ?? {};
+        return {
+          text: reaction.emoji || '',
+          mediaType: 'reaction',
+          metadata: {
+            emoji: reaction.emoji,
+            message_id: reaction.message_id,
+          },
+        };
+      }
+
+      case 'interactive': {
+        const interactive = message.interactive ?? {};
+        // Button reply
+        if (interactive.type === 'button_reply') {
+          const reply = interactive.button_reply ?? {};
+          return {
+            text: reply.title || reply.id || '',
+            mediaType: 'button_reply',
+            metadata: { button_id: reply.id, button_title: reply.title },
+          };
+        }
+        // List reply
+        if (interactive.type === 'list_reply') {
+          const reply = interactive.list_reply ?? {};
+          return {
+            text: reply.title || reply.id || '',
+            mediaType: 'list_reply',
+            metadata: { list_id: reply.id, list_title: reply.title, list_description: reply.description },
+          };
+        }
+        return { text: interactive.body?.text || '' };
+      }
+
+      case 'button': {
+        // Quick reply button press (template button callback)
+        return {
+          text: message.button?.text || message.button?.payload || '',
+          mediaType: 'button',
+          metadata: { payload: message.button?.payload },
+        };
+      }
+
+      case 'order': {
+        const order = message.order ?? {};
+        return {
+          text: `🛒 ${(order.product_items ?? []).length} ürün`,
+          mediaType: 'order',
+          metadata: {
+            catalog_id: order.catalog_id,
+            products: (order.product_items ?? []).map((p: any) => ({
+              product_retailer_id: p.product_retailer_id,
+              quantity: p.quantity,
+              item_price: p.item_price,
+              currency: p.currency,
+            })),
+          },
+        };
+      }
+
+      case 'system':
+        return { text: message.system?.body || '', mediaType: 'system' };
+
+      case 'unsupported':
+        return { text: '', mediaType: 'unsupported' };
+
+      default:
+        this.logger.debug(`Unknown WhatsApp message type: ${type}`);
+        return { text: '' };
+    }
+  }
+
+  private extractQuotedText(message: any): string | null {
+    return message.context?.quoted_message?.body || null;
+  }
+}