elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/platform/platform.controller.ts

@@ -0,0 +1,79 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Param,
+  Body,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
+import { PlatformService } from './platform.service';
+import { CreateTenantDto, UpdateTenantPlatformDto } from './dto';
+import { JwtAuthGuard, PermissionsGuard } from '../common/guards';
+import { Permissions } from '../common/decorators';
+
+@ApiTags('Platform')
+@Controller('platform')
+@UseGuards(JwtAuthGuard, PermissionsGuard)
+@ApiBearerAuth()
+export class PlatformController {
+  constructor(private readonly platformService: PlatformService) {}
+
+  @Get('tenants')
+  @Permissions('platform:tenants.list')
+  @ApiOperation({ summary: 'List all tenants (paginated)' })
+  @ApiQuery({ name: 'q', required: false, description: 'Search by tenant name' })
+  @ApiQuery({ name: 'page', required: false, type: Number })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  async listTenants(
+    @Query('q') query?: string,
+    @Query('page') page?: string,
+    @Query('limit') limit?: string,
+  ) {
+    return this.platformService.listTenants(
+      query,
+      page ? parseInt(page, 10) : 1,
+      limit ? parseInt(limit, 10) : 25,
+    );
+  }
+
+  @Post('tenants')
+  @Permissions('platform:tenants.create')
+  @ApiOperation({ summary: 'Create a new tenant with owner account' })
+  async createTenant(@Body() dto: CreateTenantDto) {
+    return this.platformService.createTenant(dto);
+  }
+
+  @Get('tenants/:id')
+  @Permissions('platform:tenants.read')
+  @ApiOperation({ summary: 'Get tenant overview' })
+  async getTenant(@Param('id') id: string) {
+    return this.platformService.getTenant(id);
+  }
+
+  @Put('tenants/:id')
+  @Permissions('platform:tenants.update')
+  @ApiOperation({ summary: 'Update tenant plan, features, or status' })
+  async updateTenant(
+    @Param('id') id: string,
+    @Body() dto: UpdateTenantPlatformDto,
+  ) {
+    return this.platformService.updateTenant(id, dto);
+  }
+
+  @Put('tenants/:id/deactivate')
+  @Permissions('platform:tenants.update')
+  @ApiOperation({ summary: 'Deactivate a tenant' })
+  async deactivateTenant(@Param('id') id: string) {
+    return this.platformService.deactivateTenant(id);
+  }
+
+  @Put('tenants/:id/reactivate')
+  @Permissions('platform:tenants.update')
+  @ApiOperation({ summary: 'Reactivate a tenant' })
+  async reactivateTenant(@Param('id') id: string) {
+    return this.platformService.reactivateTenant(id);
+  }
+}

package/nestjs/src/platform/platform.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { PlatformController } from './platform.controller';
+import { PlatformService } from './platform.service';
+
+@Module({
+  controllers: [PlatformController],
+  providers: [PlatformService],
+  exports: [PlatformService],
+})
+export class PlatformModule {}

package/nestjs/src/platform/platform.service.ts

