elevenlabs-webhook-nodejs 1.0.0

package/src/config/env.ts

@@ -0,0 +1,94 @@
+import 'dotenv/config';
+import { z } from 'zod';
+
+const envSchema = z.object({
+  // Server
+  PORT: z.coerce.number().default(3000),
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+
+  // MongoDB
+  MONGODB_URI: z.string().min(1, 'MONGODB_URI is required'),
+
+  // ElevenLabs
+  ELEVENLABS_API_KEY: z.string().min(1, 'ELEVENLABS_API_KEY is required'),
+  ELEVENLABS_WEBHOOK_SECRET: z.string().min(1, 'ELEVENLABS_WEBHOOK_SECRET is required'),
+  DEFAULT_PROFILE_AGENT_ID: z.string().default(''),
+
+  // AI
+  AI_PROVIDER: z.enum(['openai', 'gemini']).default('openai'),
+  SUMMARY_LANGUAGE: z.string().default('tr'),
+  SUMMARY_MAX_TOKENS: z.coerce.number().default(500),
+
+  OPENAI_API_KEY: z.string().default(''),
+  OPENAI_MODEL: z.string().default('gpt-5.4-mini'),
+
+  GEMINI_API_KEY: z.string().default(''),
+  GEMINI_MODEL: z.string().default('gemini-pro'),
+
+  // Unipile
+  UNIPILE_API_KEY: z.string().default(''),
+  UNIPILE_DSN: z.string().default(''),
+  UNIPILE_WEBHOOK_SECRET: z.string().default(''),
+
+  // Baileys (optional second WhatsApp bridge)
+  BAILEYS_DSN: z.string().default(''),
+  BAILEYS_API_KEY: z.string().default(''),
+  BAILEYS_WEBHOOK_SECRET: z.string().default(''),
+
+  // Google Calendar OAuth
+  GOOGLE_CLIENT_ID: z.string().default(''),
+  GOOGLE_CLIENT_SECRET: z.string().default(''),
+  GOOGLE_CALLBACK_URL: z.string().default(''),
+  GOOGLE_TOKEN_ENCRYPTION_KEY: z.string().default(''),
+  GOOGLE_OAUTH_STATE_SECRET: z.string().default(''),
+  FRONTEND_URL: z.string().default('http://localhost:5173'),
+
+  // NetGSM
+  NETGSM_USERNAME: z.string().default(''),
+  NETGSM_PASSWORD: z.string().default(''),
+  NETGSM_MSGHEADER: z.string().default(''),
+  NETGSM_API_URL: z.string().default('https://api.netgsm.com.tr/sms/rest/v2/send'),
+
+  // Twilio
+  TWILIO_ACCOUNT_SID: z.string().min(1, 'TWILIO_ACCOUNT_SID is required'),
+  TWILIO_AUTH_TOKEN: z.string().min(1, 'TWILIO_AUTH_TOKEN is required'),
+  TWILIO_WHATSAPP_NUMBER: z.string().min(1, 'TWILIO_WHATSAPP_NUMBER is required'),
+
+  // JWT
+  JWT_SECRET: z.string().min(1, 'JWT_SECRET is required'),
+  JWT_REFRESH_SECRET: z.string().min(1, 'JWT_REFRESH_SECRET is required'),
+  JWT_ACCESS_EXPIRY: z.string().default('15m'),
+  JWT_REFRESH_EXPIRY: z.string().default('7d'),
+
+  // Admin
+  ADMIN_PASSWORD: z.string().min(1, 'ADMIN_PASSWORD is required'),
+
+  // Logging
+  LOG_LEVEL: z.string().default('info')
+}).superRefine((data, ctx) => {
+  if (data.AI_PROVIDER === 'openai' && !data.OPENAI_API_KEY) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'OPENAI_API_KEY is required when AI_PROVIDER is openai',
+      path: ['OPENAI_API_KEY']
+    });
+  }
+  if (data.AI_PROVIDER === 'gemini' && !data.GEMINI_API_KEY) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'GEMINI_API_KEY is required when AI_PROVIDER is gemini',
+      path: ['GEMINI_API_KEY']
+    });
+  }
+});
+
+const parsed = envSchema.safeParse(process.env);
+
+if (!parsed.success) {
+  const formatted = parsed.error.issues
+    .map(i => `  - ${i.path.join('.')}: ${i.message}`)
+    .join('\n');
+  throw new Error(`Environment validation failed:\n${formatted}`);
+}
+
+export const env = parsed.data;

