elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/outbound-campaigns/processors/campaign-dispatch.processor.ts

@@ -0,0 +1,366 @@
+import { Processor, WorkerHost, InjectQueue } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import type { Job, Queue } from 'bullmq';
+import { PrismaService } from '../../database/prisma.service.js';
+import { ElevenLabsService } from '../../integrations/elevenlabs/elevenlabs.service.js';
+
+/** Default delay (ms) before re-enqueueing when concurrency is full. */
+const CONCURRENCY_DELAY_MS = 30_000;
+
+/** Default retry delay (ms) between attempts for a failed entry. */
+const DEFAULT_RETRY_DELAY_MS = 60_000;
+
+/**
+ * Processes individual outbound campaign calls.
+ *
+ * Each job targets one campaign entry. After processing, the processor
+ * self-feeds by enqueueing the next pending entry, creating a continuous
+ * dispatch loop.
+ */
+@Processor('outbound-campaigns-dispatch')
+export class CampaignDispatchProcessor extends WorkerHost {
+  private readonly logger = new Logger(CampaignDispatchProcessor.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly elevenlabs: ElevenLabsService,
+    @InjectQueue('outbound-campaigns-dispatch')
+    private readonly dispatchQueue: Queue,
+  ) {
+    super();
+  }
+
+  async process(
+    job: Job<{ campaignId: string; entryId?: string }>,
+  ): Promise<void> {
+    const { campaignId, entryId } = job.data;
+
+    this.logger.debug(
+      `Processing campaign dispatch (campaign=${campaignId}, entry=${entryId ?? 'next'})`,
+    );
+
+    try {
+      // 1. Load campaign and verify status
+      const campaign = await this.prisma.outboundCampaign.findUnique({
+        where: { campaign_id: campaignId },
+        include: {
+          agent: {
+            select: {
+              agent_id: true,
+              agent_elevenlabs_id: true,
+            },
+          },
+          phone: {
+            select: {
+              phone_id: true,
+              phone_elevenlabs_phone_id: true,
+              phone_number: true,
+            },
+          },
+        },
+      });
+
+      if (!campaign) {
+        this.logger.warn(`Campaign ${campaignId} not found, dropping job`);
+        return;
+      }
+
+      if (
+        campaign.campaign_status !== 'scheduled' &&
+        campaign.campaign_status !== 'running'
+      ) {
+        this.logger.debug(
+          `Campaign ${campaignId} is ${campaign.campaign_status}, skipping dispatch`,
+        );
+        return;
+      }
+
+      // 2. If scheduled, transition to running
+      if (campaign.campaign_status === 'scheduled') {
+        await this.prisma.outboundCampaign.update({
+          where: { campaign_id: campaignId },
+          data: { campaign_status: 'running' },
+        });
+        this.logger.log(`Campaign ${campaignId} transitioned to running`);
+      }
+
+      // 3. Check time window
+      const schedule = campaign.campaign_schedule as any;
+      if (schedule && !this.isWithinTimeWindow(schedule)) {
+        const delayMs = this.msToNextWindow(schedule);
+        this.logger.debug(
+          `Campaign ${campaignId} outside time window, re-enqueueing with ${Math.round(delayMs / 1000)}s delay`,
+        );
+        await this.dispatchQueue.add(
+          'dispatch',
+          { campaignId },
+          { delay: delayMs },
+        );
+        return;
+      }
+
+      // 4. Find the target entry
+      let entry;
+      if (entryId) {
+        entry = await this.prisma.outboundCampaignEntry.findUnique({
+          where: { centry_id: entryId },
+        });
+      }
+
+      if (!entry) {
+        // Find next pending entry
+        entry = await this.prisma.outboundCampaignEntry.findFirst({
+          where: {
+            centry_campaign_id: campaignId,
+            centry_status: 'pending',
+          },
+          orderBy: { centry_created_at: 'asc' },
+        });
+      }
+
+      if (!entry) {
+        // No more pending entries — check if campaign is complete
+        const pendingCount = await this.prisma.outboundCampaignEntry.count({
+          where: {
+            centry_campaign_id: campaignId,
+            centry_status: { in: ['pending', 'calling'] },
+          },
+        });
+
+        if (pendingCount === 0) {
+          await this.prisma.outboundCampaign.update({
+            where: { campaign_id: campaignId },
+            data: { campaign_status: 'completed' },
+          });
+          this.logger.log(
+            `Campaign ${campaignId} completed (all entries processed)`,
+          );
+        }
+        return;
+      }
+
+      // Verify entry is still eligible
+      if (
+        entry.centry_status !== 'pending' ||
+        entry.centry_attempts >= entry.centry_max_attempts
+      ) {
+        // Skip this entry and try the next one
+        await this.enqueueNext(campaignId);
+        return;
+      }
+
+      // 5. Check concurrency
+      const maxConcurrent = (schedule?.max_concurrent as number) ?? 5;
+      const callingCount = await this.prisma.outboundCampaignEntry.count({
+        where: {
+          centry_campaign_id: campaignId,
+          centry_status: 'calling',
+        },
+      });
+
+      if (callingCount >= maxConcurrent) {
+        this.logger.debug(
+          `Campaign ${campaignId} at max concurrency (${callingCount}/${maxConcurrent}), re-enqueueing with 30s delay`,
+        );
+        await this.dispatchQueue.add(
+          'dispatch',
+          { campaignId, entryId: entry.centry_id },
+          { delay: CONCURRENCY_DELAY_MS },
+        );
+        return;
+      }
+
+      // 6. Set entry status to calling and increment attempts
+      await this.prisma.outboundCampaignEntry.update({
+        where: { centry_id: entry.centry_id },
+        data: {
+          centry_status: 'calling',
+          centry_attempts: { increment: 1 },
+          centry_last_attempt_at: new Date(),
+          centry_called_at: entry.centry_called_at ?? new Date(),
+        },
+      });
+
+      // 7. Initiate outbound call
+      try {
+        const elAgentId = campaign.agent?.agent_elevenlabs_id;
+        const elPhoneId = campaign.phone?.phone_elevenlabs_phone_id;
+
+        if (!elAgentId || !elPhoneId) {
+          throw new Error(
+            `Missing ElevenLabs agent ID or phone number ID for campaign ${campaignId}`,
+          );
+        }
+
+        // Build dynamic variables from entry custom data
+        const customData = (entry.centry_custom_data as Record<string, string>) ?? {};
+        const dynamicVariables: Record<string, string> = {
+          contact_name: entry.centry_contact_name,
+          contact_phone: entry.centry_phone,
+          ...customData,
+        };
+
+        const result = await this.elevenlabs.sipTrunkOutboundCall({
+          agent_id: elAgentId,
+          agent_phone_number_id: elPhoneId,
+          to_phone_number: entry.centry_phone,
+          dynamic_variables: dynamicVariables,
+        });
+
+        // 8. Store conversation_id on the entry
+        const conversationId =
+          result?.conversation_id ?? result?.call_id ?? null;
+
+        await this.prisma.outboundCampaignEntry.update({
+          where: { centry_id: entry.centry_id },
+          data: {
+            ...(conversationId && { centry_conversation_id: conversationId }),
+          },
+        });
+
+        this.logger.log(
+          `Campaign ${campaignId} entry ${entry.centry_id} call initiated (conversation=${conversationId})`,
+        );
+      } catch (callError) {
+        // 9. On failure: set status to failed or re-queue for retry
+        const attempts = entry.centry_attempts + 1; // We already incremented
+        const maxAttempts = entry.centry_max_attempts;
+
+        if (attempts < maxAttempts) {
+          // Re-enqueue for retry
+          const retryDelay =
+            (schedule?.retry_delay_ms as number) ?? DEFAULT_RETRY_DELAY_MS;
+
+          await this.prisma.outboundCampaignEntry.update({
+            where: { centry_id: entry.centry_id },
+            data: { centry_status: 'pending' },
+          });
+
+          await this.dispatchQueue.add(
+            'dispatch',
+            { campaignId, entryId: entry.centry_id },
+            { delay: retryDelay },
+          );
+
+          this.logger.warn(
+            `Campaign ${campaignId} entry ${entry.centry_id} call failed (attempt ${attempts}/${maxAttempts}), retrying in ${retryDelay}ms: ${(callError as Error).message}`,
+          );
+        } else {
+          await this.prisma.outboundCampaignEntry.update({
+            where: { centry_id: entry.centry_id },
+            data: { centry_status: 'failed' },
+          });
+
+          this.logger.error(
+            `Campaign ${campaignId} entry ${entry.centry_id} permanently failed after ${attempts} attempts: ${(callError as Error).message}`,
+          );
+        }
+      }
+
+      // 10. Self-feeding: enqueue next pending entry
+      await this.enqueueNext(campaignId);
+    } catch (error) {
+      this.logger.error(
+        `Campaign dispatch failed (campaign=${campaignId}, entry=${entryId}): ${(error as Error).message}`,
+        (error as Error).stack,
+      );
+      throw error;
+    }
+  }
+
+  /** Enqueue the next pending entry for this campaign (self-feeding loop). */
+  private async enqueueNext(campaignId: string): Promise<void> {
+    const nextEntry = await this.prisma.outboundCampaignEntry.findFirst({
+      where: {
+        centry_campaign_id: campaignId,
+        centry_status: 'pending',
+      },
+      select: { centry_id: true },
+      orderBy: { centry_created_at: 'asc' },
+    });
+
+    if (nextEntry) {
+      await this.dispatchQueue.add(
+        'dispatch',
+        { campaignId, entryId: nextEntry.centry_id },
+        { delay: 1000 }, // Small delay to avoid hammering
+      );
+    }
+  }
+
+  /**
+   * Check if the current time falls within the campaign's scheduled time window.
+   * Schedule format: { daily_start_time: "09:00", daily_end_time: "18:00", days_of_week: [1,2,3,4,5] }
+   */
+  private isWithinTimeWindow(schedule: any): boolean {
+    if (!schedule?.daily_start_time || !schedule?.daily_end_time) {
+      return true; // No window configured means always allowed
+    }
+
+    const now = new Date();
+    const currentDay = now.getDay(); // 0=Sun, 1=Mon, ...
+    const currentMinutes = now.getHours() * 60 + now.getMinutes();
+
+    // Check day of week
+    const allowedDays = schedule.days_of_week as number[] | undefined;
+    if (allowedDays && Array.isArray(allowedDays) && !allowedDays.includes(currentDay)) {
+      return false;
+    }
+
+    // Check time range
+    const [startH, startM] = (schedule.daily_start_time as string)
+      .split(':')
+      .map(Number);
+    const [endH, endM] = (schedule.daily_end_time as string)
+      .split(':')
+      .map(Number);
+    const startMinutes = startH * 60 + startM;
+    const endMinutes = endH * 60 + endM;
+
+    return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+  }
+
+  /**
+   * Calculate milliseconds until the next allowed time window opens.
+   */
+  private msToNextWindow(schedule: any): number {
+    if (!schedule?.daily_start_time) {
+      return 60_000; // 1 minute fallback
+    }
+
+    const now = new Date();
+    const [startH, startM] = (schedule.daily_start_time as string)
+      .split(':')
+      .map(Number);
+
+    // Try today first
+    const todayStart = new Date(now);
+    todayStart.setHours(startH, startM, 0, 0);
+
+    if (todayStart.getTime() > now.getTime()) {
+      // Window opens later today — check if today is an allowed day
+      const allowedDays = schedule.days_of_week as number[] | undefined;
+      if (!allowedDays || allowedDays.includes(now.getDay())) {
+        return todayStart.getTime() - now.getTime();
+      }
+    }
+
+    // Find the next allowed day
+    const allowedDays = (schedule.days_of_week as number[] | undefined) ?? [
+      0, 1, 2, 3, 4, 5, 6,
+    ];
+
+    for (let daysAhead = 1; daysAhead <= 7; daysAhead++) {
+      const nextDate = new Date(now);
+      nextDate.setDate(nextDate.getDate() + daysAhead);
+      nextDate.setHours(startH, startM, 0, 0);
+
+      if (allowedDays.includes(nextDate.getDay())) {
+        return nextDate.getTime() - now.getTime();
+      }
+    }
+
+    // Fallback: 24 hours
+    return 24 * 60 * 60 * 1000;
+  }
+}

