elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/whatsapp/whatsapp.service.ts

@@ -0,0 +1,592 @@
+import {
+  Injectable,
+  Logger,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { PrismaService } from '../database/prisma.service.js';
+import { EncryptionService } from '../integrations/encryption/encryption.service.js';
+import { MinioService } from '../integrations/minio/minio.service.js';
+import { MetaWhatsAppService } from '../integrations/meta-business/meta-whatsapp.service.js';
+
+/**
+ * Chat/session query service — read-only operations for the dashboard.
+ * Separate from the AI engine (WhatsAppAgentService).
+ */
+@Injectable()
+export class WhatsAppService {
+  private readonly logger = new Logger(WhatsAppService.name);
+  private readonly messageEncryptionKey: string;
+  private readonly tokenEncryptionKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly encryption: EncryptionService,
+    private readonly config: ConfigService,
+    private readonly events: EventEmitter2,
+    private readonly minio: MinioService,
+    private readonly metaWhatsApp: MetaWhatsAppService,
+  ) {
+    this.messageEncryptionKey = this.config.getOrThrow<string>(
+      'MESSAGE_ENCRYPTION_KEY',
+    );
+    this.tokenEncryptionKey = this.config.get<string>(
+      'META_TOKEN_ENCRYPTION_KEY', '',
+    );
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CHAT LIST (paginated)                                              */
+  /* ------------------------------------------------------------------ */
+
+  async findChats(
+    tenantId: string,
+    clinicIds?: string[],
+    query?: string,
+    page = 1,
+    limit = 25,
+    assignedTo?: string,
+    status?: string,
+  ) {
+    const where: any = {
+      chat_tenant_id: tenantId,
+      chat_deleted_at: null,
+    };
+
+    if (clinicIds && clinicIds.length > 0) {
+      where.chat_clinic_id = { in: clinicIds };
+    }
+
+    if (query?.trim()) {
+      const q = query.trim();
+      where.OR = [
+        { chat_contact_name: { contains: q, mode: 'insensitive' } },
+        { chat_contact_phone: { contains: q } },
+      ];
+    }
+
+    // Filter by assigned user (chat-level)
+    if (assignedTo) {
+      where.chat_assigned_to_id = assignedTo;
+    }
+
+    // Filter by session status
+    if (status) {
+      where.sessions = {
+        some: { session_status: status },
+      };
+    }
+
+    const skip = (page - 1) * limit;
+
+    const [chats, total] = await Promise.all([
+      this.prisma.whatsappChat.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { chat_last_message_at: 'desc' },
+        include: {
+          patient: {
+            select: {
+              patient_id: true,
+              patient_first_name: true,
+              patient_last_name: true,
+              patient_display_name: true,
+              patient_phone: true,
+            },
+          },
+          clinic: {
+            select: {
+              clinic_id: true,
+              clinic_name: true,
+            },
+          },
+          assigned_to: {
+            select: { user_id: true, user_first_name: true, user_last_name: true },
+          },
+          phone: {
+            select: { phone_id: true, phone_number: true, phone_label: true },
+          },
+          sessions: {
+            where: { session_status: { not: 'resolved' } },
+            take: 1,
+            orderBy: { session_started_at: 'desc' },
+            select: {
+              session_id: true,
+              session_status: true,
+              session_taken_over_by_id: true,
+              session_awaiting_operator: true,
+            },
+          },
+        },
+      }),
+      this.prisma.whatsappChat.count({ where }),
+    ]);
+
+    return {
+      data: chats,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  ASSIGN / UNASSIGN                                                  */
+  /* ------------------------------------------------------------------ */
+
+  async assignChat(chatId: string, tenantId: string, assignToUserId: string, assignedByUserId: string) {
+    const chat = await this.prisma.whatsappChat.findFirst({
+      where: { chat_id: chatId, chat_tenant_id: tenantId, chat_deleted_at: null },
+    });
+
+    if (!chat) {
+      throw new NotFoundException('Chat not found');
+    }
+
+    await this.prisma.whatsappChat.update({
+      where: { chat_id: chatId },
+      data: {
+        chat_assigned_to_id: assignToUserId,
+        chat_assigned_by_id: assignedByUserId,
+        chat_assigned_at: new Date(),
+      },
+    });
+
+    this.events.emit('chat:assigned', {
+      tenantId,
+      chatId,
+      assignedToId: assignToUserId,
+      assignedById: assignedByUserId,
+    });
+  }
+
+  async unassignChat(chatId: string, tenantId: string) {
+    const chat = await this.prisma.whatsappChat.findFirst({
+      where: { chat_id: chatId, chat_tenant_id: tenantId, chat_deleted_at: null },
+    });
+
+    if (!chat) {
+      throw new NotFoundException('Chat not found');
+    }
+
+    await this.prisma.whatsappChat.update({
+      where: { chat_id: chatId },
+      data: {
+        chat_assigned_to_id: null,
+        chat_assigned_by_id: null,
+        chat_assigned_at: null,
+      },
+    });
+
+    this.events.emit('chat:unassigned', { tenantId, chatId });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CHAT DETAIL                                                        */
+  /* ------------------------------------------------------------------ */
+
+  async findChatById(chatId: string, tenantId: string) {
+    const chat = await this.prisma.whatsappChat.findFirst({
+      where: {
+        chat_id: chatId,
+        chat_tenant_id: tenantId,
+        chat_deleted_at: null,
+      },
+      include: {
+        patient: true,
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_name: true,
+            clinic_operator_phone: true,
+          },
+        },
+        sessions: {
+          orderBy: { session_started_at: 'desc' },
+          take: 5,
+          include: {
+            taken_over_by: {
+              select: {
+                user_id: true,
+                user_first_name: true,
+                user_last_name: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!chat) {
+      throw new NotFoundException('Chat not found');
+    }
+
+    return chat;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  MESSAGES (paginated, decrypted)                                    */
+  /* ------------------------------------------------------------------ */
+
+  async findMessages(
+    chatId: string,
+    tenantId: string,
+    page = 1,
+    limit = 50,
+  ) {
+    // Verify chat belongs to tenant
+    const chat = await this.prisma.whatsappChat.findFirst({
+      where: {
+        chat_id: chatId,
+        chat_tenant_id: tenantId,
+        chat_deleted_at: null,
+      },
+      select: { chat_id: true },
+    });
+
+    if (!chat) {
+      throw new NotFoundException('Chat not found');
+    }
+
+    const skip = (page - 1) * limit;
+
+    const [messages, total] = await Promise.all([
+      this.prisma.whatsappMessage.findMany({
+        where: { msg_chat_id: chatId },
+        skip,
+        take: limit,
+        orderBy: { msg_created_at: 'desc' },
+        include: {
+          sender_user: {
+            select: {
+              user_id: true,
+              user_first_name: true,
+              user_last_name: true,
+            },
+          },
+        },
+      }),
+      this.prisma.whatsappMessage.count({
+        where: { msg_chat_id: chatId },
+      }),
+    ]);
+
+    // Decrypt message text
+    const decrypted = messages.map((msg) => ({
+      ...msg,
+      msg_text: this.decryptMessageText(msg.msg_text),
+    }));
+
+    return {
+      data: decrypted,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  STATS                                                              */
+  /* ------------------------------------------------------------------ */
+
+  /* ------------------------------------------------------------------ */
+  /*  CONNECTION STATUS                                                  */
+  /* ------------------------------------------------------------------ */
+
+  async getConnectionStatus(tenantId: string, clinicIds?: string[]) {
+    const where: any = {
+      clinic: { clinic_tenant_id: tenantId },
+    };
+    if (clinicIds?.length) {
+      where.meta_clinic_id = { in: clinicIds };
+    }
+
+    const connections = await this.prisma.clinicMetaConnection.findMany({
+      where,
+      select: {
+        meta_id: true,
+        meta_type: true,
+        meta_is_active: true,
+        meta_label: true,
+        meta_display_phone: true,
+        meta_waba_id: true,
+        meta_phone_number_id: true,
+        meta_instagram_page_id: true,
+        meta_token_expires_at: true,
+        meta_connected_at: true,
+        clinic: {
+          select: { clinic_id: true, clinic_name: true },
+        },
+      },
+      orderBy: { meta_connected_at: 'desc' },
+    });
+
+    return connections.map((c) => ({
+      id: c.meta_id,
+      type: c.meta_type,
+      isActive: c.meta_is_active,
+      label: c.meta_label,
+      phone: c.meta_display_phone,
+      wabaId: c.meta_waba_id,
+      phoneNumberId: c.meta_phone_number_id,
+      instagramPageId: c.meta_instagram_page_id,
+      tokenExpiresAt: c.meta_token_expires_at,
+      connectedAt: c.meta_connected_at,
+      clinic: c.clinic,
+      tokenHealthy: c.meta_token_expires_at
+        ? new Date(c.meta_token_expires_at) > new Date()
+        : false,
+    }));
+  }
+
+  async deleteConnection(connectionId: string, tenantId: string) {
+    const conn = await this.prisma.clinicMetaConnection.findFirst({
+      where: { meta_id: connectionId, clinic: { clinic_tenant_id: tenantId } },
+    });
+    if (!conn) throw new NotFoundException('Connection not found');
+
+    await this.prisma.clinicMetaConnection.delete({
+      where: { meta_id: connectionId },
+    });
+
+    // If WhatsApp, also unmark the phone number
+    if (conn.meta_type === 'whatsapp' && conn.meta_display_phone) {
+      await this.prisma.phoneNumber.updateMany({
+        where: { phone_number: conn.meta_display_phone, phone_tenant_id: tenantId },
+        data: { phone_wa_connected: false },
+      });
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  MEDIA PROXY                                                        */
+  /* ------------------------------------------------------------------ */
+
+  async getMedia(
+    msgId: string,
+    tenantId: string,
+  ): Promise<{ buffer: Buffer; contentType: string } | null> {
+    const msg = await this.prisma.whatsappMessage.findFirst({
+      where: { msg_id: msgId, msg_tenant_id: tenantId },
+      select: {
+        msg_media_key: true,
+        msg_media_mime: true,
+        msg_media_type: true,
+        chat: {
+          select: { chat_clinic_id: true, chat_channel: true },
+        },
+      },
+    });
+
+    if (!msg?.msg_media_key) return null;
+
+    const contentType = msg.msg_media_mime || 'application/octet-stream';
+    const isDirectUrl = msg.msg_media_key.startsWith('http');
+
+    // Use a safe MinIO key (hash the URL for direct URLs, use media ID for WA)
+    const cacheKey = isDirectUrl
+      ? `chat-media/${tenantId}/${Buffer.from(msg.msg_media_key).toString('base64url').substring(0, 80)}`
+      : `chat-media/${tenantId}/${msg.msg_media_key}`;
+
+    // Check MinIO cache first
+    if (await this.minio.objectExists(cacheKey)) {
+      const buffer = await this.minio.getObject(cacheKey);
+      return { buffer, contentType };
+    }
+
+    try {
+      let buffer: Buffer;
+
+      if (isDirectUrl) {
+        // Instagram: direct CDN URL — fetch directly (no auth needed, URL has signature)
+        const res = await fetch(msg.msg_media_key);
+        if (!res.ok) throw new Error(`Direct media fetch failed: ${res.status}`);
+        buffer = Buffer.from(await res.arrayBuffer());
+      } else {
+        // WhatsApp: media ID — use Graph API download with access token
+        const metaConn = await this.prisma.clinicMetaConnection.findFirst({
+          where: {
+            meta_clinic_id: msg.chat.chat_clinic_id,
+            meta_type: 'whatsapp',
+            meta_is_active: true,
+          },
+          select: { meta_encrypted_access_token: true },
+        });
+
+        if (!metaConn?.meta_encrypted_access_token) return null;
+
+        const accessToken = this.tokenEncryptionKey
+          ? this.encryption.decrypt(metaConn.meta_encrypted_access_token, this.tokenEncryptionKey)
+          : metaConn.meta_encrypted_access_token;
+
+        buffer = await this.metaWhatsApp.downloadMedia(msg.msg_media_key, accessToken);
+      }
+
+      // Cache in MinIO (fire-and-forget)
+      this.minio.putObject(cacheKey, buffer, contentType).catch((err) =>
+        this.logger.warn(`Failed to cache media in MinIO: ${err.message}`),
+      );
+
+      return { buffer, contentType };
+    } catch (err: any) {
+      this.logger.warn(`Media download failed for ${msg.msg_media_key.substring(0, 80)}: ${err.message}`);
+      return null;
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  STATS                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async getStats(tenantId: string, clinicIds?: string[]) {
+    const chatWhere: any = {
+      chat_tenant_id: tenantId,
+      chat_deleted_at: null,
+    };
+    const sessionWhere: any = {
+      session_tenant_id: tenantId,
+      session_status: 'active',
+    };
+
+    if (clinicIds && clinicIds.length > 0) {
+      chatWhere.chat_clinic_id = { in: clinicIds };
+      sessionWhere.session_clinic_id = { in: clinicIds };
+    }
+
+    const todayStart = new Date();
+    todayStart.setHours(0, 0, 0, 0);
+
+    const [totalChats, activeSessions, messagesToday] = await Promise.all([
+      this.prisma.whatsappChat.count({ where: chatWhere }),
+      this.prisma.whatsappSession.count({ where: sessionWhere }),
+      this.prisma.whatsappMessage.count({
+        where: {
+          msg_tenant_id: tenantId,
+          msg_created_at: { gte: todayStart },
+          ...(clinicIds?.length
+            ? {
+                chat: {
+                  chat_clinic_id: { in: clinicIds },
+                },
+              }
+            : {}),
+        },
+      }),
+    ]);
+
+    return {
+      totalChats,
+      activeSessions,
+      messagesToday,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  BLACKLIST                                                          */
+  /* ------------------------------------------------------------------ */
+
+  async getBlacklist(clinicId: string) {
+    const clinic = await this.prisma.clinic.findUnique({
+      where: { clinic_id: clinicId },
+      select: {
+        clinic_id: true,
+        clinic_name: true,
+        clinic_blacklisted_numbers: true,
+      },
+    });
+
+    if (!clinic) {
+      throw new NotFoundException('Clinic not found');
+    }
+
+    return {
+      clinicId: clinic.clinic_id,
+      clinicName: clinic.clinic_name,
+      numbers: clinic.clinic_blacklisted_numbers,
+    };
+  }
+
+  async addToBlacklist(clinicId: string, tenantId: string, phone: string) {
+    const clinic = await this.prisma.clinic.findFirst({
+      where: { clinic_id: clinicId, clinic_tenant_id: tenantId },
+      select: { clinic_blacklisted_numbers: true },
+    });
+
+    if (!clinic) {
+      throw new NotFoundException('Clinic not found');
+    }
+
+    if (clinic.clinic_blacklisted_numbers.includes(phone)) {
+      throw new BadRequestException('Phone number already blacklisted');
+    }
+
+    return this.prisma.clinic.update({
+      where: { clinic_id: clinicId },
+      data: {
+        clinic_blacklisted_numbers: {
+          push: phone,
+        },
+      },
+      select: {
+        clinic_id: true,
+        clinic_blacklisted_numbers: true,
+      },
+    });
+  }
+
+  async removeFromBlacklist(
+    clinicId: string,
+    tenantId: string,
+    phone: string,
+  ) {
+    const clinic = await this.prisma.clinic.findFirst({
+      where: { clinic_id: clinicId, clinic_tenant_id: tenantId },
+      select: { clinic_blacklisted_numbers: true },
+    });
+
+    if (!clinic) {
+      throw new NotFoundException('Clinic not found');
+    }
+
+    const filtered = clinic.clinic_blacklisted_numbers.filter(
+      (n) => n !== phone,
+    );
+
+    return this.prisma.clinic.update({
+      where: { clinic_id: clinicId },
+      data: {
+        clinic_blacklisted_numbers: filtered,
+      },
+      select: {
+        clinic_id: true,
+        clinic_blacklisted_numbers: true,
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  HELPERS                                                            */
+  /* ------------------------------------------------------------------ */
+
+  private decryptMessageText(encryptedText: string): string {
+    if (!encryptedText) return '';
+    try {
+      return this.encryption.decrypt(
+        encryptedText,
+        this.messageEncryptionKey,
+      );
+    } catch {
+      // If decryption fails, return as-is (may be unencrypted legacy data)
+      return encryptedText;
+    }
+  }
+}

package/nestjs/test/app.e2e-spec.ts

@@ -0,0 +1,25 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { App } from 'supertest/types';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!');
+  });
+});

package/nestjs/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/nestjs/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/nestjs/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}

package/nginx.example.conf

@@ -0,0 +1,18 @@
+# Asistan724 - Host Nginx Reverse Proxy Configuration
+# Copy to /etc/nginx/sites-available/asistan724.conf
+# Then: ln -s /etc/nginx/sites-available/asistan724.conf /etc/nginx/sites-enabled/
+# After: certbot --nginx -d yourdomain.com
+# Test: nginx -t && systemctl reload nginx
+
+server {
+    listen 80;
+    server_name yourdomain.com;
+
+    location / {
+        proxy_pass http://127.0.0.1:3020;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}