package/src/config/index.ts

@@ -0,0 +1,86 @@
+import { env } from './env';
+import { AppConfig } from '../types';
+
+const config: AppConfig = {
+  server: {
+    port: env.PORT,
+    env: env.NODE_ENV
+  },
+
+  mongodb: {
+    uri: env.MONGODB_URI
+  },
+
+  elevenlabs: {
+    apiKey: env.ELEVENLABS_API_KEY,
+    webhookSecret: env.ELEVENLABS_WEBHOOK_SECRET,
+    defaultProfileAgentId: env.DEFAULT_PROFILE_AGENT_ID,
+  },
+
+  ai: {
+    provider: env.AI_PROVIDER,
+    summaryLanguage: env.SUMMARY_LANGUAGE,
+    summaryMaxTokens: env.SUMMARY_MAX_TOKENS,
+
+    openai: {
+      apiKey: env.OPENAI_API_KEY,
+      model: env.OPENAI_MODEL
+    },
+
+    gemini: {
+      apiKey: env.GEMINI_API_KEY,
+      model: env.GEMINI_MODEL
+    }
+  },
+
+  logging: {
+    level: env.LOG_LEVEL
+  },
+
+  unipile: {
+    apiKey: env.UNIPILE_API_KEY,
+    dsn: env.UNIPILE_DSN,
+    webhookSecret: env.UNIPILE_WEBHOOK_SECRET,
+  },
+
+  baileys: {
+    apiKey: env.BAILEYS_API_KEY,
+    dsn: env.BAILEYS_DSN,
+    webhookSecret: env.BAILEYS_WEBHOOK_SECRET,
+  },
+
+  twilio: {
+    accountSid: env.TWILIO_ACCOUNT_SID,
+    authToken: env.TWILIO_AUTH_TOKEN,
+    whatsappNumber: env.TWILIO_WHATSAPP_NUMBER
+  },
+
+  jwt: {
+    accessSecret: env.JWT_SECRET,
+    refreshSecret: env.JWT_REFRESH_SECRET,
+    accessExpiry: env.JWT_ACCESS_EXPIRY,
+    refreshExpiry: env.JWT_REFRESH_EXPIRY
+  },
+
+  admin: {
+    password: env.ADMIN_PASSWORD
+  },
+
+  google: {
+    clientId: env.GOOGLE_CLIENT_ID,
+    clientSecret: env.GOOGLE_CLIENT_SECRET,
+    callbackUrl: env.GOOGLE_CALLBACK_URL,
+    tokenEncryptionKey: env.GOOGLE_TOKEN_ENCRYPTION_KEY,
+    oauthStateSecret: env.GOOGLE_OAUTH_STATE_SECRET,
+    frontendUrl: env.FRONTEND_URL,
+  },
+
+  netgsm: {
+    username: env.NETGSM_USERNAME,
+    password: env.NETGSM_PASSWORD,
+    msgheader: env.NETGSM_MSGHEADER,
+    apiUrl: env.NETGSM_API_URL,
+  },
+};
+
+export default config;

package/src/controllers/webhook.controller.ts

