elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/leads/leads.service.ts

@@ -0,0 +1,375 @@
+import { Injectable, NotFoundException, Logger } from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+import { QueryLeadsDto, UpdateLeadDto } from './dto';
+
+@Injectable()
+export class LeadsService {
+  private readonly logger = new Logger(LeadsService.name);
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST (paginated with filters)                                      */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(
+    tenantId: string,
+    clinicIds?: string[],
+    query?: QueryLeadsDto,
+  ) {
+    const page = query?.page ? parseInt(query.page, 10) : 1;
+    const limit = query?.limit ? parseInt(query.limit, 10) : 25;
+    const skip = (page - 1) * limit;
+
+    const where: any = { lead_tenant_id: tenantId };
+
+    if (clinicIds && clinicIds.length > 0) {
+      where.lead_clinic_id = { in: clinicIds };
+    }
+
+    if (query?.status) {
+      where.lead_status = query.status;
+    }
+
+    if (query?.clinicId) {
+      where.lead_clinic_id = query.clinicId;
+    }
+
+    if (query?.from || query?.to) {
+      where.lead_created_at = {};
+      if (query.from) {
+        where.lead_created_at.gte = new Date(query.from);
+      }
+      if (query.to) {
+        where.lead_created_at.lte = new Date(query.to);
+      }
+    }
+
+    const [leads, total] = await Promise.all([
+      this.prisma.lead.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { lead_created_at: 'desc' },
+        include: {
+          clinic: {
+            select: { clinic_id: true, clinic_name: true },
+          },
+          patient: {
+            select: {
+              patient_id: true,
+              patient_display_name: true,
+              patient_phone: true,
+            },
+          },
+        },
+      }),
+      this.prisma.lead.count({ where }),
+    ]);
+
+    return {
+      data: leads.map((l) => this.formatLead(l)),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY ID                                                         */
+  /* ------------------------------------------------------------------ */
+
+  async findById(leadId: string, tenantId: string) {
+    const lead = await this.prisma.lead.findFirst({
+      where: {
+        lead_id: leadId,
+        lead_tenant_id: tenantId,
+      },
+      include: {
+        clinic: {
+          select: { clinic_id: true, clinic_name: true },
+        },
+        patient: {
+          select: {
+            patient_id: true,
+            patient_display_name: true,
+            patient_phone: true,
+          },
+        },
+        call: {
+          select: {
+            call_id: true,
+            call_direction: true,
+            call_status: true,
+            call_duration_seconds: true,
+            call_created_at: true,
+          },
+        },
+        session: {
+          select: {
+            session_id: true,
+            session_status: true,
+            session_created_at: true,
+          },
+        },
+      },
+    });
+
+    if (!lead) {
+      throw new NotFoundException('Lead not found');
+    }
+
+    return this.formatLeadDetail(lead);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND TODAY (last 24h)                                              */
+  /* ------------------------------------------------------------------ */
+
+  async findToday(tenantId: string, clinicIds?: string[]) {
+    const since = new Date(Date.now() - 24 * 60 * 60 * 1000);
+
+    const where: any = {
+      lead_tenant_id: tenantId,
+      lead_created_at: { gte: since },
+    };
+
+    if (clinicIds && clinicIds.length > 0) {
+      where.lead_clinic_id = { in: clinicIds };
+    }
+
+    const leads = await this.prisma.lead.findMany({
+      where,
+      orderBy: { lead_created_at: 'desc' },
+      include: {
+        clinic: {
+          select: { clinic_id: true, clinic_name: true },
+        },
+        patient: {
+          select: {
+            patient_id: true,
+            patient_display_name: true,
+            patient_phone: true,
+          },
+        },
+      },
+    });
+
+    return {
+      data: leads.map((l) => this.formatLead(l)),
+      total: leads.length,
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async update(leadId: string, tenantId: string, dto: UpdateLeadDto) {
+    const lead = await this.prisma.lead.findFirst({
+      where: { lead_id: leadId, lead_tenant_id: tenantId },
+    });
+
+    if (!lead) {
+      throw new NotFoundException('Lead not found');
+    }
+
+    const data: any = {};
+
+    if (dto.status !== undefined) {
+      data.lead_status = dto.status;
+    }
+
+    const updated = await this.prisma.lead.update({
+      where: { lead_id: leadId },
+      data,
+      include: {
+        clinic: {
+          select: { clinic_id: true, clinic_name: true },
+        },
+        patient: {
+          select: {
+            patient_id: true,
+            patient_display_name: true,
+            patient_phone: true,
+          },
+        },
+      },
+    });
+
+    this.logger.log(
+      `Lead updated: ${leadId} (status=${dto.status ?? 'unchanged'})`,
+    );
+
+    return this.formatLead(updated);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE (internal — used by post-call processor)                    */
+  /* ------------------------------------------------------------------ */
+
+  async create(data: {
+    tenantId: string;
+    clinicId: string;
+    patientId?: string;
+    callId?: string;
+    sessionId?: string;
+    chatId?: string;
+    name?: string;
+    phone: string;
+    serviceOfInterest?: string;
+    status?: string;
+    categories?: string[];
+    summary?: string;
+  }) {
+    const lead = await this.prisma.lead.create({
+      data: {
+        lead_tenant_id: data.tenantId,
+        lead_clinic_id: data.clinicId,
+        ...(data.patientId && { lead_patient_id: data.patientId }),
+        ...(data.callId && { lead_call_id: data.callId }),
+        ...(data.sessionId && { lead_session_id: data.sessionId }),
+        ...(data.chatId && { lead_chat_id: data.chatId }),
+        ...(data.name && { lead_name: data.name }),
+        lead_phone: data.phone,
+        ...(data.serviceOfInterest && {
+          lead_service_of_interest: data.serviceOfInterest,
+        }),
+        ...(data.status && { lead_status: data.status as any }),
+        ...(data.categories && { lead_categories: data.categories }),
+        ...(data.summary && { lead_summary: data.summary }),
+      },
+    });
+
+    this.logger.log(
+      `Lead created: ${lead.lead_id} (tenant=${data.tenantId}, phone=${data.phone})`,
+    );
+
+    return lead;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  EXPORT CSV                                                         */
+  /* ------------------------------------------------------------------ */
+
+  async exportCsv(
+    tenantId: string,
+    clinicIds?: string[],
+    query?: QueryLeadsDto,
+  ) {
+    const where: any = { lead_tenant_id: tenantId };
+
+    if (clinicIds && clinicIds.length > 0) {
+      where.lead_clinic_id = { in: clinicIds };
+    }
+
+    if (query?.status) {
+      where.lead_status = query.status;
+    }
+
+    if (query?.clinicId) {
+      where.lead_clinic_id = query.clinicId;
+    }
+
+    if (query?.from || query?.to) {
+      where.lead_created_at = {};
+      if (query?.from) {
+        where.lead_created_at.gte = new Date(query.from);
+      }
+      if (query?.to) {
+        where.lead_created_at.lte = new Date(query.to);
+      }
+    }
+
+    const leads = await this.prisma.lead.findMany({
+      where,
+      orderBy: { lead_created_at: 'desc' },
+      include: {
+        clinic: {
+          select: { clinic_id: true, clinic_name: true },
+        },
+        patient: {
+          select: {
+            patient_id: true,
+            patient_display_name: true,
+            patient_phone: true,
+          },
+        },
+      },
+    });
+
+    return leads.map((l) => ({
+      id: l.lead_id,
+      name: l.lead_name,
+      phone: l.lead_phone,
+      status: l.lead_status,
+      serviceOfInterest: l.lead_service_of_interest,
+      categories: l.lead_categories.join(', '),
+      summary: l.lead_summary,
+      clinic: l.clinic?.clinic_name ?? '',
+      patient: l.patient?.patient_display_name ?? '',
+      createdAt: l.lead_created_at.toISOString(),
+    }));
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PRIVATE HELPERS                                                    */
+  /* ------------------------------------------------------------------ */
+
+  private formatLead(lead: any) {
+    return {
+      id: lead.lead_id,
+      tenantId: lead.lead_tenant_id,
+      clinicId: lead.lead_clinic_id,
+      patientId: lead.lead_patient_id,
+      callId: lead.lead_call_id,
+      sessionId: lead.lead_session_id,
+      chatId: lead.lead_chat_id,
+      name: lead.lead_name,
+      phone: lead.lead_phone,
+      serviceOfInterest: lead.lead_service_of_interest,
+      status: lead.lead_status,
+      categories: lead.lead_categories,
+      summary: lead.lead_summary,
+      createdAt: lead.lead_created_at,
+      updatedAt: lead.lead_updated_at,
+      clinic: lead.clinic
+        ? { id: lead.clinic.clinic_id, name: lead.clinic.clinic_name }
+        : null,
+      patient: lead.patient
+        ? {
+            id: lead.patient.patient_id,
+            displayName: lead.patient.patient_display_name,
+            phone: lead.patient.patient_phone,
+          }
+        : null,
+    };
+  }
+
+  private formatLeadDetail(lead: any) {
+    const base = this.formatLead(lead);
+
+    return {
+      ...base,
+      call: lead.call
+        ? {
+            id: lead.call.call_id,
+            direction: lead.call.call_direction,
+            status: lead.call.call_status,
+            durationSeconds: lead.call.call_duration_seconds,
+            createdAt: lead.call.call_created_at,
+          }
+        : null,
+      session: lead.session
+        ? {
+            id: lead.session.session_id,
+            status: lead.session.session_status,
+            createdAt: lead.session.session_created_at,
+          }
+        : null,
+    };
+  }
+}

package/nestjs/src/logging/logging.controller.ts

@@ -0,0 +1,82 @@
+import {
+  Controller,
+  Get,
+  Delete,
+  Param,
+  Query,
+  UseGuards,
+  ForbiddenException,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
+import { LoggingService } from './logging.service';
+import { JwtAuthGuard, PermissionsGuard } from '../common/guards';
+import { CurrentUser, Permissions } from '../common/decorators';
+import type { JwtPayload } from '../common/interfaces/jwt-payload.interface';
+
+@ApiTags('Logs')
+@Controller('admin/logs')
+@UseGuards(JwtAuthGuard, PermissionsGuard)
+@ApiBearerAuth()
+export class LoggingController {
+  constructor(private readonly loggingService: LoggingService) {}
+
+  @Get()
+  @Permissions('audit:read')
+  @ApiOperation({ summary: 'List logs (paginated with filters)' })
+  @ApiQuery({ name: 'level', required: false })
+  @ApiQuery({ name: 'service', required: false })
+  @ApiQuery({ name: 'tenantId', required: false })
+  @ApiQuery({ name: 'clinicId', required: false })
+  @ApiQuery({ name: 'requestId', required: false })
+  @ApiQuery({ name: 'from', required: false, description: 'ISO date string' })
+  @ApiQuery({ name: 'to', required: false, description: 'ISO date string' })
+  @ApiQuery({ name: 'page', required: false, type: Number })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  async findAll(
+    @Query('level') level?: string,
+    @Query('service') service?: string,
+    @Query('tenantId') tenantId?: string,
+    @Query('clinicId') clinicId?: string,
+    @Query('requestId') requestId?: string,
+    @Query('from') from?: string,
+    @Query('to') to?: string,
+    @Query('page') page?: string,
+    @Query('limit') limit?: string,
+  ) {
+    return this.loggingService.findAll({
+      level,
+      service,
+      tenantId,
+      clinicId,
+      requestId,
+      from,
+      to,
+      page: page ? parseInt(page, 10) : 1,
+      limit: limit ? parseInt(limit, 10) : 50,
+    });
+  }
+
+  @Get('stats')
+  @Permissions('audit:read')
+  @ApiOperation({ summary: 'Log count by level' })
+  async getStats() {
+    return this.loggingService.getStats();
+  }
+
+  @Delete()
+  @Permissions('platform:plans.manage')
+  @ApiOperation({ summary: 'Delete logs older than given date (superadmin only)' })
+  @ApiQuery({ name: 'before', required: true, description: 'ISO date string' })
+  async deleteLogs(
+    @Query('before') before: string,
+  ) {
+    return this.loggingService.deleteOlderThan(new Date(before));
+  }
+
+  @Get('request/:requestId')
+  @Permissions('audit:read')
+  @ApiOperation({ summary: 'Get all logs for a specific request ID' })
+  async findByRequestId(@Param('requestId') requestId: string) {
+    return this.loggingService.findByRequestId(requestId);
+  }
+}

package/nestjs/src/logging/logging.module.ts

@@ -0,0 +1,11 @@
+import { Global, Module } from '@nestjs/common';
+import { LoggingController } from './logging.controller';
+import { LoggingService } from './logging.service';
+
+@Global()
+@Module({
+  controllers: [LoggingController],
+  providers: [LoggingService],
+  exports: [LoggingService],
+})
+export class LoggingModule {}

package/nestjs/src/logging/logging.service.ts

@@ -0,0 +1,180 @@
+import { Injectable, OnModuleDestroy, Logger } from '@nestjs/common';
+import { PrismaService } from '../database/prisma.service';
+
+interface LogEntry {
+  level: string;
+  message: string;
+  service?: string;
+  meta?: Record<string, any>;
+  requestId?: string;
+  tenantId?: string;
+  clinicId?: string;
+  userId?: string;
+}
+
+const BUFFER_SIZE = 100;
+const FLUSH_INTERVAL_MS = 5000;
+
+@Injectable()
+export class LoggingService implements OnModuleDestroy {
+  private readonly logger = new Logger(LoggingService.name);
+  private buffer: LogEntry[] = [];
+  private flushTimer: ReturnType<typeof setInterval>;
+
+  constructor(private readonly prisma: PrismaService) {
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) =>
+        this.logger.error('Periodic flush failed', err),
+      );
+    }, FLUSH_INTERVAL_MS);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  WRITE (add to buffer)                                              */
+  /* ------------------------------------------------------------------ */
+
+  write(entry: LogEntry): void {
+    this.buffer.push(entry);
+    if (this.buffer.length >= BUFFER_SIZE) {
+      this.flush().catch((err) =>
+        this.logger.error('Buffer flush failed', err),
+      );
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FLUSH (bulk insert)                                                */
+  /* ------------------------------------------------------------------ */
+
+  async flush(): Promise<void> {
+    if (this.buffer.length === 0) return;
+
+    const entries = this.buffer.splice(0, this.buffer.length);
+
+    try {
+      await this.prisma.log.createMany({
+        data: entries.map((e) => ({
+          log_level: e.level,
+          log_message: e.message,
+          log_service: e.service ?? 'api',
+          log_meta: e.meta ?? {},
+          log_request_id: e.requestId ?? null,
+          log_tenant_id: e.tenantId ?? null,
+          log_clinic_id: e.clinicId ?? null,
+          log_user_id: e.userId ?? null,
+        })),
+      });
+    } catch (err) {
+      // Put entries back on failure so they can be retried
+      this.buffer.unshift(...entries);
+      throw err;
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND ALL (paginated with filters)                                  */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(query?: {
+    level?: string;
+    service?: string;
+    tenantId?: string;
+    clinicId?: string;
+    requestId?: string;
+    from?: string;
+    to?: string;
+    page?: number;
+    limit?: number;
+  }) {
+    const page = query?.page ?? 1;
+    const limit = query?.limit ?? 50;
+    const skip = (page - 1) * limit;
+
+    const where: any = {};
+
+    if (query?.level) where.log_level = query.level;
+    if (query?.service) where.log_service = query.service;
+    if (query?.tenantId) where.log_tenant_id = query.tenantId;
+    if (query?.clinicId) where.log_clinic_id = query.clinicId;
+    if (query?.requestId) where.log_request_id = query.requestId;
+
+    if (query?.from || query?.to) {
+      where.log_timestamp = {};
+      if (query.from) where.log_timestamp.gte = new Date(query.from);
+      if (query.to) where.log_timestamp.lte = new Date(query.to);
+    }
+
+    const [logs, total] = await Promise.all([
+      this.prisma.log.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { log_timestamp: 'desc' },
+      }),
+      this.prisma.log.count({ where }),
+    ]);
+
+    return {
+      data: logs,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY REQUEST ID                                                 */
+  /* ------------------------------------------------------------------ */
+
+  async findByRequestId(requestId: string) {
+    return this.prisma.log.findMany({
+      where: { log_request_id: requestId },
+      orderBy: { log_timestamp: 'asc' },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  STATS                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async getStats() {
+    const counts = await this.prisma.log.groupBy({
+      by: ['log_level'],
+      _count: { log_id: true },
+    });
+
+    const stats: Record<string, number> = {};
+    for (const row of counts) {
+      stats[row.log_level] = row._count.log_id;
+    }
+
+    return stats;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CLEANUP                                                            */
+  /* ------------------------------------------------------------------ */
+
+  async deleteOlderThan(date: Date) {
+    const result = await this.prisma.log.deleteMany({
+      where: { log_timestamp: { lt: date } },
+    });
+
+    this.logger.log(`Deleted ${result.count} logs older than ${date.toISOString()}`);
+    return { deleted: result.count };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  LIFECYCLE                                                          */
+  /* ------------------------------------------------------------------ */
+
+  async onModuleDestroy() {
+    clearInterval(this.flushTimer);
+    await this.flush().catch((err) =>
+      this.logger.error('Final flush failed on shutdown', err),
+    );
+  }
+}