elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/clinics/clinics.controller.ts

@@ -0,0 +1,226 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Param,
+  Body,
+  UseGuards,
+  BadRequestException,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { ClinicsService } from './clinics.service';
+import { MetaConnectionsService } from './meta-connections.service';
+import {
+  CreateClinicDto,
+  UpdateClinicDto,
+  CreateMetaConnectionDto,
+  UpdateMetaConnectionDto,
+} from './dto';
+import {
+  JwtAuthGuard,
+  PermissionsGuard,
+  ClinicAccessGuard,
+} from '../common/guards';
+import {
+  CurrentUser,
+  Permissions,
+  AccessibleClinics,
+} from '../common/decorators';
+import type { JwtPayload } from '../common/interfaces/jwt-payload.interface';
+
+@ApiTags('Clinics')
+@Controller('clinics')
+@UseGuards(JwtAuthGuard, PermissionsGuard, ClinicAccessGuard)
+@ApiBearerAuth()
+export class ClinicsController {
+  constructor(
+    private readonly clinicsService: ClinicsService,
+    private readonly metaConnectionsService: MetaConnectionsService,
+  ) {}
+
+  @Get()
+  @Permissions('clinics:read')
+  @ApiOperation({ summary: 'List clinics (scoped by user access)' })
+  async findAll(
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    // clinicIds is empty for owner/superadmin (means all clinics)
+    return this.clinicsService.findAll(
+      user.tenantId,
+      clinicIds.length > 0 ? clinicIds : undefined,
+    );
+  }
+
+  @Get(':id')
+  @Permissions('clinics:read')
+  @ApiOperation({ summary: 'Get a single clinic by ID' })
+  async findById(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    // Verify access for non-owner/superadmin users
+    if (clinicIds.length > 0 && !clinicIds.includes(id)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+
+    return this.clinicsService.findById(id, user.tenantId);
+  }
+
+  @Post()
+  @Permissions('clinics:create')
+  @ApiOperation({ summary: 'Create a new clinic' })
+  async create(
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: CreateClinicDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    return this.clinicsService.create(user.tenantId, dto);
+  }
+
+  @Put(':id')
+  @Permissions('clinics:update')
+  @ApiOperation({ summary: 'Update a clinic' })
+  async update(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+    @Body() dto: UpdateClinicDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    if (clinicIds.length > 0 && !clinicIds.includes(id)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+
+    return this.clinicsService.update(id, user.tenantId, dto);
+  }
+
+  @Delete(':id')
+  @Permissions('clinics:delete')
+  @ApiOperation({ summary: 'Soft-delete a clinic (set inactive)' })
+  async remove(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    if (clinicIds.length > 0 && !clinicIds.includes(id)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+
+    return this.clinicsService.remove(id, user.tenantId);
+  }
+
+  /* ================================================================== */
+  /*  META CONNECTIONS                                                   */
+  /* ================================================================== */
+
+  @Get(':id/meta-connections')
+  @Permissions('chats:config')
+  @ApiOperation({ summary: 'List Meta connections for a clinic' })
+  async listMetaConnections(
+    @Param('id') clinicId: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    if (clinicIds.length > 0 && !clinicIds.includes(clinicId)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+    return this.metaConnectionsService.findAll(clinicId, user.tenantId);
+  }
+
+  @Post(':id/meta-connections')
+  @Permissions('chats:config')
+  @ApiOperation({ summary: 'Create a Meta connection for a clinic' })
+  async createMetaConnection(
+    @Param('id') clinicId: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+    @Body() dto: CreateMetaConnectionDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    if (clinicIds.length > 0 && !clinicIds.includes(clinicId)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+    return this.metaConnectionsService.create(clinicId, user.tenantId, dto);
+  }
+
+  @Get(':id/meta-connections/:connId')
+  @Permissions('chats:config')
+  @ApiOperation({ summary: 'Get a single Meta connection' })
+  async getMetaConnection(
+    @Param('id') clinicId: string,
+    @Param('connId') connId: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    if (clinicIds.length > 0 && !clinicIds.includes(clinicId)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+    return this.metaConnectionsService.findById(connId, user.tenantId);
+  }
+
+  @Put(':id/meta-connections/:connId')
+  @Permissions('chats:config')
+  @ApiOperation({ summary: 'Update a Meta connection' })
+  async updateMetaConnection(
+    @Param('id') clinicId: string,
+    @Param('connId') connId: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+    @Body() dto: UpdateMetaConnectionDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    if (clinicIds.length > 0 && !clinicIds.includes(clinicId)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+    return this.metaConnectionsService.update(connId, user.tenantId, dto);
+  }
+
+  @Delete(':id/meta-connections/:connId')
+  @Permissions('chats:config')
+  @ApiOperation({ summary: 'Delete (disconnect) a Meta connection' })
+  async deleteMetaConnection(
+    @Param('id') clinicId: string,
+    @Param('connId') connId: string,
+    @CurrentUser() user: JwtPayload,
+    @AccessibleClinics() clinicIds: string[],
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    if (clinicIds.length > 0 && !clinicIds.includes(clinicId)) {
+      throw new BadRequestException('No access to this clinic');
+    }
+    return this.metaConnectionsService.disconnect(connId, user.tenantId);
+  }
+}

package/nestjs/src/clinics/clinics.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ClinicsController } from './clinics.controller';
+import { ClinicsService } from './clinics.service';
+import { MetaConnectionsService } from './meta-connections.service';
+
+@Module({
+  controllers: [ClinicsController],
+  providers: [ClinicsService, MetaConnectionsService],
+  exports: [ClinicsService, MetaConnectionsService],
+})
+export class ClinicsModule {}

package/nestjs/src/clinics/clinics.service.ts

@@ -0,0 +1,203 @@
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { CreateClinicDto, UpdateClinicDto } from './dto';
+
+@Injectable()
+export class ClinicsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST                                                               */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(tenantId: string, clinicIds?: string[]) {
+    const where: any = { clinic_tenant_id: tenantId };
+
+    // If clinicIds provided (non-empty), scope to those clinics
+    if (clinicIds && clinicIds.length > 0) {
+      where.clinic_id = { in: clinicIds };
+    }
+
+    return this.prisma.clinic.findMany({
+      where,
+      orderBy: [
+        { clinic_is_default: 'desc' },
+        { clinic_created_at: 'asc' },
+      ],
+      include: {
+        _count: {
+          select: {
+            patients: true,
+            appointments: true,
+          },
+        },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SINGLE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async findById(clinicId: string, tenantId: string) {
+    const clinic = await this.prisma.clinic.findFirst({
+      where: {
+        clinic_id: clinicId,
+        clinic_tenant_id: tenantId,
+      },
+      include: {
+        calendar_connection: true,
+        meta_connections: true,
+        _count: {
+          select: {
+            patients: true,
+            appointments: true,
+          },
+        },
+      },
+    });
+
+    if (!clinic) {
+      throw new NotFoundException('Clinic not found');
+    }
+
+    return clinic;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async create(tenantId: string, dto: CreateClinicDto) {
+    const slug = dto.slug ?? this.generateSlug(dto.name);
+
+    // Check slug uniqueness within tenant
+    const existing = await this.prisma.clinic.findUnique({
+      where: {
+        clinic_tenant_id_clinic_slug: {
+          clinic_tenant_id: tenantId,
+          clinic_slug: slug,
+        },
+      },
+    });
+
+    if (existing) {
+      throw new BadRequestException(
+        `A clinic with slug "${slug}" already exists in this tenant`,
+      );
+    }
+
+    return this.prisma.clinic.create({
+      data: {
+        clinic_tenant_id: tenantId,
+        clinic_name: dto.name,
+        clinic_slug: slug,
+        ...(dto.address !== undefined && { clinic_address: dto.address }),
+        ...(dto.phone !== undefined && { clinic_phone: dto.phone }),
+        ...(dto.email !== undefined && { clinic_email: dto.email }),
+        ...(dto.timezone !== undefined && { clinic_timezone: dto.timezone }),
+      },
+      include: {
+        _count: {
+          select: {
+            patients: true,
+            appointments: true,
+          },
+        },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async update(clinicId: string, tenantId: string, dto: UpdateClinicDto) {
+    // Verify clinic exists and belongs to tenant
+    await this.findById(clinicId, tenantId);
+
+    const data = this.mapDtoToPrisma(dto);
+
+    if (Object.keys(data).length === 0) {
+      throw new BadRequestException('No fields to update');
+    }
+
+    return this.prisma.clinic.update({
+      where: { clinic_id: clinicId },
+      data,
+      include: {
+        calendar_connection: true,
+        meta_connections: true,
+        _count: {
+          select: {
+            patients: true,
+            appointments: true,
+          },
+        },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE (soft delete)                                               */
+  /* ------------------------------------------------------------------ */
+
+  async remove(clinicId: string, tenantId: string) {
+    const clinic = await this.findById(clinicId, tenantId);
+
+    if (clinic.clinic_is_default) {
+      throw new BadRequestException('Cannot delete the default clinic');
+    }
+
+    return this.prisma.clinic.update({
+      where: { clinic_id: clinicId },
+      data: { clinic_is_active: false },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  HELPERS                                                            */
+  /* ------------------------------------------------------------------ */
+
+  private generateSlug(name: string): string {
+    return name
+      .toLowerCase()
+      .trim()
+      .replace(/\s+/g, '-')
+      .replace(/[^a-z0-9\-]/g, '')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+
+  private mapDtoToPrisma(dto: UpdateClinicDto): Record<string, any> {
+    const map: Record<string, any> = {};
+
+    if (dto.name !== undefined) map.clinic_name = dto.name;
+    if (dto.address !== undefined) map.clinic_address = dto.address;
+    if (dto.phone !== undefined) map.clinic_phone = dto.phone;
+    if (dto.email !== undefined) map.clinic_email = dto.email;
+    if (dto.timezone !== undefined) map.clinic_timezone = dto.timezone;
+    if (dto.language !== undefined) map.clinic_language = dto.language;
+    if (dto.aiProvider !== undefined) map.clinic_ai_provider = dto.aiProvider;
+    if (dto.aiModel !== undefined) map.clinic_ai_model = dto.aiModel;
+    if (dto.gracePeriodSeconds !== undefined) map.clinic_grace_period_seconds = dto.gracePeriodSeconds;
+    if (dto.operatorPhone !== undefined) map.clinic_operator_phone = dto.operatorPhone;
+    if (dto.operatorPrefix !== undefined) map.clinic_operator_prefix = dto.operatorPrefix;
+    if (dto.operatorTimeoutHours !== undefined) map.clinic_operator_timeout_hours = dto.operatorTimeoutHours;
+    if (dto.aiShiftEnabled !== undefined) map.clinic_ai_shift_enabled = dto.aiShiftEnabled;
+    if (dto.aiShiftSchedule !== undefined) map.clinic_ai_shift_schedule = dto.aiShiftSchedule;
+    if (dto.blacklistedNumbers !== undefined) map.clinic_blacklisted_numbers = dto.blacklistedNumbers;
+    if (dto.fixedFirstMessage !== undefined) map.clinic_fixed_first_message = dto.fixedFirstMessage;
+    if (dto.smsEnabled !== undefined) map.clinic_sms_enabled = dto.smsEnabled;
+    if (dto.smsPhones !== undefined) map.clinic_sms_phones = dto.smsPhones;
+    if (dto.notificationPhones !== undefined) map.clinic_notification_phones = dto.notificationPhones;
+    if (dto.messageRetentionDays !== undefined) map.clinic_message_retention_days = dto.messageRetentionDays;
+    if (dto.isActive !== undefined) map.clinic_is_active = dto.isActive;
+
+    return map;
+  }
+}

package/nestjs/src/clinics/dto/create-clinic.dto.ts

@@ -0,0 +1,40 @@
+import { IsString, IsOptional, MinLength, MaxLength } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreateClinicDto {
+  @ApiProperty({ example: 'Kadikoy Branch' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  name: string;
+
+  @ApiPropertyOptional({ example: 'kadikoy-branch' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  slug?: string;
+
+  @ApiPropertyOptional({ example: 'Kadikoy, Istanbul' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(500)
+  address?: string;
+
+  @ApiPropertyOptional({ example: '+905551234567' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  phone?: string;
+
+  @ApiPropertyOptional({ example: 'kadikoy@clinic.com' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  email?: string;
+
+  @ApiPropertyOptional({ example: 'Europe/Istanbul', default: 'Europe/Istanbul' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  timezone?: string;
+}

package/nestjs/src/clinics/dto/create-meta-connection.dto.ts

@@ -0,0 +1,44 @@
+import { IsString, IsOptional, IsIn, MinLength, MaxLength } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreateMetaConnectionDto {
+  @ApiProperty({ example: 'whatsapp', enum: ['whatsapp', 'instagram'] })
+  @IsString()
+  @IsIn(['whatsapp', 'instagram'])
+  type: 'whatsapp' | 'instagram';
+
+  @ApiProperty({ example: 'Main WhatsApp Line' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  label: string;
+
+  @ApiPropertyOptional({ example: '123456789', description: 'WhatsApp Business Account ID (whatsapp only)' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  wabaId?: string;
+
+  @ApiPropertyOptional({ example: '987654321', description: 'Phone number ID from Meta (whatsapp only)' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  phoneNumberId?: string;
+
+  @ApiPropertyOptional({ example: '+905551234567', description: 'Display phone number (whatsapp only)' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  displayPhone?: string;
+
+  @ApiPropertyOptional({ example: '111222333', description: 'Instagram page ID (instagram only)' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  instagramPageId?: string;
+
+  @ApiProperty({ description: 'Meta access token (will be encrypted at rest)' })
+  @IsString()
+  @MinLength(1)
+  accessToken: string;
+}

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

@@ -0,0 +1,4 @@
+export { CreateClinicDto } from './create-clinic.dto';
+export { UpdateClinicDto } from './update-clinic.dto';
+export { CreateMetaConnectionDto } from './create-meta-connection.dto';
+export { UpdateMetaConnectionDto } from './update-meta-connection.dto';

package/nestjs/src/clinics/dto/update-clinic.dto.ts

@@ -0,0 +1,133 @@
+import {
+  IsString,
+  IsOptional,
+  IsBoolean,
+  IsInt,
+  IsArray,
+  MaxLength,
+  Min,
+} from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdateClinicDto {
+  @ApiPropertyOptional({ example: 'Kadikoy Branch' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  name?: string;
+
+  @ApiPropertyOptional({ example: 'Kadikoy, Istanbul' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(500)
+  address?: string;
+
+  @ApiPropertyOptional({ example: '+905551234567' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  phone?: string;
+
+  @ApiPropertyOptional({ example: 'kadikoy@clinic.com' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  email?: string;
+
+  @ApiPropertyOptional({ example: 'Europe/Istanbul' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  timezone?: string;
+
+  @ApiPropertyOptional({ example: 'tr' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(10)
+  language?: string;
+
+  @ApiPropertyOptional({ example: 'openai' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  aiProvider?: string;
+
+  @ApiPropertyOptional({ example: 'gpt-4o' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  aiModel?: string;
+
+  @ApiPropertyOptional({ example: 180 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  gracePeriodSeconds?: number;
+
+  @ApiPropertyOptional({ example: '+905551234567' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  operatorPhone?: string | null;
+
+  @ApiPropertyOptional({ example: 'R' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(10)
+  operatorPrefix?: string;
+
+  @ApiPropertyOptional({ example: 24 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  operatorTimeoutHours?: number;
+
+  @ApiPropertyOptional({ example: false })
+  @IsOptional()
+  @IsBoolean()
+  aiShiftEnabled?: boolean;
+
+  @ApiPropertyOptional({ example: [{ day: 1, start: '09:00', end: '18:00' }] })
+  @IsOptional()
+  @IsArray()
+  aiShiftSchedule?: any[];
+
+  @ApiPropertyOptional({ example: ['+905551234567'] })
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  blacklistedNumbers?: string[];
+
+  @ApiPropertyOptional({ example: 'Welcome to our clinic!' })
+  @IsOptional()
+  @IsString()
+  fixedFirstMessage?: string | null;
+
+  @ApiPropertyOptional({ example: false })
+  @IsOptional()
+  @IsBoolean()
+  smsEnabled?: boolean;
+
+  @ApiPropertyOptional({ example: ['+905551234567'] })
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  smsPhones?: string[];
+
+  @ApiPropertyOptional({ example: ['+905551234567'] })
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  notificationPhones?: string[];
+
+  @ApiPropertyOptional({ example: 7 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  messageRetentionDays?: number;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

package/nestjs/src/clinics/dto/update-meta-connection.dto.ts

@@ -0,0 +1,22 @@
+import { IsString, IsOptional, IsBoolean, MinLength, MaxLength } from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdateMetaConnectionDto {
+  @ApiPropertyOptional({ example: 'Updated Label' })
+  @IsOptional()
+  @IsString()
+  @MinLength(1)
+  @MaxLength(255)
+  label?: string;
+
+  @ApiPropertyOptional({ description: 'New access token (will be re-encrypted)' })
+  @IsOptional()
+  @IsString()
+  @MinLength(1)
+  accessToken?: string;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}