elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/patients/photo-sets.service.ts

@@ -0,0 +1,389 @@
+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 { ImageService } from '../integrations/image/image.service';
+import { CreatePhotoSetDto, UpdatePhotoSetDto, UploadPhotoDto } from './dto';
+
+@Injectable()
+export class PhotoSetsService {
+  private readonly logger = new Logger(PhotoSetsService.name);
+  private readonly piiKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly minio: MinioService,
+    private readonly encryption: EncryptionService,
+    private readonly image: ImageService,
+    private readonly config: ConfigService,
+  ) {
+    this.piiKey = this.config.getOrThrow<string>('PATIENT_PII_ENCRYPTION_KEY');
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST                                                                */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(patientId: string, tenantId: string, treatmentPlanId?: string) {
+    const where: any = {
+      photoset_patient_id: patientId,
+      photoset_tenant_id: tenantId,
+    };
+
+    if (treatmentPlanId) {
+      where.photoset_treatment_plan_id = treatmentPlanId;
+    }
+
+    const sets = await this.prisma.patientPhotoSet.findMany({
+      where,
+      orderBy: { photoset_taken_at: 'desc' },
+      include: {
+        _count: { select: { photos: true } },
+        taken_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+      },
+    });
+
+    return sets.map((s) => this.formatPhotoSet(s));
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY ID (with signed URLs for all photos)                       */
+  /* ------------------------------------------------------------------ */
+
+  async findById(photosetId: string, tenantId: string) {
+    const set = await this.prisma.patientPhotoSet.findFirst({
+      where: {
+        photoset_id: photosetId,
+        photoset_tenant_id: tenantId,
+      },
+      include: {
+        photos: {
+          orderBy: { photo_sort_order: 'asc' },
+        },
+        taken_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+        _count: { select: { photos: true } },
+      },
+    });
+
+    if (!set) {
+      throw new NotFoundException('Photo set not found');
+    }
+
+    // Generate signed URLs for all photos
+    const photosWithUrls = await Promise.all(
+      set.photos.map(async (p) => ({
+        id: p.photo_id,
+        angle: p.photo_angle,
+        caption: p.photo_caption,
+        sortOrder: p.photo_sort_order,
+        url: await this.minio.presignedGetObject(p.photo_media_key),
+        thumbnailUrl: p.photo_thumbnail_key
+          ? await this.minio.presignedGetObject(p.photo_thumbnail_key)
+          : null,
+        createdAt: p.photo_created_at,
+      })),
+    );
+
+    return {
+      ...this.formatPhotoSet(set),
+      photos: photosWithUrls,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async create(
+    patientId: string,
+    tenantId: string,
+    clinicId: string,
+    userId: string,
+    dto: CreatePhotoSetDto,
+  ) {
+    const set = await this.prisma.patientPhotoSet.create({
+      data: {
+        photoset_patient_id: patientId,
+        photoset_tenant_id: tenantId,
+        photoset_clinic_id: clinicId,
+        photoset_taken_by: userId,
+        photoset_type: dto.type,
+        photoset_label: dto.label ?? '',
+        photoset_treatment_plan_id: dto.treatmentPlanId ?? null,
+        photoset_taken_at: dto.takenAt ? new Date(dto.takenAt) : new Date(),
+        photoset_notes: dto.notes
+          ? this.encryption.encrypt(dto.notes, this.piiKey)
+          : '',
+      },
+      include: {
+        _count: { select: { photos: true } },
+        taken_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+      },
+    });
+
+    this.logger.log(
+      `Photo set created: ${set.photoset_id} for patient ${patientId}`,
+    );
+
+    return this.formatPhotoSet(set);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async update(photosetId: string, tenantId: string, dto: UpdatePhotoSetDto) {
+    const set = await this.prisma.patientPhotoSet.findFirst({
+      where: { photoset_id: photosetId, photoset_tenant_id: tenantId },
+    });
+
+    if (!set) {
+      throw new NotFoundException('Photo set not found');
+    }
+
+    const data: any = {};
+    if (dto.type !== undefined) data.photoset_type = dto.type;
+    if (dto.label !== undefined) data.photoset_label = dto.label;
+    if (dto.takenAt !== undefined) data.photoset_taken_at = new Date(dto.takenAt);
+    if (dto.notes !== undefined) {
+      data.photoset_notes = dto.notes
+        ? this.encryption.encrypt(dto.notes, this.piiKey)
+        : '';
+    }
+
+    const updated = await this.prisma.patientPhotoSet.update({
+      where: { photoset_id: photosetId },
+      data,
+      include: {
+        _count: { select: { photos: true } },
+        taken_by_user: {
+          select: {
+            user_id: true,
+            user_first_name: true,
+            user_last_name: true,
+          },
+        },
+      },
+    });
+
+    return this.formatPhotoSet(updated);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE (set + all photos)                                          */
+  /* ------------------------------------------------------------------ */
+
+  async remove(photosetId: string, tenantId: string) {
+    const set = await this.prisma.patientPhotoSet.findFirst({
+      where: { photoset_id: photosetId, photoset_tenant_id: tenantId },
+      include: { photos: true },
+    });
+
+    if (!set) {
+      throw new NotFoundException('Photo set not found');
+    }
+
+    // Remove all photo files from MinIO
+    for (const photo of set.photos) {
+      await this.minio.removeObject(photo.photo_media_key).catch((err) => {
+        this.logger.warn(`Failed to remove photo: ${photo.photo_media_key}`, err);
+      });
+      if (photo.photo_thumbnail_key) {
+        await this.minio.removeObject(photo.photo_thumbnail_key).catch((err) => {
+          this.logger.warn(`Failed to remove thumbnail: ${photo.photo_thumbnail_key}`, err);
+        });
+      }
+    }
+
+    // Cascade delete handles photos in DB
+    await this.prisma.patientPhotoSet.delete({
+      where: { photoset_id: photosetId },
+    });
+
+    return { message: 'Photo set deleted' };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  ADD PHOTO                                                           */
+  /* ------------------------------------------------------------------ */
+
+  async addPhoto(photosetId: string, tenantId: string, dto: UploadPhotoDto) {
+    const set = await this.prisma.patientPhotoSet.findFirst({
+      where: { photoset_id: photosetId, photoset_tenant_id: tenantId },
+    });
+
+    if (!set) {
+      throw new NotFoundException('Photo set not found');
+    }
+
+    const buffer = Buffer.from(dto.content, 'base64');
+    const ext = this.extFromMime(dto.contentType);
+
+    // Get current max sort order
+    const maxOrder = await this.prisma.patientPhoto.aggregate({
+      where: { photo_set_id: photosetId },
+      _max: { photo_sort_order: true },
+    });
+    const nextOrder = (maxOrder._max.photo_sort_order ?? -1) + 1;
+
+    // Create DB record
+    const photo = await this.prisma.patientPhoto.create({
+      data: {
+        photo_set_id: photosetId,
+        photo_angle: dto.angle ?? '',
+        photo_media_key: '', // placeholder
+        photo_caption: dto.caption ?? '',
+        photo_sort_order: nextOrder,
+      },
+    });
+
+    const basePath = `${tenantId}/patients/${set.photoset_patient_id}/photos/${photosetId}`;
+    const mediaKey = `${basePath}/${photo.photo_id}${ext}`;
+    const thumbnailKey = `${basePath}/${photo.photo_id}_thumb.jpg`;
+
+    // Upload original to MinIO
+    await this.minio.putObject(mediaKey, buffer, dto.contentType);
+
+    // Generate and upload thumbnail
+    let savedThumbnailKey: string | null = null;
+    try {
+      const thumb = await this.image.generateThumbnail(buffer, {
+        width: 300,
+        height: 300,
+        quality: 80,
+      });
+      await this.minio.putObject(thumbnailKey, thumb.buffer, thumb.contentType);
+      savedThumbnailKey = thumbnailKey;
+    } catch (err) {
+      this.logger.warn(`Thumbnail generation failed for ${photo.photo_id}`, err);
+    }
+
+    // Update media key + thumbnail key
+    const updated = await this.prisma.patientPhoto.update({
+      where: { photo_id: photo.photo_id },
+      data: {
+        photo_media_key: mediaKey,
+        ...(savedThumbnailKey && { photo_thumbnail_key: savedThumbnailKey }),
+      },
+    });
+
+    const url = await this.minio.presignedGetObject(mediaKey);
+    const thumbnailUrl = savedThumbnailKey
+      ? await this.minio.presignedGetObject(savedThumbnailKey)
+      : null;
+
+    this.logger.log(
+      `Photo added: ${updated.photo_id} to set ${photosetId} (thumbnail: ${!!savedThumbnailKey})`,
+    );
+
+    return {
+      id: updated.photo_id,
+      angle: updated.photo_angle,
+      caption: updated.photo_caption,
+      sortOrder: updated.photo_sort_order,
+      url,
+      thumbnailUrl,
+      createdAt: updated.photo_created_at,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE PHOTO                                                        */
+  /* ------------------------------------------------------------------ */
+
+  async removePhoto(photoId: string, tenantId: string) {
+    const photo = await this.prisma.patientPhoto.findFirst({
+      where: { photo_id: photoId },
+      include: {
+        photo_set: {
+          select: { photoset_tenant_id: true },
+        },
+      },
+    });
+
+    if (!photo || photo.photo_set.photoset_tenant_id !== tenantId) {
+      throw new NotFoundException('Photo not found');
+    }
+
+    // Remove from MinIO
+    await this.minio.removeObject(photo.photo_media_key).catch((err) => {
+      this.logger.warn(`Failed to remove photo: ${photo.photo_media_key}`, err);
+    });
+    if (photo.photo_thumbnail_key) {
+      await this.minio.removeObject(photo.photo_thumbnail_key).catch((err) => {
+        this.logger.warn(`Failed to remove thumbnail: ${photo.photo_thumbnail_key}`, err);
+      });
+    }
+
+    await this.prisma.patientPhoto.delete({
+      where: { photo_id: photoId },
+    });
+
+    return { message: 'Photo deleted' };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PRIVATE HELPERS                                                     */
+  /* ------------------------------------------------------------------ */
+
+  private formatPhotoSet(set: any) {
+    let notes = '';
+    if (set.photoset_notes) {
+      try {
+        notes = this.encryption.decrypt(set.photoset_notes, this.piiKey);
+      } catch {
+        notes = '';
+      }
+    }
+
+    return {
+      id: set.photoset_id,
+      patientId: set.photoset_patient_id,
+      type: set.photoset_type,
+      label: set.photoset_label,
+      treatmentPlanId: set.photoset_treatment_plan_id,
+      takenAt: set.photoset_taken_at,
+      notes,
+      photoCount: set._count?.photos ?? 0,
+      takenBy: set.taken_by_user
+        ? {
+            id: set.taken_by_user.user_id,
+            firstName: set.taken_by_user.user_first_name,
+            lastName: set.taken_by_user.user_last_name,
+          }
+        : null,
+      createdAt: set.photoset_created_at,
+      updatedAt: set.photoset_updated_at,
+    };
+  }
+
+  private extFromMime(mime: string): string {
+    const map: Record<string, string> = {
+      'image/jpeg': '.jpg',
+      'image/png': '.png',
+      'image/webp': '.webp',
+      'image/heic': '.heic',
+      'image/heif': '.heif',
+    };
+    return map[mime] || '.jpg';
+  }
+}

package/nestjs/src/phone-numbers/dto/create-phone-number.dto.ts

@@ -0,0 +1,57 @@
+import {
+  IsString,
+  IsOptional,
+  IsEnum,
+  Matches,
+  MaxLength,
+} from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreatePhoneNumberDto {
+  @ApiProperty({ example: '+905551234567', description: 'E.164 format' })
+  @IsString()
+  @Matches(/^\+[1-9]\d{1,14}$/, { message: 'number must be in E.164 format' })
+  number: string;
+
+  @ApiPropertyOptional({ example: 'Main WhatsApp Line' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  label?: string;
+
+  @ApiProperty({ enum: ['whatsapp', 'inbound_call', 'outbound_call'] })
+  @IsEnum(['whatsapp', 'inbound_call', 'outbound_call'] as const)
+  purpose: 'whatsapp' | 'inbound_call' | 'outbound_call';
+
+  @ApiProperty({ enum: ['meta_business', 'elevenlabs'] })
+  @IsEnum(['meta_business', 'elevenlabs'] as const)
+  provider: 'meta_business' | 'elevenlabs';
+
+  @ApiPropertyOptional({ description: 'Clinic to link this phone to' })
+  @IsOptional()
+  @IsString()
+  clinicId?: string;
+
+  @ApiPropertyOptional({ description: 'Agent to link this phone to' })
+  @IsOptional()
+  @IsString()
+  agentId?: string;
+
+  @ApiPropertyOptional({ description: 'External provider account ID' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  externalAccountId?: string;
+
+  @ApiPropertyOptional({ description: 'ElevenLabs phone number ID' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  elevenlabsPhoneId?: string;
+
+  @ApiPropertyOptional({ description: 'ElevenLabs agent ID' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  elevenlabsAgentId?: string;
+}

package/nestjs/src/phone-numbers/dto/index.ts

@@ -0,0 +1,3 @@
+export { CreatePhoneNumberDto } from './create-phone-number.dto';
+export { UpdatePhoneNumberDto } from './update-phone-number.dto';
+export { UpdateScheduleDto } from './update-schedule.dto';

package/nestjs/src/phone-numbers/dto/update-phone-number.dto.ts

@@ -0,0 +1,38 @@
+import { IsString, IsOptional, IsBoolean, IsArray, MaxLength } from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdatePhoneNumberDto {
+  @ApiPropertyOptional({ example: 'Reception Line' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  label?: string;
+
+  @ApiPropertyOptional({ description: 'Clinic ID to link' })
+  @IsOptional()
+  @IsString()
+  clinicId?: string | null;
+
+  @ApiPropertyOptional({ description: 'Agent ID to link' })
+  @IsOptional()
+  @IsString()
+  agentId?: string | null;
+
+  @ApiPropertyOptional({ example: false })
+  @IsOptional()
+  @IsBoolean()
+  scheduleEnabled?: boolean;
+
+  @ApiPropertyOptional({
+    example: [{ day: 1, start: '09:00', end: '18:00' }],
+    description: 'Array of schedule entries { day, start, end }',
+  })
+  @IsOptional()
+  @IsArray()
+  schedule?: any[];
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

package/nestjs/src/phone-numbers/dto/update-schedule.dto.ts

@@ -0,0 +1,39 @@
+import { IsBoolean, IsArray, IsString, IsOptional, IsIn, ValidateNested } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+
+class ScheduleEntry {
+  @ApiProperty({ example: 1, description: 'Day of week (0=Sun, 6=Sat)' })
+  day: number;
+
+  @ApiProperty({ example: '09:00' })
+  start: string;
+
+  @ApiProperty({ example: '18:00' })
+  end: string;
+}
+
+export class UpdateScheduleDto {
+  @ApiProperty({ example: true })
+  @IsBoolean()
+  scheduleEnabled: boolean;
+
+  @ApiPropertyOptional({
+    example: 'active_hours',
+    enum: ['active_hours', 'off_hours'],
+    description: 'active_hours = AI works only during schedule, off_hours = AI works 24/7 except during schedule',
+  })
+  @IsOptional()
+  @IsString()
+  @IsIn(['active_hours', 'off_hours'])
+  scheduleMode?: string;
+
+  @ApiProperty({
+    type: [ScheduleEntry],
+    example: [{ day: 1, start: '09:00', end: '18:00' }],
+  })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => ScheduleEntry)
+  schedule: ScheduleEntry[];
+}

package/nestjs/src/phone-numbers/phone-numbers.controller.ts

@@ -0,0 +1,125 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Param,
+  Body,
+  Query,
+  UseGuards,
+  BadRequestException,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
+import { PhoneNumbersService } from './phone-numbers.service';
+import {
+  CreatePhoneNumberDto,
+  UpdatePhoneNumberDto,
+  UpdateScheduleDto,
+} from './dto';
+import { JwtAuthGuard, PermissionsGuard } from '../common/guards';
+import { CurrentUser, Permissions } from '../common/decorators';
+import type { JwtPayload } from '../common/interfaces/jwt-payload.interface';
+
+@ApiTags('Phone Numbers')
+@Controller('phone-numbers')
+@UseGuards(JwtAuthGuard, PermissionsGuard)
+@ApiBearerAuth()
+export class PhoneNumbersController {
+  constructor(private readonly phoneNumbersService: PhoneNumbersService) {}
+
+  @Get()
+  @Permissions('phone_numbers:read')
+  @ApiOperation({ summary: 'List phone numbers (filterable)' })
+  @ApiQuery({ name: 'purpose', required: false, enum: ['whatsapp', 'inbound_call', 'outbound_call'] })
+  @ApiQuery({ name: 'clinicId', required: false })
+  @ApiQuery({ name: 'provider', required: false, enum: ['meta_business', 'elevenlabs'] })
+  async findAll(
+    @CurrentUser() user: JwtPayload,
+    @Query('purpose') purpose?: string,
+    @Query('clinicId') clinicId?: string,
+    @Query('provider') provider?: string,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.phoneNumbersService.findAll(user.tenantId, {
+      purpose,
+      clinicId,
+      provider,
+    });
+  }
+
+  @Get(':id')
+  @Permissions('phone_numbers:read')
+  @ApiOperation({ summary: 'Get a single phone number by ID' })
+  async findById(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.phoneNumbersService.findById(id, user.tenantId);
+  }
+
+  @Post()
+  @Permissions('phone_numbers:manage')
+  @ApiOperation({ summary: 'Create a phone number' })
+  async create(
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: CreatePhoneNumberDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.phoneNumbersService.create(user.tenantId, dto);
+  }
+
+  @Put(':id')
+  @Permissions('phone_numbers:manage')
+  @ApiOperation({ summary: 'Update a phone number' })
+  async update(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: UpdatePhoneNumberDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.phoneNumbersService.update(id, user.tenantId, dto);
+  }
+
+  @Put(':id/schedule')
+  @Permissions('phone_numbers:manage')
+  @ApiOperation({ summary: 'Update inbound call schedule for a phone number' })
+  async updateSchedule(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: UpdateScheduleDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.phoneNumbersService.updateSchedule(id, user.tenantId, dto);
+  }
+
+  @Delete(':id')
+  @Permissions('phone_numbers:manage')
+  @ApiOperation({ summary: 'Delete a phone number' })
+  async remove(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.phoneNumbersService.remove(id, user.tenantId);
+  }
+}

package/nestjs/src/phone-numbers/phone-numbers.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { PhoneNumbersController } from './phone-numbers.controller';
+import { PhoneNumbersService } from './phone-numbers.service';
+
+@Module({
+  controllers: [PhoneNumbersController],
+  providers: [PhoneNumbersService],
+  exports: [PhoneNumbersService],
+})
+export class PhoneNumbersModule {}