elevenlabs-webhook-nodejs 1.0.0

package/src/migrations/003_shift-schedule.ts

@@ -0,0 +1,55 @@
+import mongoose from 'mongoose';
+import type { MigrationDefinition } from './migration.runner';
+import logger from '../utils/logger';
+
+const migration: MigrationDefinition = {
+  name: '003_shift-schedule',
+  description: 'Convert flat ai_shift_start/end/days to per-day ai_shift_schedule array',
+  async up() {
+    const db = mongoose.connection.db!;
+    const tenants = db.collection('tenants');
+
+    const cursor = tenants.find({
+      'settings.whatsapp_agent.ai_shift_days': { $exists: true, $ne: [] },
+      $or: [
+        { 'settings.whatsapp_agent.ai_shift_schedule': { $exists: false } },
+        { 'settings.whatsapp_agent.ai_shift_schedule': { $size: 0 } },
+      ],
+    });
+
+    let migrated = 0;
+    let skipped = 0;
+
+    for await (const tenant of cursor) {
+      const shift = tenant.settings?.whatsapp_agent;
+      if (!shift?.ai_shift_days?.length) {
+        skipped++;
+        continue;
+      }
+
+      const schedule = shift.ai_shift_days.map((day: number) => ({
+        day,
+        start: shift.ai_shift_start || '09:00',
+        end: shift.ai_shift_end || '18:00',
+      }));
+
+      await tenants.updateOne(
+        { _id: tenant._id },
+        {
+          $set: { 'settings.whatsapp_agent.ai_shift_schedule': schedule },
+          $unset: {
+            'settings.whatsapp_agent.ai_shift_start': '',
+            'settings.whatsapp_agent.ai_shift_end': '',
+            'settings.whatsapp_agent.ai_shift_days': '',
+          },
+        },
+      );
+
+      migrated++;
+    }
+
+    logger.info('003_shift-schedule: complete', { migrated, skipped });
+  },
+};
+
+export default migration;

package/src/migrations/004_invert-shift-to-clinic-hours.ts

@@ -0,0 +1,30 @@
+import mongoose from 'mongoose';
+import type { MigrationDefinition } from './migration.runner';
+import logger from '../utils/logger';
+
+const migration: MigrationDefinition = {
+  name: '004_invert-shift-to-clinic-hours',
+  description:
+    'Reset ai_shift_schedule and disable feature so tenants can re-configure with new clinic-hours UI',
+  async up() {
+    const db = mongoose.connection.db!;
+    const tenants = db.collection('tenants');
+
+    const result = await tenants.updateMany(
+      { 'settings.whatsapp_agent.ai_shift_enabled': true },
+      {
+        $set: {
+          'settings.whatsapp_agent.ai_shift_enabled': false,
+          'settings.whatsapp_agent.ai_shift_schedule': [],
+        },
+      },
+    );
+
+    logger.info('004_invert-shift-to-clinic-hours: complete', {
+      matched: result.matchedCount,
+      modified: result.modifiedCount,
+    });
+  },
+};
+
+export default migration;

package/src/migrations/005_composite-baileys-chat-ids.ts