@@ -0,0 +1,150 @@
+import { FastifyRequest, FastifyReply } from 'fastify';
+import logger from '../utils/logger';
+import Transcription, { ITranscription } from '../models/Transcription';
+import Summary, { ISummary } from '../models/Summary';
+import { createAIService } from '../services/ai';
+import whatsappService from '../services/whatsapp.service';
+import { ElevenLabsWebhookPayload } from '../types';
+
+class WebhookController {
+  async handleWebhook(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const payload = request.body as ElevenLabsWebhookPayload;
+
+    reply.status(200).send({ status: 'received' });
+
+    this.processWebhook(payload).catch(error => {
+      logger.error('Webhook processing failed', { error: (error as Error).message });
+    });
+  }
+
+  private async processWebhook(payload: ElevenLabsWebhookPayload): Promise<void> {
+    logger.info('Processing webhook', {
+      type: payload.type,
+      conversation_id: payload.data?.conversation_id
+    });
+
+    if (payload.type !== 'post_call_transcription') {
+      logger.info('Skipping non-transcription webhook', { type: payload.type });
+      return;
+    }
+
+    const { data } = payload;
+
+    const transcription = await this.saveTranscription(payload);
+    const summary = await this.generateAndSaveSummary(transcription);
+    await this.sendNotifications(summary, transcription);
+
+    logger.info('Webhook processing completed', {
+      conversation_id: data.conversation_id
+    });
+  }
+
+  private async saveTranscription(payload: ElevenLabsWebhookPayload): Promise<ITranscription> {
+    const { data, event_timestamp, type } = payload;
+
+    const transcription = new Transcription({
+      conversation_id: data.conversation_id,
+      agent_id: data.agent_id,
+      agent_name: data.agent_name,
+      user_id: data.user_id,
+      event_type: type,
+      event_timestamp,
+      status: data.status,
+      transcript: data.transcript.map(t => ({
+        role: t.role,
+        message: t.message,
+        time_in_call_secs: t.time_in_call_secs,
+        tool_calls: t.tool_calls,
+        tool_results: t.tool_results,
+        interrupted: t.interrupted,
+        source_medium: t.source_medium
+      })),
+      metadata: {
+        start_time_unix_secs: data.metadata?.start_time_unix_secs,
+        call_duration_secs: data.metadata?.call_duration_secs,
+        cost: data.metadata?.cost,
+        termination_reason: data.metadata?.termination_reason,
+        main_language: data.metadata?.main_language,
+        phone_call: data.metadata?.phone_call
+      },
+      analysis: data.analysis,
+      processing_status: 'pending',
+      raw_payload: payload
+    });
+
+    await transcription.save();
+    logger.info('Transcription saved', { id: transcription._id });
+
+    return transcription;
+  }
+
+  private async generateAndSaveSummary(transcription: ITranscription): Promise<ISummary> {
+    try {
+      transcription.processing_status = 'summarizing';
+      await transcription.save();
+
+      const aiService = createAIService();
+      const result = await aiService.generateSummary(
+        transcription.transcript,
+        {
+          language: (transcription.metadata as Record<string, unknown>)?.main_language as string || 'tr',
+          agentId: transcription.agent_id
+        }
+      );
+
+      const summary = new Summary({
+        transcription_id: transcription._id,
+        conversation_id: transcription.conversation_id,
+        summary_text: result.summary,
+        summary_title: (transcription.analysis as Record<string, unknown>)?.call_summary_title,
+        ai_provider: aiService.providerName,
+        ai_model: result.model,
+        token_usage: result.tokenUsage,
+        language: (transcription.metadata as Record<string, unknown>)?.main_language as string || 'tr',
+        notification_status: 'pending'
+      });
+
+      await summary.save();
+
+      transcription.processing_status = 'summarized';
+      transcription.summary_id = summary._id;
+      await transcription.save();
+
+      logger.info('Summary generated', { id: summary._id });
+
+      return summary;
+    } catch (error) {
+      transcription.processing_status = 'failed';
+      transcription.processing_error = (error as Error).message;
+      await transcription.save();
+      throw error;
+    }
+  }
+
+  private async sendNotifications(summary: ISummary, transcription: ITranscription): Promise<void> {
+    try {
+      summary.notification_status = 'sending';
+      await summary.save();
+
+      const results = await whatsappService.sendSummaryToRecipients(summary, transcription);
+
+      summary.notified_recipients = results;
+      summary.notification_status = results.some(r => !r.error) ? 'sent' : 'failed';
+      await summary.save();
+
+      transcription.processing_status = 'notified';
+      await transcription.save();
+
+      logger.info('Notifications sent', {
+        total: results.length,
+        successful: results.filter(r => !r.error).length
+      });
+    } catch (error) {
+      summary.notification_status = 'failed';
+      await summary.save();
+      logger.error('Notification sending failed', { error: (error as Error).message });
+    }
+  }
+}
+
+export default new WebhookController();

package/src/errors/index.ts

@@ -0,0 +1,9 @@
+export class AppError extends Error {
+  statusCode: number;
+
+  constructor(message: string, statusCode: number = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = 'AppError';
+  }
+}