package/nestjs/src/patients/documents.service.ts

@@ -0,0 +1,231 @@
+import { Injectable, NotFoundException, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '../database/prisma.service';
+import { MinioService } from '../integrations/minio/minio.service';
+import { EncryptionService } from '../integrations/encryption/encryption.service';
+import { UploadDocumentDto } from './dto';
+import * as path from 'path';
+
+@Injectable()
+export class DocumentsService {
+  private readonly logger = new Logger(DocumentsService.name);
+  private readonly piiKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly minio: MinioService,
+    private readonly encryption: EncryptionService,
+    private readonly config: ConfigService,
+  ) {
+    this.piiKey = this.config.getOrThrow<string>('PATIENT_PII_ENCRYPTION_KEY');
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST                                                                */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(patientId: string, tenantId: string) {
+    const docs = await this.prisma.patientDocument.findMany({
+      where: {
+        doc_patient_id: patientId,
+        doc_tenant_id: tenantId,
+      },
+      orderBy: { doc_created_at: 'desc' },
+      include: {
+        uploaded_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+      },
+    });
+
+    return docs.map((d) => this.formatDocument(d));
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY ID (with signed URL)                                       */
+  /* ------------------------------------------------------------------ */
+
+  async findById(docId: string, tenantId: string) {
+    const doc = await this.prisma.patientDocument.findFirst({
+      where: {
+        doc_id: docId,
+        doc_tenant_id: tenantId,
+      },
+      include: {
+        uploaded_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+      },
+    });
+
+    if (!doc) {
+      throw new NotFoundException('Document not found');
+    }
+
+    const url = await this.minio.presignedGetObject(doc.doc_media_key);
+
+    return {
+      ...this.formatDocument(doc),
+      url,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPLOAD                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async upload(
+    patientId: string,
+    tenantId: string,
+    clinicId: string,
+    userId: string,
+    dto: UploadDocumentDto,
+  ) {
+    const buffer = Buffer.from(dto.content, 'base64');
+    const ext = path.extname(dto.name) || this.extFromMime(dto.contentType);
+
+    // Create DB record first to get the ID
+    const doc = await this.prisma.patientDocument.create({
+      data: {
+        doc_patient_id: patientId,
+        doc_tenant_id: tenantId,
+        doc_clinic_id: clinicId,
+        doc_uploaded_by: userId,
+        doc_type: dto.type,
+        doc_name: dto.name,
+        doc_media_key: '', // placeholder, will update
+        doc_content_type: dto.contentType,
+        doc_size_bytes: buffer.length,
+        doc_notes: dto.notes
+          ? this.encryption.encrypt(dto.notes, this.piiKey)
+          : '',
+      },
+    });
+
+    const mediaKey = `${tenantId}/patients/${patientId}/documents/${doc.doc_id}${ext}`;
+
+    // Upload to MinIO
+    await this.minio.putObject(mediaKey, buffer, dto.contentType);
+
+    // Update the media key
+    const updated = await this.prisma.patientDocument.update({
+      where: { doc_id: doc.doc_id },
+      data: { doc_media_key: mediaKey },
+      include: {
+        uploaded_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+      },
+    });
+
+    this.logger.log(
+      `Document uploaded: ${updated.doc_id} for patient ${patientId}`,
+    );
+
+    return this.formatDocument(updated);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  GET FILE BUFFER (for streaming proxy)                               */
+  /* ------------------------------------------------------------------ */
+
+  async getFileBuffer(docId: string, tenantId: string): Promise<Buffer> {
+    const doc = await this.prisma.patientDocument.findFirst({
+      where: { doc_id: docId, doc_tenant_id: tenantId },
+    });
+
+    if (!doc || !doc.doc_media_key) {
+      throw new NotFoundException('Document not found');
+    }
+
+    return this.minio.getObject(doc.doc_media_key);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async remove(docId: string, tenantId: string) {
+    const doc = await this.prisma.patientDocument.findFirst({
+      where: { doc_id: docId, doc_tenant_id: tenantId },
+    });
+
+    if (!doc) {
+      throw new NotFoundException('Document not found');
+    }
+
+    // Remove from MinIO
+    if (doc.doc_media_key) {
+      await this.minio.removeObject(doc.doc_media_key).catch((err) => {
+        this.logger.warn(
+          `Failed to remove object from MinIO: ${doc.doc_media_key}`,
+          err,
+        );
+      });
+    }
+
+    await this.prisma.patientDocument.delete({
+      where: { doc_id: docId },
+    });
+
+    return { message: 'Document deleted' };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PRIVATE HELPERS                                                     */
+  /* ------------------------------------------------------------------ */
+
+  private formatDocument(doc: any) {
+    let notes = '';
+    if (doc.doc_notes) {
+      try {
+        notes = this.encryption.decrypt(doc.doc_notes, this.piiKey);
+      } catch {
+        notes = '';
+      }
+    }
+
+    return {
+      id: doc.doc_id,
+      patientId: doc.doc_patient_id,
+      type: doc.doc_type,
+      name: doc.doc_name,
+      contentType: doc.doc_content_type,
+      sizeBytes: doc.doc_size_bytes,
+      notes,
+      uploadedBy: doc.uploaded_by_user
+        ? {
+            id: doc.uploaded_by_user.user_id,
+            firstName: doc.uploaded_by_user.user_first_name,
+            lastName: doc.uploaded_by_user.user_last_name,
+          }
+        : null,
+      createdAt: doc.doc_created_at,
+    };
+  }
+
+  private extFromMime(mime: string): string {
+    const map: Record<string, string> = {
+      'image/jpeg': '.jpg',
+      'image/png': '.png',
+      'image/webp': '.webp',
+      'application/pdf': '.pdf',
+      'application/msword': '.doc',
+      'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+        '.docx',
+    };
+    return map[mime] || '.bin';
+  }
+}

package/nestjs/src/patients/dto/create-examination.dto.ts

@@ -0,0 +1,34 @@
+import { IsString, IsOptional } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreateExaminationDto {
+  @ApiPropertyOptional({ description: 'Appointment ID to link this examination to' })
+  @IsOptional()
+  @IsString()
+  appointmentId?: string;
+
+  @ApiPropertyOptional({ example: 'No visible caries, mild gingivitis' })
+  @IsOptional()
+  @IsString()
+  findings?: string;
+
+  @ApiPropertyOptional({ example: 'Gingivitis, Class I malocclusion' })
+  @IsOptional()
+  @IsString()
+  diagnosis?: string;
+
+  @ApiPropertyOptional({ example: 'Scaling and root planing performed' })
+  @IsOptional()
+  @IsString()
+  procedureNotes?: string;
+
+  @ApiPropertyOptional({ example: 'Amoxicillin 500mg TID x7 days' })
+  @IsOptional()
+  @IsString()
+  prescription?: string;
+
+  @ApiPropertyOptional({ example: 'Avoid hot food for 24h, use prescribed mouthwash' })
+  @IsOptional()
+  @IsString()
+  instructions?: string;
+}

package/nestjs/src/patients/dto/create-note.dto.ts

@@ -0,0 +1,14 @@
+import { IsString, IsOptional, IsBoolean, MinLength } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreateNoteDto {
+  @ApiProperty({ example: 'Patient mentioned sensitivity to cold' })
+  @IsString()
+  @MinLength(1)
+  text: string;
+
+  @ApiPropertyOptional({ example: false, default: false })
+  @IsOptional()
+  @IsBoolean()
+  isPinned?: boolean;
+}