@@ -0,0 +1,60 @@
+import mongoose from 'mongoose';
+import type { MigrationDefinition } from './migration.runner';
+import logger from '../utils/logger';
+
+const migration: MigrationDefinition = {
+  name: '005_composite-baileys-chat-ids',
+  description:
+    'Prefix Baileys chat IDs with accountId to make them globally unique across tenants',
+  async up() {
+    const db = mongoose.connection.db!;
+    const chats = db.collection('whatsappchats');
+    const tenants = db.collection('tenants');
+
+    // Find all tenants using Baileys provider
+    const baileysTenants = await tenants.find({
+      'settings.whatsapp_agent.whatsapp_bridge_provider': 'baileys',
+    }).toArray();
+
+    const baileysTenantIds = new Set(
+      baileysTenants.map(t => t._id.toString())
+    );
+
+    if (baileysTenantIds.size === 0) {
+      logger.info('005: no Baileys tenants found, skipping');
+      return;
+    }
+
+    // Find all chats belonging to Baileys tenants that don't already have composite IDs
+    const cursor = chats.find({
+      tenant_id: { $in: baileysTenants.map(t => t._id) },
+      unipile_chat_id: { $not: /^.+:.+@/ },  // skip already-migrated composite IDs
+    });
+
+    let migrated = 0;
+
+    for await (const chat of cursor) {
+      const accountId = chat.unipile_account_id;
+      if (!accountId) {
+        logger.warn('005: chat missing unipile_account_id, skipping', { chatId: chat._id });
+        continue;
+      }
+
+      const newChatId = `${accountId}:${chat.unipile_chat_id}`;
+
+      await chats.updateOne(
+        { _id: chat._id },
+        { $set: { unipile_chat_id: newChatId } },
+      );
+
+      migrated++;
+    }
+
+    logger.info('005_composite-baileys-chat-ids: complete', {
+      baileysTenants: baileysTenantIds.size,
+      migrated,
+    });
+  },
+};
+
+export default migration;

package/src/migrations/migration.model.ts

@@ -0,0 +1,27 @@
+import mongoose, { Schema } from 'mongoose';
+import type { Document } from 'mongoose';
+
+export type MigrationStatus = 'success' | 'failed';
+
+export interface IMigration extends Document {
+  name: string;
+  ran_at: Date;
+  duration_ms: number;
+  status: MigrationStatus;
+  error: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const migrationSchema = new Schema<IMigration>(
+  {
+    name: { type: String, required: true, unique: true },
+    ran_at: { type: Date, required: true },
+    duration_ms: { type: Number, required: true },
+    status: { type: String, enum: ['success', 'failed'], required: true },
+    error: { type: String, default: null },
+  },
+  { timestamps: true },
+);
+
+export default mongoose.model<IMigration>('Migration', migrationSchema);

package/src/migrations/migration.routes.ts

@@ -0,0 +1,40 @@
+import type { FastifyInstance } from 'fastify';
+import { getMigrationStatus, runPendingMigrations } from './migration.runner';
+
+export default async function migrationRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /admin/migrations — list all migrations with status
+  fastify.get('/', async () => {
+    const migrations = await getMigrationStatus();
+    const pending = migrations.filter(m => m.status === 'pending').length;
+    const success = migrations.filter(m => m.status === 'success').length;
+    const failed = migrations.filter(m => m.status === 'failed').length;
+
+    return {
+      summary: { total: migrations.length, pending, success, failed },
+      migrations,
+    };
+  });
+
+  // POST /admin/migrations/run — execute all pending migrations
+  fastify.post('/run', async (_request, reply) => {
+    const result = await runPendingMigrations();
+
+    if (result.failed) {
+      return reply.status(500).send({
+        message: `Migration "${result.failed}" failed. Subsequent migrations skipped.`,
+        executed: result.executed,
+        failed: result.failed,
+        error: result.error,
+      });
+    }
+
+    if (result.executed.length === 0) {
+      return { message: 'No pending migrations.', executed: [] };
+    }
+
+    return {
+      message: `${result.executed.length} migration(s) executed successfully.`,
+      executed: result.executed,
+    };
+  });
+}

package/src/migrations/migration.runner.ts