package/src/hooks/webhookValidator.ts

@@ -0,0 +1,55 @@
+import crypto from 'crypto';
+import { FastifyRequest, FastifyReply } from 'fastify';
+import config from '../config';
+import logger from '../utils/logger';
+
+const TIMESTAMP_TOLERANCE_SECONDS = 30 * 60;
+
+export async function webhookValidator(
+  request: FastifyRequest,
+  reply: FastifyReply
+): Promise<void> {
+  const signatureHeader = request.headers['elevenlabs-signature'] as string | undefined;
+
+  // If no signature header, allow through but log warning
+  // (some ElevenLabs agents may not have webhook signing configured)
+  if (!signatureHeader) {
+    logger.warn('Missing elevenlabs-signature header — allowing unsigned webhook', { url: request.url });
+    return;
+  }
+
+  const parts = signatureHeader.split(',');
+  const timestamp = parts[0].substring(2);
+  const signature = parts[1];
+
+  const currentTime = Math.floor(Date.now() / 1000);
+  if (parseInt(timestamp) < currentTime - TIMESTAMP_TOLERANCE_SECONDS) {
+    logger.warn('Webhook timestamp too old', { timestamp, tolerance: currentTime - TIMESTAMP_TOLERANCE_SECONDS });
+    reply.status(401).send({ error: 'Timestamp expired' });
+    return;
+  }
+
+  const rawBody = (request as FastifyRequest & { rawBody?: string }).rawBody;
+  const payloadToSign = `${timestamp}.${rawBody}`;
+
+  const hmac = crypto.createHmac('sha256', config.elevenlabs.webhookSecret);
+  hmac.update(payloadToSign);
+  const expectedSignature = 'v0=' + hmac.digest('hex');
+
+  try {
+    if (!crypto.timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature)
+    )) {
+      logger.warn('Invalid webhook signature');
+      reply.status(401).send({ error: 'Invalid signature' });
+      return;
+    }
+  } catch {
+    logger.warn('Signature comparison failed');
+    reply.status(401).send({ error: 'Invalid signature' });
+    return;
+  }
+
+  // Signature valid
+}

package/src/index.ts

@@ -0,0 +1,68 @@
+import config from './config';
+import { connectDatabase } from './config/database';
+import whatsappService from './services/whatsapp.service';
+import elevenlabsService from './services/elevenlabs.service';
+import unipileService from './services/unipile.service';
+import whatsappAgentService from './services/whatsapp-agent.service';
+import { buildApp } from './app';
+import { syncActiveBatches, resumeInterruptedBatches } from './modules/appointment-validation/appointment-validation.service';
+import { snapshotExpiredPeriods, checkAndSendBillingAlerts } from './modules/billing/billing.service';
+import inboundCallScheduleService from './services/inbound-call-schedule.service';
+import cron from 'node-cron';
+import logger from './utils/logger';
+
+async function start() {
+  try {
+    await connectDatabase();
+    logger.info('Connected to MongoDB');
+
+    await whatsappService.initialize();
+    logger.info('WhatsApp client initialized');
+
+    await elevenlabsService.initialize();
+    logger.info('ElevenLabs client initialized');
+
+    await unipileService.initialize();
+    logger.info('Unipile client initialized');
+
+    await whatsappAgentService.initialize();
+    logger.info('WhatsApp Agent service initialized');
+
+    inboundCallScheduleService.initialize();
+
+    const app = await buildApp();
+    await app.listen({ port: config.server.port, host: '0.0.0.0' });
+    logger.info(`Server running on port ${config.server.port}`);
+
+    // Resume any interrupted appointment validation batches
+    resumeInterruptedBatches().catch(err =>
+      logger.error('Failed to resume interrupted batches', { error: (err as Error).message }),
+    );
+
+    // Daily billing period snapshot sweep at 00:05 Europe/Istanbul
+    cron.schedule('5 0 * * *', () => {
+      snapshotExpiredPeriods().catch(err =>
+        logger.error('Billing snapshot sweep failed', { error: (err as Error).message }),
+      );
+    }, { timezone: 'Europe/Istanbul' });
+
+    // Daily billing SMS alerts at 09:00 Istanbul
+    cron.schedule('0 9 * * *', () => {
+      checkAndSendBillingAlerts().catch(err =>
+        logger.error('Billing alert check failed', { error: (err as Error).message }),
+      );
+    }, { timezone: 'Europe/Istanbul' });
+
+    // Sync appointment validation batches every 60s
+    setInterval(() => {
+      syncActiveBatches().catch(err =>
+        logger.error('Appointment validation batch sync error', { error: (err as Error).message }),
+      );
+    }, 60_000);
+  } catch (error) {
+    logger.error('Failed to start server', { error: (error as Error).message });
+    process.exit(1);
+  }
+}
+
+start();

