insforge 1.2.10 → 1.4.8

package/backend/src/api/routes/deployments/index.routes.ts

@@ -0,0 +1,192 @@
+import { Router, Response, NextFunction } from 'express';
+import { DeploymentService } from '@/services/deployments/deployment.service.js';
+import { verifyAdmin, AuthRequest } from '@/api/middlewares/auth.js';
+import { AuditService } from '@/services/logs/audit.service.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { successResponse, paginatedResponse } from '@/utils/response.js';
+import { startDeploymentRequestSchema } from '@insforge/shared-schemas';
+
+const router = Router();
+const deploymentService = DeploymentService.getInstance();
+const auditService = AuditService.getInstance();
+
+/**
+ * Create a new deployment record with WAITING status
+ * Returns presigned URL for uploading source zip file
+ * POST /api/deployments
+ */
+router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    // Check if deployment service is configured
+    if (!deploymentService.isConfigured()) {
+      throw new AppError(
+        'Deployment service is not configured. Please set VERCEL_TOKEN, VERCEL_TEAM_ID, and VERCEL_PROJECT_ID environment variables.',
+        503,
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+
+    const response = await deploymentService.createDeployment();
+
+    // Log audit
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'CREATE_DEPLOYMENT',
+      module: 'DEPLOYMENTS',
+      details: { id: response.id },
+      ip_address: req.ip,
+    });
+
+    successResponse(res, response, 201);
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Start a deployment - downloads zip from S3, uploads to Vercel, creates deployment
+ * POST /api/deployments/:id/start
+ */
+router.post(
+  '/:id/start',
+  verifyAdmin,
+  async (req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      // Check if deployment service is configured
+      if (!deploymentService.isConfigured()) {
+        throw new AppError(
+          'Deployment service is not configured. Please set VERCEL_TOKEN, VERCEL_TEAM_ID, and VERCEL_PROJECT_ID environment variables.',
+          503,
+          ERROR_CODES.INTERNAL_ERROR
+        );
+      }
+
+      const { id } = req.params;
+
+      const validationResult = startDeploymentRequestSchema.safeParse(req.body);
+      if (!validationResult.success) {
+        throw new AppError(
+          validationResult.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', '),
+          400,
+          ERROR_CODES.INVALID_INPUT
+        );
+      }
+
+      const deployment = await deploymentService.startDeployment(id, validationResult.data);
+
+      // Log audit
+      await auditService.log({
+        actor: req.user?.email || 'api-key',
+        action: 'START_DEPLOYMENT',
+        module: 'DEPLOYMENTS',
+        details: {
+          id: deployment.id,
+          providerDeploymentId: deployment.providerDeploymentId,
+          provider: deployment.provider,
+          status: deployment.status,
+        },
+        ip_address: req.ip,
+      });
+
+      successResponse(res, deployment);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * List all deployments
+ * GET /api/deployments
+ */
+router.get('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const limit = parseInt(req.query.limit as string) || 50;
+    const offset = parseInt(req.query.offset as string) || 0;
+
+    const { deployments, total } = await deploymentService.listDeployments(limit, offset);
+
+    paginatedResponse(res, deployments, total, offset);
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Get deployment by database ID
+ * GET /api/deployments/:id
+ */
+router.get('/:id', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { id } = req.params;
+
+    const deployment = await deploymentService.getDeploymentById(id);
+
+    if (!deployment) {
+      throw new AppError(`Deployment not found: ${id}`, 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    successResponse(res, deployment);
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Sync deployment status from Vercel and update database
+ * POST /api/deployments/:id/sync
+ */
+router.post(
+  '/:id/sync',
+  verifyAdmin,
+  async (req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const { id } = req.params;
+
+      const deployment = await deploymentService.syncDeploymentById(id);
+
+      if (!deployment) {
+        throw new AppError(`Deployment not found: ${id}`, 404, ERROR_CODES.NOT_FOUND);
+      }
+
+      successResponse(res, deployment);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+/**
+ * Cancel a deployment
+ * POST /api/deployments/:id/cancel
+ */
+router.post(
+  '/:id/cancel',
+  verifyAdmin,
+  async (req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const { id } = req.params;
+
+      await deploymentService.cancelDeploymentById(id);
+
+      // Log audit
+      await auditService.log({
+        actor: req.user?.email || 'api-key',
+        action: 'CANCEL_DEPLOYMENT',
+        module: 'DEPLOYMENTS',
+        details: { id },
+        ip_address: req.ip,
+      });
+
+      successResponse(res, {
+        success: true,
+        message: `Deployment ${id} has been cancelled`,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+export { router as deploymentsRouter };

package/backend/src/api/routes/docs/index.routes.ts

@@ -1,76 +1,76 @@
-import { Router, Request, Response, NextFunction } from 'express';
-import { readFile } from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { successResponse } from '@/utils/response.js';
-import { ERROR_CODES } from '@/types/error-constants.js';
-import { AppError } from '@/api/middlewares/error.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const router = Router();
-
-// Define available documentation files
-const DOCS_MAP: Record<string, string> = {
-  instructions: 'insforge-instructions-sdk.md',
-  'db-sdk': 'core-concepts/database/sdk.mdx',
-  'auth-sdk': 'core-concepts/authentication/sdk.mdx',
-  // UI Components - Framework-specific
-  'auth-components-react': 'core-concepts/authentication/ui-components/react.mdx',
-  'auth-components-nextjs': 'core-concepts/authentication/ui-components/nextjs.mdx',
-  'auth-components-react-router': 'core-concepts/authentication/ui-components/react-router.mdx',
-  'storage-sdk': 'core-concepts/storage/sdk.mdx',
-  'functions-sdk': 'core-concepts/functions/sdk.mdx',
-  'ai-integration-sdk': 'core-concepts/ai/sdk.mdx',
-};
-
-// GET /api/docs/:docType - Get specific documentation
-router.get('/:docType', async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const { docType } = req.params;
-
-    // Validate doc type
-    const docFileName = DOCS_MAP[docType];
-    if (!docFileName) {
-      throw new AppError('Documentation not found', 404, ERROR_CODES.NOT_FOUND);
-    }
-
-    // Read the documentation file
-    // PROJECT_ROOT is set in the docker-compose.yml file to point to the InsForge directory
-    const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, '../../../..');
-    const filePath = path.join(projectRoot, 'docs', docFileName);
-    const content = await readFile(filePath, 'utf-8');
-
-    // Traditional REST: return documentation directly
-    return successResponse(res, {
-      type: docType,
-      content,
-    });
-  } catch (error) {
-    // If file doesn't exist or other error
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-      next(new AppError('Documentation file not found', 404, ERROR_CODES.NOT_FOUND));
-    } else {
-      next(error);
-    }
-  }
-});
-
-// GET /api/docs - List available documentation
-router.get('/', (_req: Request, res: Response, next: NextFunction) => {
-  try {
-    const available = Object.keys(DOCS_MAP).map((key) => ({
-      type: key,
-      filename: DOCS_MAP[key],
-      endpoint: `/api/docs/${key}`,
-    }));
-
-    // Traditional REST: return list directly
-    return successResponse(res, available);
-  } catch (error) {
-    next(error);
-  }
-});
-
-export { router as docsRouter };
+import { Router, Request, Response, NextFunction } from 'express';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { successResponse } from '@/utils/response.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { DocTypeSchema, docTypeSchema } from '@insforge/shared-schemas';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const router = Router();
+
+// Define available documentation files
+const DOCS_MAP: Record<DocTypeSchema, string> = {
+  instructions: 'insforge-instructions-sdk.md',
+  'db-sdk': 'core-concepts/database/sdk.mdx',
+  'auth-sdk': 'core-concepts/authentication/sdk.mdx',
+  // UI Components - Framework-specific
+  'auth-components-react': 'core-concepts/authentication/ui-components/react.mdx',
+  'auth-components-nextjs': 'core-concepts/authentication/ui-components/nextjs.mdx',
+  // 'auth-components-react-router': 'core-concepts/authentication/ui-components/react-router.mdx',
+  'storage-sdk': 'core-concepts/storage/sdk.mdx',
+  'functions-sdk': 'core-concepts/functions/sdk.mdx',
+  'ai-integration-sdk': 'core-concepts/ai/sdk.mdx',
+  'real-time': 'agent-docs/real-time.md',
+  'deployment': 'agent-docs/deployment.md',
+};
+
+// GET /api/docs/:docType - Get specific documentation
+router.get('/:docType', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { docType } = req.params;
+
+    // Validate doc type using Zod enum
+    const parsed = docTypeSchema.safeParse(docType);
+    if (!parsed.success) {
+      throw new AppError('Documentation not found', 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    const docFileName = DOCS_MAP[parsed.data];
+
+    // Read the documentation file
+    // PROJECT_ROOT is set in the docker-compose.yml file to point to the InsForge directory
+    const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, '../../../..');
+    const filePath = path.join(projectRoot, 'docs', docFileName);
+    const content = await readFile(filePath, 'utf-8');
+
+    // Traditional REST: return documentation directly
+    return successResponse(res, {
+      type: docType,
+      content,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /api/docs - List available documentation
+router.get('/', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const available = (Object.keys(DOCS_MAP) as DocTypeSchema[]).map((key) => ({
+      type: key,
+      filename: DOCS_MAP[key],
+      endpoint: `/api/docs/${key}`,
+    }));
+
+    // Traditional REST: return list directly
+    return successResponse(res, available);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export { router as docsRouter };

package/backend/src/api/routes/email/index.routes.ts

@@ -0,0 +1,35 @@
+import { Router, Response, NextFunction } from 'express';
+import { AuthRequest, verifyUser } from '@/api/middlewares/auth.js';
+import { EmailService } from '@/services/email/email.service.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { sendRawEmailRequestSchema } from '@insforge/shared-schemas';
+import { successResponse } from '@/utils/response.js';
+
+const router = Router();
+const emailService = EmailService.getInstance();
+
+/**
+ * POST /api/email/send-raw
+ * Send a raw/custom email with explicit to, subject, and body
+ */
+router.post(
+  '/send-raw',
+  verifyUser,
+  async (req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const validation = sendRawEmailRequestSchema.safeParse(req.body);
+      if (!validation.success) {
+        throw new AppError(JSON.stringify(validation.error.issues), 400, ERROR_CODES.INVALID_INPUT);
+      }
+
+      await emailService.sendRaw(validation.data);
+
+      successResponse(res, {});
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+export const emailRouter = router;

package/backend/src/api/routes/functions/index.routes.ts

@@ -5,7 +5,7 @@ import { AuditService } from '@/services/logs/audit.service.js';
 import { AppError } from '@/api/middlewares/error.js';
 import { ERROR_CODES } from '@/types/error-constants.js';
 import logger from '@/utils/logger.js';
-import { functionUploadRequestSchema, functionUpdateRequestSchema } from '@insforge/shared-schemas';
+import { uploadFunctionRequestSchema, updateFunctionRequestSchema } from '@insforge/shared-schemas';
 import { SocketManager } from '@/infra/socket/socket.manager.js';
 import { DataUpdateResourceType, ServerEvents } from '@/types/socket.js';
 import { successResponse } from '@/utils/response.js';
@@ -53,7 +53,7 @@ router.get('/:slug', verifyAdmin, async (req: AuthRequest, res: Response, next:
  */
 router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const validation = functionUploadRequestSchema.safeParse(req.body);
+    const validation = uploadFunctionRequestSchema.safeParse(req.body);
     if (!validation.success) {
       throw new AppError(JSON.stringify(validation.error.issues), 400, ERROR_CODES.INVALID_INPUT);
     }
@@ -76,9 +76,12 @@ router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: Next
     });
 
     const socket = SocketManager.getInstance();
-    socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-      resource: DataUpdateResourceType.FUNCTIONS,
-    });
+    socket.broadcastToRoom(
+      'role:project_admin',
+      ServerEvents.DATA_UPDATE,
+      { resource: DataUpdateResourceType.FUNCTIONS },
+      'system'
+    );
 
     successResponse(
       res,
@@ -100,7 +103,7 @@ router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: Next
 router.put('/:slug', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
   try {
     const { slug } = req.params;
-    const validation = functionUpdateRequestSchema.safeParse(req.body);
+    const validation = updateFunctionRequestSchema.safeParse(req.body);
 
     if (!validation.success) {
       throw new AppError(JSON.stringify(validation.error.issues), 400, ERROR_CODES.INVALID_INPUT);
@@ -126,12 +129,12 @@ router.put('/:slug', verifyAdmin, async (req: AuthRequest, res: Response, next:
     });
 
     const socket = SocketManager.getInstance();
-    socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-      resource: DataUpdateResourceType.FUNCTIONS,
-      data: {
-        slug,
-      },
-    });
+    socket.broadcastToRoom(
+      'role:project_admin',
+      ServerEvents.DATA_UPDATE,
+      { resource: DataUpdateResourceType.FUNCTIONS, data: { slug } },
+      'system'
+    );
 
     successResponse(res, {
       success: true,
@@ -171,9 +174,12 @@ router.delete(
       });
 
       const socket = SocketManager.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.FUNCTIONS,
-      });
+      socket.broadcastToRoom(
+        'role:project_admin',
+        ServerEvents.DATA_UPDATE,
+        { resource: DataUpdateResourceType.FUNCTIONS },
+        'system'
+      );
 
       successResponse(res, {
         success: true,

package/backend/src/api/routes/metadata/index.routes.ts

@@ -4,6 +4,7 @@ import { AuthService } from '@/services/auth/auth.service.js';
 import { StorageService } from '@/services/storage/storage.service.js';
 import { AIConfigService } from '@/services/ai/ai-config.service.js';
 import { FunctionService } from '@/services/functions/function.service.js';
+import { RealtimeChannelService } from '@/services/realtime/realtime-channel.service.js';
 import { verifyAdmin, AuthRequest } from '@/api/middlewares/auth.js';
 import { successResponse } from '@/utils/response.js';
 import { ERROR_CODES } from '@/types/error-constants.js';
@@ -11,11 +12,13 @@ import { AppError } from '@/api/middlewares/error.js';
 import type { AppMetadataSchema } from '@insforge/shared-schemas';
 import { SecretService } from '@/services/secrets/secret.service.js';
 import { DatabaseManager } from '@/infra/database/database.manager.js';
+import { CloudDatabaseProvider } from '@/providers/database/cloud.provider.js';
 
 const router = Router();
 const authService = AuthService.getInstance();
 const storageService = StorageService.getInstance();
 const functionService = FunctionService.getInstance();
+const realtimeChannelService = RealtimeChannelService.getInstance();
 const dbManager = DatabaseManager.getInstance();
 const dbAdvanceService = DatabaseAdvanceService.getInstance();
 const aiConfigService = AIConfigService.getInstance();
@@ -104,6 +107,16 @@ router.get('/functions', async (_req: AuthRequest, res: Response, next: NextFunc
   }
 });
 
+// Get realtime metadata
+router.get('/realtime', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const realtimeMetadata = await realtimeChannelService.getMetadata();
+    successResponse(res, realtimeMetadata);
+  } catch (error) {
+    next(error);
+  }
+});
+
 // Get API key (admin only)
 router.get('/api-key', async (req: AuthRequest, res: Response, next: NextFunction) => {
   try {
@@ -116,6 +129,31 @@ router.get('/api-key', async (req: AuthRequest, res: Response, next: NextFunctio
   }
 });
 
+// Get database connection string from cloud backend (admin only)
+router.get(
+  '/database-connection-string',
+  async (_req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const cloudDbProvider = CloudDatabaseProvider.getInstance();
+      const connectionInfo = await cloudDbProvider.getDatabaseConnectionString();
+      successResponse(res, connectionInfo);
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+// Get database password from cloud backend (admin only)
+router.get('/database-password', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const cloudDbProvider = CloudDatabaseProvider.getInstance();
+    const passwordInfo = await cloudDbProvider.getDatabasePassword();
+    successResponse(res, passwordInfo);
+  } catch (error) {
+    next(error);
+  }
+});
+
 // get metadata for a table.
 // Notice: must be after endpoint /api-key in case of conflict.
 router.get('/:tableName', async (req: AuthRequest, res: Response, next: NextFunction) => {

package/backend/src/api/routes/realtime/channels.routes.ts

@@ -0,0 +1,81 @@
+import { Router, Response, NextFunction } from 'express';
+import { verifyAdmin, AuthRequest } from '@/api/middlewares/auth.js';
+import { RealtimeChannelService } from '@/services/realtime/realtime-channel.service.js';
+import { successResponse } from '@/utils/response.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { createChannelRequestSchema, updateChannelRequestSchema } from '@insforge/shared-schemas';
+
+const router = Router();
+const channelService = RealtimeChannelService.getInstance();
+
+// List all channels
+router.get('/', verifyAdmin, async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const channels = await channelService.list();
+    successResponse(res, channels);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Get channel by ID
+router.get('/:id', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const channel = await channelService.getById(req.params.id);
+    if (!channel) {
+      throw new AppError('Channel not found', 404, ERROR_CODES.NOT_FOUND);
+    }
+    successResponse(res, channel);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Create a channel
+router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const validation = createChannelRequestSchema.safeParse(req.body);
+    if (!validation.success) {
+      throw new AppError(
+        validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', '),
+        400,
+        ERROR_CODES.INVALID_INPUT
+      );
+    }
+    const channel = await channelService.create(validation.data);
+    successResponse(res, channel, 201);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Update a channel
+router.put('/:id', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const validation = updateChannelRequestSchema.safeParse(req.body);
+    if (!validation.success) {
+      throw new AppError(
+        validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', '),
+        400,
+        ERROR_CODES.INVALID_INPUT
+      );
+    }
+    const channel = await channelService.update(req.params.id, validation.data);
+    successResponse(res, channel);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Delete a channel
+router.delete('/:id', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    await channelService.delete(req.params.id);
+    successResponse(res, { message: 'Channel deleted' });
+  } catch (error) {
+    next(error);
+  }
+});
+
+export { router as channelsRouter };

package/backend/src/api/routes/realtime/index.routes.ts

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import { channelsRouter } from './channels.routes.js';
+import { messagesRouter } from './messages.routes.js';
+import { permissionsRouter } from './permissions.routes.js';
+
+const router = Router();
+
+router.use('/channels', channelsRouter);
+router.use('/messages', messagesRouter);
+router.use('/permissions', permissionsRouter);
+
+export { router as realtimeRouter };

package/backend/src/api/routes/realtime/messages.routes.ts

@@ -0,0 +1,48 @@
+import { Router, Response, NextFunction } from 'express';
+import { verifyAdmin, AuthRequest } from '@/api/middlewares/auth.js';
+import { RealtimeMessageService } from '@/services/realtime/realtime-message.service.js';
+import { successResponse } from '@/utils/response.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { listMessagesRequestSchema, messageStatsRequestSchema } from '@insforge/shared-schemas';
+
+const router = Router();
+const messageService = RealtimeMessageService.getInstance();
+
+// List messages
+router.get('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const validation = listMessagesRequestSchema.safeParse(req.query);
+    if (!validation.success) {
+      throw new AppError(
+        validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', '),
+        400,
+        ERROR_CODES.INVALID_INPUT
+      );
+    }
+    const messages = await messageService.list(validation.data);
+    successResponse(res, messages);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Get message statistics
+router.get('/stats', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const validation = messageStatsRequestSchema.safeParse(req.query);
+    if (!validation.success) {
+      throw new AppError(
+        validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', '),
+        400,
+        ERROR_CODES.INVALID_INPUT
+      );
+    }
+    const stats = await messageService.getStats(validation.data);
+    successResponse(res, stats);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export { router as messagesRouter };