@@ -0,0 +1,112 @@
+import Migration from './migration.model';
+import logger from '../utils/logger';
+
+// ─── Interface ───────────────────────────────────────────────
+
+export interface MigrationDefinition {
+  name: string;
+  description: string;
+  up: () => Promise<void>;
+}
+
+export interface MigrationStatusItem {
+  name: string;
+  description: string;
+  status: 'pending' | 'success' | 'failed';
+  ran_at: Date | null;
+  duration_ms: number | null;
+  error: string | null;
+}
+
+// ─── Registry (static imports, explicit order) ───────────────
+
+import m001 from './001_session-architecture';
+import m002 from './002_agent-ref';
+import m003 from './003_shift-schedule';
+import m004 from './004_invert-shift-to-clinic-hours';
+import m005 from './005_composite-baileys-chat-ids';
+
+const ALL_MIGRATIONS: MigrationDefinition[] = [m001, m002, m003, m004, m005];
+
+// ─── Status ──────────────────────────────────────────────────
+
+export async function getMigrationStatus(): Promise<MigrationStatusItem[]> {
+  const ran = await Migration.find().lean();
+  const ranMap = new Map(ran.map(m => [m.name, m]));
+
+  return ALL_MIGRATIONS.map(def => {
+    const record = ranMap.get(def.name);
+    return {
+      name: def.name,
+      description: def.description,
+      status: record ? record.status : 'pending',
+      ran_at: record?.ran_at ?? null,
+      duration_ms: record?.duration_ms ?? null,
+      error: record?.error ?? null,
+    };
+  });
+}
+
+// ─── Runner ──────────────────────────────────────────────────
+
+export async function runPendingMigrations(): Promise<{
+  executed: string[];
+  failed: string | null;
+  error: string | null;
+}> {
+  const ran = await Migration.find({ status: 'success' }).distinct('name');
+  const ranSet = new Set(ran as string[]);
+
+  const pending = ALL_MIGRATIONS.filter(m => !ranSet.has(m.name));
+
+  if (pending.length === 0) {
+    return { executed: [], failed: null, error: null };
+  }
+
+  const executed: string[] = [];
+
+  for (const migration of pending) {
+    const startTime = Date.now();
+    logger.info(`Running migration: ${migration.name}`);
+
+    try {
+      await migration.up();
+      const duration = Date.now() - startTime;
+
+      await Migration.findOneAndUpdate(
+        { name: migration.name },
+        {
+          name: migration.name,
+          ran_at: new Date(startTime),
+          duration_ms: duration,
+          status: 'success',
+          error: null,
+        },
+        { upsert: true },
+      );
+
+      executed.push(migration.name);
+      logger.info(`Migration ${migration.name} completed in ${duration}ms`);
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+
+      await Migration.findOneAndUpdate(
+        { name: migration.name },
+        {
+          name: migration.name,
+          ran_at: new Date(startTime),
+          duration_ms: duration,
+          status: 'failed',
+          error: errorMessage,
+        },
+        { upsert: true },
+      );
+
+      logger.error(`Migration ${migration.name} FAILED after ${duration}ms: ${errorMessage}`);
+      return { executed, failed: migration.name, error: errorMessage };
+    }
+  }
+
+  return { executed, failed: null, error: null };
+}

package/src/models/ConversationClaim.ts

@@ -0,0 +1,17 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface IConversationClaim extends Document {
+  conversation_id: string;
+  user_id: string;
+  user_name: string;
+  expires_at: Date;
+}
+
+const ConversationClaimSchema = new Schema<IConversationClaim>({
+  conversation_id: { type: String, required: true, unique: true },
+  user_id: { type: String, required: true },
+  user_name: { type: String, required: true },
+  expires_at: { type: Date, required: true, index: { expires: 0 } }, // TTL — auto-delete when expired
+});
+
+export default mongoose.model<IConversationClaim>('ConversationClaim', ConversationClaimSchema);

package/src/models/ConversationEvaluation.ts