package/src/migrations/001_session-architecture.ts

@@ -0,0 +1,138 @@
+import mongoose from 'mongoose';
+import type { MigrationDefinition } from './migration.runner';
+import WhatsAppSession from '../modules/whatsapp/whatsapp-session.model';
+import WhatsAppMessage from '../modules/whatsapp/whatsapp-message.model';
+import logger from '../utils/logger';
+
+const migration: MigrationDefinition = {
+  name: '001_session-architecture',
+  description: 'Migrate chat-centric to session-centric WhatsApp architecture',
+  async up() {
+    const chatCollection = mongoose.connection.collection('whatsappchats');
+    const allChats = await chatCollection.find({}).toArray();
+    logger.info('001_session-architecture: found chats', { count: allChats.length });
+
+    let sessionsCreated = 0;
+    let messagesUpdated = 0;
+    let chatsUpdated = 0;
+
+    for (const chat of allChats) {
+      const chatId = chat._id;
+      const tenantId = chat.tenant_id;
+
+      // Read old embedded fields
+      const oldMode = (chat as any).mode as string | undefined;
+      const oldSessionStatus = (chat as any).session_status as string | undefined;
+      const oldSessionStartedAt = (chat as any).session_started_at as Date | null;
+      const oldGraceDeadline = (chat as any).session_grace_deadline as Date | null;
+      const oldResolvedBy = (chat as any).session_resolved_by as string | null;
+      const oldTakenOverBy = (chat as any).taken_over_by as mongoose.Types.ObjectId | null;
+      const oldTakenOverAt = (chat as any).taken_over_at as Date | null;
+      const oldELConversationId = (chat as any).elevenlabs_conversation_id as string | null;
+      const oldELConversationCreatedAt = (chat as any).elevenlabs_conversation_created_at as Date | null;
+      const oldELLastInteractionAt = (chat as any).elevenlabs_last_interaction_at as Date | null;
+
+      const isClosed = oldMode === 'closed';
+
+      const needsSession =
+        oldSessionStatus === 'waiting' ||
+        oldSessionStatus === 'active' ||
+        (oldMode === 'ai' && oldSessionStatus !== 'idle' && oldSessionStatus !== 'resolved') ||
+        (oldMode === 'human' && oldSessionStatus !== 'idle' && oldSessionStatus !== 'resolved');
+
+      const hadSession = !!(oldSessionStartedAt || oldSessionStatus === 'resolved');
+
+      let activeSessionId: mongoose.Types.ObjectId | null = null;
+
+      // Skip if already migrated
+      if (chat.active_session_id) continue;
+
+      if (hadSession || needsSession) {
+        let sessionStatus: 'waiting' | 'active' | 'resolved' = 'resolved';
+        if (oldSessionStatus === 'waiting') {
+          sessionStatus = 'waiting';
+        } else if (
+          oldSessionStatus === 'active' ||
+          (oldMode === 'ai' && oldSessionStatus !== 'resolved' && oldSessionStatus !== 'idle')
+        ) {
+          sessionStatus = 'active';
+        }
+
+        let resolvedBy: 'human' | 'ai_timeout' | 'manual' | null = null;
+        if (sessionStatus === 'resolved') {
+          resolvedBy = (oldResolvedBy as any) || 'manual';
+        }
+
+        const session = await WhatsAppSession.create({
+          chat_id: chatId,
+          tenant_id: tenantId,
+          status: sessionStatus,
+          resolved_by: resolvedBy,
+          started_at: oldSessionStartedAt || chat.createdAt || new Date(),
+          resolved_at: sessionStatus === 'resolved' ? (oldTakenOverAt || new Date()) : null,
+          grace_deadline: oldGraceDeadline || null,
+          taken_over_by: oldTakenOverBy || null,
+          taken_over_at: oldTakenOverAt || null,
+          elevenlabs_conversation_id: oldELConversationId || null,
+          elevenlabs_conversation_created_at: oldELConversationCreatedAt || null,
+          elevenlabs_last_interaction_at: oldELLastInteractionAt || null,
+          message_count: 0,
+        });
+
+        activeSessionId = sessionStatus !== 'resolved' ? session._id : null;
+
+        // Backfill session_id on messages
+        const messageFilter: any = {
+          chat_id: chatId,
+          session_id: null,
+        };
+        if (oldSessionStartedAt) {
+          messageFilter.createdAt = { $gte: oldSessionStartedAt };
+        }
+
+        const msgResult = await WhatsAppMessage.updateMany(messageFilter, {
+          $set: { session_id: session._id },
+        });
+        messagesUpdated += msgResult.modifiedCount;
+
+        // Update message_count on session
+        const sessionMessageCount = await WhatsAppMessage.countDocuments({ session_id: session._id });
+        await WhatsAppSession.updateOne({ _id: session._id }, { message_count: sessionMessageCount });
+
+        sessionsCreated++;
+      }
+
+      // Update chat: set is_closed + active_session_id, remove old fields
+      await chatCollection.updateOne(
+        { _id: chatId },
+        {
+          $set: {
+            is_closed: isClosed,
+            active_session_id: activeSessionId,
+          },
+          $unset: {
+            mode: '',
+            session_status: '',
+            session_started_at: '',
+            session_grace_deadline: '',
+            session_resolved_by: '',
+            taken_over_by: '',
+            taken_over_at: '',
+            elevenlabs_conversation_id: '',
+            elevenlabs_conversation_created_at: '',
+            elevenlabs_last_interaction_at: '',
+          },
+        },
+      );
+      chatsUpdated++;
+    }
+
+    logger.info('001_session-architecture: complete', {
+      sessionsCreated,
+      messagesUpdated,
+      chatsUpdated,
+    });
+  },
+};
+
+export default migration;