@@ -0,0 +1,301 @@
+import {
+  Injectable,
+  NotFoundException,
+  ConflictException,
+  Logger,
+} from '@nestjs/common';
+import * as bcrypt from 'bcrypt';
+import { PrismaService } from '../database/prisma.service';
+import { CreateTenantDto, UpdateTenantPlatformDto } from './dto';
+
+const BCRYPT_ROUNDS = 12;
+
+@Injectable()
+export class PlatformService {
+  private readonly logger = new Logger(PlatformService.name);
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST TENANTS (paginated)                                           */
+  /* ------------------------------------------------------------------ */
+
+  async listTenants(query?: string, page = 1, limit = 25) {
+    const where: any = {};
+
+    if (query && query.trim()) {
+      where.tenant_name = { contains: query.trim(), mode: 'insensitive' };
+    }
+
+    const skip = (page - 1) * limit;
+
+    const [tenants, total] = await Promise.all([
+      this.prisma.tenant.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { tenant_created_at: 'desc' },
+        include: {
+          plan: true,
+          _count: {
+            select: {
+              clinics: true,
+              users: true,
+            },
+          },
+        },
+      }),
+      this.prisma.tenant.count({ where }),
+    ]);
+
+    return {
+      data: tenants.map((t) => ({
+        id: t.tenant_id,
+        name: t.tenant_name,
+        isActive: t.tenant_is_active,
+        enabledFeatures: t.tenant_enabled_features,
+        plan: t.plan
+          ? { id: t.plan.plan_id, name: t.plan.plan_name }
+          : null,
+        limits: {
+          maxClinics: t.tenant_max_clinics,
+          maxUsers: t.tenant_max_users,
+          maxDoctors: t.tenant_max_doctors,
+          maxPatients: t.tenant_max_patients,
+        },
+        clinicCount: t._count.clinics,
+        userCount: t._count.users,
+        createdAt: t.tenant_created_at,
+        updatedAt: t.tenant_updated_at,
+      })),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  GET TENANT                                                         */
+  /* ------------------------------------------------------------------ */
+
+  async getTenant(tenantId: string) {
+    const tenant = await this.prisma.tenant.findUnique({
+      where: { tenant_id: tenantId },
+      include: {
+        plan: true,
+        _count: {
+          select: {
+            clinics: true,
+            users: true,
+          },
+        },
+      },
+    });
+
+    if (!tenant) {
+      throw new NotFoundException('Tenant not found');
+    }
+
+    return {
+      id: tenant.tenant_id,
+      name: tenant.tenant_name,
+      isActive: tenant.tenant_is_active,
+      enabledFeatures: tenant.tenant_enabled_features,
+      kvkkConsent: tenant.tenant_kvkk_consent,
+      plan: tenant.plan
+        ? { id: tenant.plan.plan_id, name: tenant.plan.plan_name }
+        : null,
+      limits: {
+        maxClinics: tenant.tenant_max_clinics,
+        maxUsers: tenant.tenant_max_users,
+        maxDoctors: tenant.tenant_max_doctors,
+        maxPatients: tenant.tenant_max_patients,
+      },
+      clinicCount: tenant._count.clinics,
+      userCount: tenant._count.users,
+      createdAt: tenant.tenant_created_at,
+      updatedAt: tenant.tenant_updated_at,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE TENANT                                                      */
+  /* ------------------------------------------------------------------ */
+
+  async createTenant(dto: CreateTenantDto) {
+    // Check for duplicate email
+    const existing = await this.prisma.user.findUnique({
+      where: { user_email: dto.ownerEmail },
+    });
+    if (existing) {
+      throw new ConflictException('Email already registered');
+    }
+
+    // Validate plan if provided
+    if (dto.planId) {
+      const plan = await this.prisma.plan.findUnique({
+        where: { plan_id: dto.planId },
+      });
+      if (!plan) {
+        throw new NotFoundException('Plan not found');
+      }
+    }
+
+    const passwordHash = await bcrypt.hash(dto.ownerPassword, BCRYPT_ROUNDS);
+    const clinicSlug = this.slugify(dto.tenantName);
+
+    const result = await this.prisma.$transaction(async (tx) => {
+      const tenant = await tx.tenant.create({
+        data: {
+          tenant_name: dto.tenantName,
+          tenant_plan_id: dto.planId ?? null,
+          tenant_enabled_features: [],
+        },
+      });
+
+      const clinic = await tx.clinic.create({
+        data: {
+          clinic_tenant_id: tenant.tenant_id,
+          clinic_name: dto.tenantName,
+          clinic_slug: clinicSlug,
+          clinic_is_default: true,
+        },
+      });
+
+      const user = await tx.user.create({
+        data: {
+          user_tenant_id: tenant.tenant_id,
+          user_email: dto.ownerEmail,
+          user_password_hash: passwordHash,
+          user_role: 'owner',
+          user_first_name: dto.ownerFirstName,
+          user_last_name: dto.ownerLastName,
+        },
+      });
+
+      return { tenant, clinic, user };
+    });
+
+    this.logger.log(
+      `Tenant "${result.tenant.tenant_name}" created by platform (id=${result.tenant.tenant_id})`,
+    );
+
+    return {
+      tenant: {
+        id: result.tenant.tenant_id,
+        name: result.tenant.tenant_name,
+      },
+      clinic: {
+        id: result.clinic.clinic_id,
+        name: result.clinic.clinic_name,
+      },
+      owner: {
+        id: result.user.user_id,
+        email: result.user.user_email,
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE TENANT                                                      */
+  /* ------------------------------------------------------------------ */
+
+  async updateTenant(tenantId: string, dto: UpdateTenantPlatformDto) {
+    const tenant = await this.prisma.tenant.findUnique({
+      where: { tenant_id: tenantId },
+    });
+    if (!tenant) {
+      throw new NotFoundException('Tenant not found');
+    }
+
+    // Validate plan if provided
+    if (dto.planId) {
+      const plan = await this.prisma.plan.findUnique({
+        where: { plan_id: dto.planId },
+      });
+      if (!plan) {
+        throw new NotFoundException('Plan not found');
+      }
+    }
+
+    const updated = await this.prisma.tenant.update({
+      where: { tenant_id: tenantId },
+      data: {
+        ...(dto.planId !== undefined && { tenant_plan_id: dto.planId }),
+        ...(dto.enabledFeatures !== undefined && {
+          tenant_enabled_features: dto.enabledFeatures,
+        }),
+        ...(dto.isActive !== undefined && { tenant_is_active: dto.isActive }),
+        ...(dto.maxClinics !== undefined && { tenant_max_clinics: dto.maxClinics }),
+        ...(dto.maxUsers !== undefined && { tenant_max_users: dto.maxUsers }),
+        ...(dto.maxDoctors !== undefined && { tenant_max_doctors: dto.maxDoctors }),
+        ...(dto.maxPatients !== undefined && { tenant_max_patients: dto.maxPatients }),
+      },
+      include: { plan: true },
+    });
+
+    return {
+      id: updated.tenant_id,
+      name: updated.tenant_name,
+      isActive: updated.tenant_is_active,
+      enabledFeatures: updated.tenant_enabled_features,
+      plan: updated.plan
+        ? { id: updated.plan.plan_id, name: updated.plan.plan_name }
+        : null,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  DEACTIVATE / REACTIVATE                                            */
+  /* ------------------------------------------------------------------ */
+
+  async deactivateTenant(tenantId: string) {
+    const tenant = await this.prisma.tenant.findUnique({
+      where: { tenant_id: tenantId },
+    });
+    if (!tenant) {
+      throw new NotFoundException('Tenant not found');
+    }
+
+    await this.prisma.tenant.update({
+      where: { tenant_id: tenantId },
+      data: { tenant_is_active: false },
+    });
+
+    this.logger.log(`Tenant ${tenantId} deactivated`);
+    return { message: 'Tenant deactivated' };
+  }
+
+  async reactivateTenant(tenantId: string) {
+    const tenant = await this.prisma.tenant.findUnique({
+      where: { tenant_id: tenantId },
+    });
+    if (!tenant) {
+      throw new NotFoundException('Tenant not found');
+    }
+
+    await this.prisma.tenant.update({
+      where: { tenant_id: tenantId },
+      data: { tenant_is_active: true },
+    });
+
+    this.logger.log(`Tenant ${tenantId} reactivated`);
+    return { message: 'Tenant reactivated' };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PRIVATE HELPERS                                                     */
+  /* ------------------------------------------------------------------ */
+
+  private slugify(text: string): string {
+    return text
+      .toLowerCase()
+      .trim()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-');
+  }
+}

package/nestjs/src/queue/queue.module.ts

@@ -0,0 +1,56 @@
+import { Global, Module } from '@nestjs/common';
+import { BullModule } from '@nestjs/bullmq';
+import { ConfigService } from '@nestjs/config';
+
+@Global()
+@Module({
+  imports: [
+    BullModule.forRootAsync({
+      useFactory: (configService: ConfigService) => ({
+        connection: {
+          url: configService.get<string>('REDIS_URL', 'redis://localhost:6379'),
+        },
+      }),
+      inject: [ConfigService],
+    }),
+    // WhatsApp queues
+    BullModule.registerQueue(
+      { name: 'whatsapp-grace' },
+      { name: 'whatsapp-message-buffer' },
+      { name: 'whatsapp-session-cleanup' },
+      { name: 'whatsapp-cost-sweep' },
+      { name: 'whatsapp-operator-expiry' },
+      { name: 'whatsapp-profile-update' },
+      { name: 'whatsapp-session-labels' },
+      { name: 'whatsapp-message-cleanup' },
+    ),
+    // ElevenLabs queues
+    BullModule.registerQueue(
+      { name: 'elevenlabs-webhook' },
+      { name: 'elevenlabs-tools' },
+    ),
+    // Billing queues
+    BullModule.registerQueue(
+      { name: 'billing-snapshot' },
+      { name: 'billing-alerts' },
+    ),
+    // Appointment queues
+    BullModule.registerQueue(
+      { name: 'appointment-validation-dispatch' },
+      { name: 'appointment-validation-sync' },
+      { name: 'appointment-reminder' },
+    ),
+    // Outbound campaign queues
+    BullModule.registerQueue(
+      { name: 'outbound-campaigns-dispatch' },
+    ),
+    // Infrastructure queues
+    BullModule.registerQueue(
+      { name: 'inbound-call-schedule-sync' },
+      { name: 'log-cleanup' },
+      { name: 'webhook-outgoing' },
+    ),
+  ],
+  exports: [BullModule],
+})
+export class QueueModule {}

package/nestjs/src/redis/redis.module.ts

@@ -0,0 +1,20 @@
+import { Global, Module } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Redis from 'ioredis';
+
+export const REDIS_CLIENT = 'REDIS_CLIENT';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: REDIS_CLIENT,
+      useFactory: (configService: ConfigService) => {
+        return new Redis(configService.get<string>('REDIS_URL', 'redis://localhost:6379'));
+      },
+      inject: [ConfigService],
+    },
+  ],
+  exports: [REDIS_CLIENT],
+})
+export class RedisModule {}

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

@@ -0,0 +1 @@
+export { UpdateTenantDto } from './update-tenant.dto';

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

@@ -0,0 +1,15 @@
+import { IsString, IsBoolean, IsOptional, MaxLength } from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdateTenantDto {
+  @ApiPropertyOptional({ example: 'My Clinic' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  name?: string;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  kvkkConsent?: boolean;
+}

package/nestjs/src/tenants/tenants.controller.ts

@@ -0,0 +1,45 @@
+import {
+  Controller,
+  Get,
+  Put,
+  Body,
+  UseGuards,
+  BadRequestException,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { TenantsService } from './tenants.service';
+import { UpdateTenantDto } from './dto';
+import { JwtAuthGuard, PermissionsGuard } from '../common/guards';
+import { CurrentUser, Permissions } from '../common/decorators';
+import type { JwtPayload } from '../common/interfaces/jwt-payload.interface';
+
+@ApiTags('Tenants')
+@Controller('tenants')
+@UseGuards(JwtAuthGuard)
+@ApiBearerAuth()
+export class TenantsController {
+  constructor(private readonly tenantsService: TenantsService) {}
+
+  @Get('me')
+  @ApiOperation({ summary: 'Get current tenant' })
+  async getMyTenant(@CurrentUser() user: JwtPayload) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    return this.tenantsService.findByIdOrFail(user.tenantId);
+  }
+
+  @Put('me')
+  @UseGuards(PermissionsGuard)
+  @Permissions('tenant:update')
+  @ApiOperation({ summary: 'Update current tenant' })
+  async updateMyTenant(
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: UpdateTenantDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+    return this.tenantsService.update(user.tenantId, dto);
+  }
+}

package/nestjs/src/tenants/tenants.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { TenantsController } from './tenants.controller';
+import { TenantsService } from './tenants.service';
+
+@Module({
+  controllers: [TenantsController],
+  providers: [TenantsService],
+  exports: [TenantsService],
+})
+export class TenantsModule {}

package/nestjs/src/tenants/tenants.service.ts

@@ -0,0 +1,41 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { UpdateTenantDto } from './dto';
+
+@Injectable()
+export class TenantsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findById(tenantId: string) {
+    return this.prisma.tenant.findUnique({
+      where: { tenant_id: tenantId },
+      include: { plan: true },
+    });
+  }
+
+  async findByIdOrFail(tenantId: string) {
+    const tenant = await this.findById(tenantId);
+    if (!tenant) {
+      throw new NotFoundException('Tenant not found');
+    }
+    return tenant;
+  }
+
+  async update(tenantId: string, dto: UpdateTenantDto) {
+    await this.findByIdOrFail(tenantId);
+
+    return this.prisma.tenant.update({
+      where: { tenant_id: tenantId },
+      data: {
+        ...(dto.name !== undefined && { tenant_name: dto.name }),
+        ...(dto.kvkkConsent !== undefined && { tenant_kvkk_consent: dto.kvkkConsent }),
+      },
+      include: { plan: true },
+    });
+  }
+
+  async getFeatures(tenantId: string): Promise<string[]> {
+    const tenant = await this.findByIdOrFail(tenantId);
+    return tenant.tenant_enabled_features;
+  }
+}

package/nestjs/src/tools/adapters/elevenlabs-http.adapter.ts

@@ -0,0 +1,51 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ToolRegistryService } from '../tool-registry.service.js';
+import type { ToolContext, ToolResult } from '../tool.interfaces.js';
+
+/**
+ * Adapter for ElevenLabs HTTP webhook tool calls.
+ * Used by SIP trunk voice call tool webhooks (POST /webhooks/elevenlabs/tools/:toolName).
+ */
+@Injectable()
+export class ElevenLabsHttpAdapter {
+  private readonly logger = new Logger(ElevenLabsHttpAdapter.name);
+
+  constructor(private readonly registry: ToolRegistryService) {}
+
+  /**
+   * Handle an HTTP-based tool call from ElevenLabs webhook.
+   * Returns a JSON-serializable response.
+   */
+  async handleToolCall(
+    toolName: string,
+    body: {
+      agent_id?: string;
+      conversation_id?: string;
+      parameters?: Record<string, any>;
+      [key: string]: any;
+    },
+    ctx: ToolContext,
+  ): Promise<{ result: any; is_error: boolean }> {
+    const parameters = body.parameters ?? {};
+
+    this.logger.debug(
+      `HTTP tool call: ${toolName} for ${ctx.patientPhone}`,
+    );
+
+    let result: ToolResult;
+    try {
+      result = await this.registry.execute(toolName, ctx, parameters);
+    } catch (err: any) {
+      this.logger.error(
+        `Tool ${toolName} failed: ${err.message}`,
+        err.stack,
+      );
+      result = { data: err.message, isError: true };
+    }
+
+    return {
+      result: result.data,
+      is_error: result.isError,
+    };
+  }
+}

package/nestjs/src/tools/adapters/elevenlabs-ws.adapter.ts

@@ -0,0 +1,59 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ToolRegistryService } from '../tool-registry.service.js';
+import type { ToolContext, ToolResult } from '../tool.interfaces.js';
+
+/**
+ * Adapter for ElevenLabs WebSocket client_tool_call / client_tool_result protocol.
+ * Used by WhatsApp AI sessions communicating over WS.
+ */
+@Injectable()
+export class ElevenLabsWsAdapter {
+  private readonly logger = new Logger(ElevenLabsWsAdapter.name);
+
+  constructor(private readonly registry: ToolRegistryService) {}
+
+  /**
+   * Handle an incoming client_tool_call message from ElevenLabs WS.
+   * Returns a properly formatted client_tool_result message.
+   */
+  async handleToolCall(
+    wsMessage: {
+      tool_call_id: string;
+      tool_name: string;
+      parameters: Record<string, any>;
+    },
+    ctx: ToolContext,
+  ): Promise<{
+    type: 'client_tool_result';
+    tool_call_id: string;
+    result: string;
+    is_error: boolean;
+  }> {
+    const { tool_call_id, tool_name, parameters } = wsMessage;
+
+    this.logger.debug(
+      `Tool call: ${tool_name} (${tool_call_id}) for ${ctx.patientPhone}`,
+    );
+
+    let result: ToolResult;
+    try {
+      result = await this.registry.execute(tool_name, ctx, parameters);
+    } catch (err: any) {
+      this.logger.error(
+        `Tool ${tool_name} failed: ${err.message}`,
+        err.stack,
+      );
+      result = { data: err.message, isError: true };
+    }
+
+    // ElevenLabs WS protocol: type must be lowercase, is_error is required
+    return {
+      type: 'client_tool_result',
+      tool_call_id,
+      result: typeof result.data === 'string'
+        ? result.data
+        : JSON.stringify(result.data),
+      is_error: result.isError,
+    };
+  }
+}