@@ -0,0 +1,91 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface IConversationEvaluation extends Document {
+  conversation_id: string;
+  evaluator_id: string;
+  evaluator_name: string;
+  skipped: boolean;
+
+  patient_audio_quality: number | null;
+  ai_comprehension: number | null;
+  ai_speech_quality: number | null;
+  ai_content_quality: number | null;
+  no_unnecessary_content: number | null;
+  patient_reached_goal: number | null;
+
+  overall_score: number;
+  notes: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const ConversationEvaluationSchema = new Schema<IConversationEvaluation>(
+  {
+    conversation_id: { type: String, required: true, unique: true, index: true },
+    evaluator_id: { type: String, required: true, index: true },
+    evaluator_name: { type: String, required: true },
+
+    skipped: { type: Boolean, default: false }, // "Degerlendirilemez" — marked as not evaluable
+
+    patient_audio_quality: { type: Number, min: 1, max: 5, default: null },
+    ai_comprehension: { type: Number, min: 1, max: 5, default: null },
+    ai_speech_quality: { type: Number, min: 1, max: 5, default: null },
+    ai_content_quality: { type: Number, min: 1, max: 5, default: null },
+    no_unnecessary_content: { type: Number, min: 1, max: 5, default: null },
+    patient_reached_goal: { type: Number, min: 1, max: 5, default: null },
+
+    overall_score: { type: Number, default: 0 },
+
+    notes: { type: String, default: '' },
+  },
+  { timestamps: true }
+);
+
+// Auto-calculate overall_score before save
+ConversationEvaluationSchema.pre('save', function (next) {
+  const doc = this as unknown as IConversationEvaluation;
+  const criteria = [
+    doc.patient_audio_quality,
+    doc.ai_comprehension,
+    doc.ai_speech_quality,
+    doc.ai_content_quality,
+    doc.no_unnecessary_content,
+    doc.patient_reached_goal,
+  ].filter((v): v is number => typeof v === 'number');
+  doc.overall_score = criteria.length > 0
+    ? Math.round((criteria.reduce((a, b) => a + b, 0) / criteria.length) * 10) / 10
+    : 0;
+  next();
+});
+
+// Also calculate on findOneAndUpdate (upsert)
+ConversationEvaluationSchema.pre('findOneAndUpdate', function (next) {
+  const update = this.getUpdate() as Record<string, unknown>;
+  const set = (update.$set || update) as Record<string, number>;
+
+  const fields = [
+    'patient_audio_quality',
+    'ai_comprehension',
+    'ai_speech_quality',
+    'ai_content_quality',
+    'no_unnecessary_content',
+    'patient_reached_goal',
+  ];
+
+  const values = fields.map((f) => set[f]).filter((v) => typeof v === 'number');
+  if (values.length === 6) {
+    const avg = Math.round((values.reduce((a, b) => a + b, 0) / 6) * 10) / 10;
+    if (update.$set) {
+      (update.$set as Record<string, number>).overall_score = avg;
+    } else {
+      (update as Record<string, number>).overall_score = avg;
+    }
+  }
+
+  next();
+});
+
+export default mongoose.model<IConversationEvaluation>(
+  'ConversationEvaluation',
+  ConversationEvaluationSchema
+);

package/src/models/Summary.ts

@@ -0,0 +1,77 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface INotifiedRecipient {
+  recipient_id: string;
+  recipient_name: string;
+  recipient_type: 'group' | 'contact';
+  sent_at?: Date;
+  message_id?: string;
+  error?: string;
+}
+
+export interface ITokenUsage {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+}
+
+export interface ISummary extends Document {
+  transcription_id: mongoose.Types.ObjectId;
+  conversation_id: string;
+  summary_text: string;
+  summary_title?: string;
+  key_points?: string[];
+  detected_intent?: string;
+  sentiment?: 'positive' | 'neutral' | 'negative';
+  ai_provider: 'openai' | 'gemini';
+  ai_model?: string;
+  token_usage?: ITokenUsage;
+  notification_status: 'pending' | 'sending' | 'sent' | 'failed';
+  notified_recipients?: INotifiedRecipient[];
+  language: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const summarySchema = new Schema<ISummary>({
+  transcription_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Transcription',
+    required: true,
+    index: true
+  },
+  conversation_id: { type: String, required: true, index: true },
+  summary_text: { type: String, required: true },
+  summary_title: { type: String },
+  key_points: [{ type: String }],
+  detected_intent: { type: String },
+  sentiment: {
+    type: String,
+    enum: ['positive', 'neutral', 'negative']
+  },
+  ai_provider: { type: String, enum: ['openai', 'gemini'], required: true },
+  ai_model: { type: String },
+  token_usage: {
+    prompt_tokens: Number,
+    completion_tokens: Number,
+    total_tokens: Number
+  },
+  notification_status: {
+    type: String,
+    enum: ['pending', 'sending', 'sent', 'failed'],
+    default: 'pending'
+  },
+  notified_recipients: [{
+    recipient_id: String,
+    recipient_name: String,
+    recipient_type: { type: String, enum: ['group', 'contact'] },
+    sent_at: Date,
+    message_id: String,
+    error: String
+  }],
+  language: { type: String, default: 'tr' }
+}, {
+  timestamps: true
+});
+
+export default mongoose.model<ISummary>('Summary', summarySchema);

package/src/models/Transcription.ts

@@ -0,0 +1,68 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface ITranscriptEntry {
+  role: string;
+  message: string;
+  time_in_call_secs?: number;
+  tool_calls?: unknown[];
+  tool_results?: unknown[];
+  interrupted?: boolean;
+  source_medium?: string;
+}
+
+export interface ITranscription extends Document {
+  conversation_id: string;
+  agent_id: string;
+  agent_name?: string;
+  user_id?: string;
+  event_type: string;
+  event_timestamp?: number;
+  status: 'done' | 'pending' | 'failed';
+  transcript: ITranscriptEntry[];
+  metadata?: Record<string, unknown>;
+  analysis?: Record<string, unknown>;
+  processing_status: 'pending' | 'summarizing' | 'summarized' | 'notified' | 'failed';
+  summary_id?: mongoose.Types.ObjectId;
+  processing_error?: string;
+  raw_payload?: unknown;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const transcriptEntrySchema = new Schema<ITranscriptEntry>({
+  role: { type: String, required: true },
+  message: { type: String, default: '' },
+  time_in_call_secs: { type: Number },
+  tool_calls: { type: [Schema.Types.Mixed], default: [] },
+  tool_results: { type: [Schema.Types.Mixed], default: [] },
+  interrupted: { type: Boolean, default: false },
+  source_medium: { type: String }
+}, { _id: false });
+
+const transcriptionSchema = new Schema<ITranscription>({
+  conversation_id: { type: String, required: true, unique: true, index: true },
+  agent_id: { type: String, required: true, index: true },
+  agent_name: { type: String },
+  user_id: { type: String, index: true },
+  event_type: { type: String, default: 'post_call_transcription' },
+  event_timestamp: { type: Number },
+  status: { type: String, enum: ['done', 'pending', 'failed'], default: 'done' },
+  transcript: [transcriptEntrySchema],
+  metadata: { type: Schema.Types.Mixed },
+  analysis: { type: Schema.Types.Mixed },
+  processing_status: {
+    type: String,
+    enum: ['pending', 'summarizing', 'summarized', 'notified', 'failed'],
+    default: 'pending',
+    index: true
+  },
+  summary_id: { type: Schema.Types.ObjectId, ref: 'Summary' },
+  processing_error: { type: String },
+  raw_payload: { type: Schema.Types.Mixed }
+}, {
+  timestamps: true
+});
+
+transcriptionSchema.index({ createdAt: -1 });
+
+export default mongoose.model<ITranscription>('Transcription', transcriptionSchema);

package/src/models/WhatsAppRecipient.ts

@@ -0,0 +1,37 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export interface IRecipientFilters {
+  agent_ids?: string[];
+  min_call_duration?: number;
+  keywords?: string[];
+}
+
+export interface IWhatsAppRecipient extends Document {
+  whatsapp_id: string;
+  name: string;
+  type: 'group' | 'contact';
+  is_active: boolean;
+  filters?: IRecipientFilters;
+  total_notifications_sent: number;
+  last_notification_at?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const whatsappRecipientSchema = new Schema<IWhatsAppRecipient>({
+  whatsapp_id: { type: String, required: true, unique: true },
+  name: { type: String, required: true },
+  type: { type: String, enum: ['group', 'contact'], required: true },
+  is_active: { type: Boolean, default: true },
+  filters: {
+    agent_ids: [{ type: String }],
+    min_call_duration: Number,
+    keywords: [{ type: String }]
+  },
+  total_notifications_sent: { type: Number, default: 0 },
+  last_notification_at: { type: Date }
+}, {
+  timestamps: true
+});
+
+export default mongoose.model<IWhatsAppRecipient>('WhatsAppRecipient', whatsappRecipientSchema);