package/src/migrations/002_agent-ref.ts

@@ -0,0 +1,65 @@
+import mongoose from 'mongoose';
+import type { MigrationDefinition } from './migration.runner';
+import logger from '../utils/logger';
+
+const migration: MigrationDefinition = {
+  name: '002_agent-ref',
+  description: 'Convert elevenlabs_agent_id string to agent_id ObjectId reference',
+  async up() {
+    const db = mongoose.connection.db!;
+    const tenants = db.collection('tenants');
+    const agents = db.collection('agents');
+
+    const cursor = tenants.find({
+      'settings.whatsapp_agent.elevenlabs_agent_id': { $ne: null, $exists: true },
+    });
+
+    let migrated = 0;
+    let skipped = 0;
+    let notFound = 0;
+
+    for await (const tenant of cursor) {
+      const oldElId = tenant.settings?.whatsapp_agent?.elevenlabs_agent_id;
+      const existingAgentId = tenant.settings?.whatsapp_agent?.agent_id;
+
+      if (!oldElId) {
+        skipped++;
+        continue;
+      }
+
+      if (existingAgentId) {
+        skipped++;
+        continue;
+      }
+
+      // Find matching Agent record
+      let agent = await agents.findOne({ elevenlabs_agent_id: oldElId });
+      if (!agent) {
+        agent = await agents.findOne({ tenant_id: tenant._id, is_active: true });
+      }
+
+      if (!agent) {
+        logger.warn('002_agent-ref: no Agent found for tenant', {
+          tenantName: tenant.name,
+          oldElId,
+        });
+        notFound++;
+        continue;
+      }
+
+      await tenants.updateOne(
+        { _id: tenant._id },
+        {
+          $set: { 'settings.whatsapp_agent.agent_id': agent._id },
+          $unset: { 'settings.whatsapp_agent.elevenlabs_agent_id': '' },
+        },
+      );
+
+      migrated++;
+    }
+
+    logger.info('002_agent-ref: complete', { migrated, skipped, notFound });
+  },
+};
+
+export default migration;