elevenlabs-webhook-nodejs 1.0.0

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

@@ -0,0 +1,209 @@
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { CreatePhoneNumberDto, UpdatePhoneNumberDto, UpdateScheduleDto } from './dto';
+
+@Injectable()
+export class PhoneNumbersService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST                                                               */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(
+    tenantId: string,
+    filters?: { purpose?: string; clinicId?: string; provider?: string },
+  ) {
+    const where: any = { phone_tenant_id: tenantId };
+
+    if (filters?.purpose) {
+      where.phone_purpose = filters.purpose;
+    }
+    if (filters?.clinicId) {
+      where.phone_clinic_id = filters.clinicId;
+    }
+    if (filters?.provider) {
+      where.phone_provider = filters.provider;
+    }
+
+    return this.prisma.phoneNumber.findMany({
+      where,
+      orderBy: { phone_created_at: 'desc' },
+      include: {
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        agent: { select: { agent_id: true, agent_name: true } },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SINGLE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async findById(phoneId: string, tenantId: string) {
+    const phone = await this.prisma.phoneNumber.findFirst({
+      where: {
+        phone_id: phoneId,
+        phone_tenant_id: tenantId,
+      },
+      include: {
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        agent: { select: { agent_id: true, agent_name: true } },
+      },
+    });
+
+    if (!phone) {
+      throw new NotFoundException('Phone number not found');
+    }
+
+    return phone;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY EXTERNAL ID (webhook routing)                              */
+  /* ------------------------------------------------------------------ */
+
+  async findByExternalId(provider: string, externalAccountId: string) {
+    return this.prisma.phoneNumber.findFirst({
+      where: {
+        phone_provider: provider as any,
+        phone_external_account_id: externalAccountId,
+      },
+      include: {
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        agent: { select: { agent_id: true, agent_name: true } },
+        tenant: { select: { tenant_id: true, tenant_name: true } },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async create(tenantId: string, dto: CreatePhoneNumberDto) {
+    // Check uniqueness: same number + purpose within tenant
+    const existing = await this.prisma.phoneNumber.findUnique({
+      where: {
+        phone_tenant_id_phone_number_phone_purpose: {
+          phone_tenant_id: tenantId,
+          phone_number: dto.number,
+          phone_purpose: dto.purpose as any,
+        },
+      },
+    });
+
+    if (existing) {
+      throw new BadRequestException(
+        `Phone number ${dto.number} already exists for purpose "${dto.purpose}" in this tenant`,
+      );
+    }
+
+    return this.prisma.phoneNumber.create({
+      data: {
+        phone_tenant_id: tenantId,
+        phone_number: dto.number,
+        phone_purpose: dto.purpose as any,
+        phone_provider: dto.provider as any,
+        ...(dto.label !== undefined && { phone_label: dto.label }),
+        ...(dto.clinicId !== undefined && { phone_clinic_id: dto.clinicId }),
+        ...(dto.agentId !== undefined && { phone_agent_id: dto.agentId }),
+        ...(dto.externalAccountId !== undefined && {
+          phone_external_account_id: dto.externalAccountId,
+        }),
+        ...(dto.elevenlabsPhoneId !== undefined && {
+          phone_elevenlabs_phone_id: dto.elevenlabsPhoneId,
+        }),
+        ...(dto.elevenlabsAgentId !== undefined && {
+          phone_elevenlabs_agent_id: dto.elevenlabsAgentId,
+        }),
+      },
+      include: {
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        agent: { select: { agent_id: true, agent_name: true } },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async update(phoneId: string, tenantId: string, dto: UpdatePhoneNumberDto) {
+    await this.findById(phoneId, tenantId);
+
+    const data = this.mapUpdateDto(dto);
+
+    if (Object.keys(data).length === 0) {
+      throw new BadRequestException('No fields to update');
+    }
+
+    return this.prisma.phoneNumber.update({
+      where: { phone_id: phoneId },
+      data,
+      include: {
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        agent: { select: { agent_id: true, agent_name: true } },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE SCHEDULE                                                    */
+  /* ------------------------------------------------------------------ */
+
+  async updateSchedule(
+    phoneId: string,
+    tenantId: string,
+    dto: UpdateScheduleDto,
+  ) {
+    await this.findById(phoneId, tenantId);
+
+    return this.prisma.phoneNumber.update({
+      where: { phone_id: phoneId },
+      data: {
+        phone_schedule_enabled: dto.scheduleEnabled,
+        ...(dto.scheduleMode && { phone_schedule_mode: dto.scheduleMode }),
+        phone_schedule: dto.schedule as any,
+      },
+      include: {
+        clinic: { select: { clinic_id: true, clinic_name: true } },
+        agent: { select: { agent_id: true, agent_name: true } },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async remove(phoneId: string, tenantId: string) {
+    await this.findById(phoneId, tenantId);
+
+    return this.prisma.phoneNumber.delete({
+      where: { phone_id: phoneId },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  HELPERS                                                            */
+  /* ------------------------------------------------------------------ */
+
+  private mapUpdateDto(dto: UpdatePhoneNumberDto): Record<string, any> {
+    const map: Record<string, any> = {};
+
+    if (dto.label !== undefined) map.phone_label = dto.label;
+    if (dto.clinicId !== undefined) map.phone_clinic_id = dto.clinicId;
+    if (dto.agentId !== undefined) map.phone_agent_id = dto.agentId;
+    if (dto.scheduleEnabled !== undefined)
+      map.phone_schedule_enabled = dto.scheduleEnabled;
+    if (dto.schedule !== undefined) map.phone_schedule = dto.schedule;
+    if (dto.isActive !== undefined) map.phone_is_active = dto.isActive;
+
+    return map;
+  }
+}

package/nestjs/src/plans/dto/create-plan.dto.ts

@@ -0,0 +1,70 @@
+import {
+  IsString,
+  IsNumber,
+  IsInt,
+  IsOptional,
+  MinLength,
+  MaxLength,
+  Min,
+} from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreatePlanDto {
+  @ApiProperty({ example: 'Starter' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  name: string;
+
+  @ApiProperty({ example: 'starter' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  slug: string;
+
+  @ApiProperty({ example: 499.99 })
+  @IsNumber()
+  @Min(0)
+  price: number;
+
+  @ApiProperty({ example: 0.05, description: 'Per-unit overage rate' })
+  @IsNumber()
+  @Min(0)
+  overageRate: number;
+
+  @ApiPropertyOptional({ example: 500, default: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedInboundMinutes?: number;
+
+  @ApiPropertyOptional({ example: 200, default: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedInboundCalls?: number;
+
+  @ApiPropertyOptional({ example: 100, default: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedOutboundMinutes?: number;
+
+  @ApiPropertyOptional({ example: 50, default: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedOutboundCalls?: number;
+
+  @ApiPropertyOptional({ example: 1000, default: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedWaChats?: number;
+
+  @ApiPropertyOptional({ example: 1, default: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+}

package/nestjs/src/plans/dto/index.ts

@@ -0,0 +1,2 @@
+export { CreatePlanDto } from './create-plan.dto';
+export { UpdatePlanDto } from './update-plan.dto';

package/nestjs/src/plans/dto/update-plan.dto.ts

@@ -0,0 +1,80 @@
+import {
+  IsString,
+  IsNumber,
+  IsInt,
+  IsBoolean,
+  IsOptional,
+  MinLength,
+  MaxLength,
+  Min,
+} from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdatePlanDto {
+  @ApiPropertyOptional({ example: 'Starter' })
+  @IsOptional()
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  name?: string;
+
+  @ApiPropertyOptional({ example: 'starter' })
+  @IsOptional()
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  slug?: string;
+
+  @ApiPropertyOptional({ example: 499.99 })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  price?: number;
+
+  @ApiPropertyOptional({ example: 0.05 })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  overageRate?: number;
+
+  @ApiPropertyOptional({ example: 500 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedInboundMinutes?: number;
+
+  @ApiPropertyOptional({ example: 200 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedInboundCalls?: number;
+
+  @ApiPropertyOptional({ example: 100 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedOutboundMinutes?: number;
+
+  @ApiPropertyOptional({ example: 50 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedOutboundCalls?: number;
+
+  @ApiPropertyOptional({ example: 1000 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  includedWaChats?: number;
+
+  @ApiPropertyOptional({ example: 1 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

package/nestjs/src/plans/plans.controller.ts

@@ -0,0 +1,50 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Param,
+  Body,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { PlansService } from './plans.service';
+import { CreatePlanDto, UpdatePlanDto } from './dto';
+import { JwtAuthGuard, PermissionsGuard } from '../common/guards';
+import { Permissions } from '../common/decorators';
+
+@ApiTags('Plans')
+@Controller('plans')
+@UseGuards(JwtAuthGuard)
+@ApiBearerAuth()
+export class PlansController {
+  constructor(private readonly plansService: PlansService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List all active plans' })
+  async findAll() {
+    return this.plansService.findAll();
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a single plan by ID' })
+  async findById(@Param('id') id: string) {
+    return this.plansService.findById(id);
+  }
+
+  @Post()
+  @UseGuards(PermissionsGuard)
+  @Permissions('platform:plans.manage')
+  @ApiOperation({ summary: 'Create a new plan (superadmin only)' })
+  async create(@Body() dto: CreatePlanDto) {
+    return this.plansService.create(dto);
+  }
+
+  @Put(':id')
+  @UseGuards(PermissionsGuard)
+  @Permissions('platform:plans.manage')
+  @ApiOperation({ summary: 'Update a plan (superadmin only)' })
+  async update(@Param('id') id: string, @Body() dto: UpdatePlanDto) {
+    return this.plansService.update(id, dto);
+  }
+}

package/nestjs/src/plans/plans.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { PlansController } from './plans.controller';
+import { PlansService } from './plans.service';
+
+@Module({
+  controllers: [PlansController],
+  providers: [PlansService],
+  exports: [PlansService],
+})
+export class PlansModule {}

package/nestjs/src/plans/plans.service.ts

@@ -0,0 +1,115 @@
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { CreatePlanDto, UpdatePlanDto } from './dto';
+
+@Injectable()
+export class PlansService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST                                                               */
+  /* ------------------------------------------------------------------ */
+
+  async findAll() {
+    return this.prisma.plan.findMany({
+      where: { plan_is_active: true },
+      orderBy: { plan_sort_order: 'asc' },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SINGLE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async findById(planId: string) {
+    const plan = await this.prisma.plan.findUnique({
+      where: { plan_id: planId },
+    });
+
+    if (!plan) {
+      throw new NotFoundException('Plan not found');
+    }
+
+    return plan;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async create(dto: CreatePlanDto) {
+    // Check slug uniqueness
+    const existing = await this.prisma.plan.findUnique({
+      where: { plan_slug: dto.slug },
+    });
+
+    if (existing) {
+      throw new BadRequestException(
+        `A plan with slug "${dto.slug}" already exists`,
+      );
+    }
+
+    return this.prisma.plan.create({
+      data: {
+        plan_name: dto.name,
+        plan_slug: dto.slug,
+        plan_price: dto.price,
+        plan_overage_rate: dto.overageRate,
+        plan_included_inbound_minutes: dto.includedInboundMinutes ?? 0,
+        plan_included_inbound_calls: dto.includedInboundCalls ?? 0,
+        plan_included_outbound_minutes: dto.includedOutboundMinutes ?? 0,
+        plan_included_outbound_calls: dto.includedOutboundCalls ?? 0,
+        plan_included_wa_chats: dto.includedWaChats ?? 0,
+        plan_sort_order: dto.sortOrder ?? 0,
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async update(planId: string, dto: UpdatePlanDto) {
+    await this.findById(planId);
+
+    // If slug is being changed, check uniqueness
+    if (dto.slug !== undefined) {
+      const existing = await this.prisma.plan.findUnique({
+        where: { plan_slug: dto.slug },
+      });
+
+      if (existing && existing.plan_id !== planId) {
+        throw new BadRequestException(
+          `A plan with slug "${dto.slug}" already exists`,
+        );
+      }
+    }
+
+    const data: Record<string, any> = {};
+
+    if (dto.name !== undefined) data.plan_name = dto.name;
+    if (dto.slug !== undefined) data.plan_slug = dto.slug;
+    if (dto.price !== undefined) data.plan_price = dto.price;
+    if (dto.overageRate !== undefined) data.plan_overage_rate = dto.overageRate;
+    if (dto.includedInboundMinutes !== undefined) data.plan_included_inbound_minutes = dto.includedInboundMinutes;
+    if (dto.includedInboundCalls !== undefined) data.plan_included_inbound_calls = dto.includedInboundCalls;
+    if (dto.includedOutboundMinutes !== undefined) data.plan_included_outbound_minutes = dto.includedOutboundMinutes;
+    if (dto.includedOutboundCalls !== undefined) data.plan_included_outbound_calls = dto.includedOutboundCalls;
+    if (dto.includedWaChats !== undefined) data.plan_included_wa_chats = dto.includedWaChats;
+    if (dto.sortOrder !== undefined) data.plan_sort_order = dto.sortOrder;
+    if (dto.isActive !== undefined) data.plan_is_active = dto.isActive;
+
+    if (Object.keys(data).length === 0) {
+      throw new BadRequestException('No fields to update');
+    }
+
+    return this.prisma.plan.update({
+      where: { plan_id: planId },
+      data,
+    });
+  }
+}

package/nestjs/src/platform/dto/create-tenant.dto.ts

@@ -0,0 +1,36 @@
+import { IsString, IsEmail, MinLength, MaxLength, IsOptional } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreateTenantDto {
+  @ApiProperty({ example: 'Bright Smile Dental' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  tenantName: string;
+
+  @ApiProperty({ example: 'John' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(100)
+  ownerFirstName: string;
+
+  @ApiProperty({ example: 'Doe' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(100)
+  ownerLastName: string;
+
+  @ApiProperty({ example: 'owner@clinic.com' })
+  @IsEmail()
+  ownerEmail: string;
+
+  @ApiProperty({ example: 'securePassword123' })
+  @IsString()
+  @MinLength(6)
+  ownerPassword: string;
+
+  @ApiPropertyOptional({ example: 'uuid-of-plan' })
+  @IsOptional()
+  @IsString()
+  planId?: string;
+}

package/nestjs/src/platform/dto/index.ts

@@ -0,0 +1,2 @@
+export { CreateTenantDto } from './create-tenant.dto';
+export { UpdateTenantPlatformDto } from './update-tenant-platform.dto';

package/nestjs/src/platform/dto/update-tenant-platform.dto.ts

@@ -0,0 +1,44 @@
+import { IsString, IsBoolean, IsOptional, IsArray, IsInt, Min } from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdateTenantPlatformDto {
+  @ApiPropertyOptional({ example: 'uuid-of-plan' })
+  @IsOptional()
+  @IsString()
+  planId?: string;
+
+  @ApiPropertyOptional({ example: ['whatsapp', 'voice_calls'] })
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  enabledFeatures?: string[];
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+
+  @ApiPropertyOptional({ example: 3 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  maxClinics?: number;
+
+  @ApiPropertyOptional({ example: 10 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  maxUsers?: number;
+
+  @ApiPropertyOptional({ example: 5 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  maxDoctors?: number;
+
+  @ApiPropertyOptional({ example: 1000 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  maxPatients?: number;
+}