insforge 0.3.3 → 1.3.0

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

@@ -0,0 +1,194 @@
+import { Router, Response, NextFunction } from 'express';
+import { AuthRequest, verifyAdmin } from '@/api/middlewares/auth.js';
+import { FunctionService } from '@/services/functions/function.service.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 logger from '@/utils/logger.js';
+import { functionUploadRequestSchema, functionUpdateRequestSchema } 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';
+
+const router = Router();
+const functionService = FunctionService.getInstance();
+const auditService = AuditService.getInstance();
+
+/**
+ * GET /api/functions
+ * List all edge functions
+ */
+router.get('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const result = await functionService.listFunctions();
+    successResponse(res, result);
+  } catch (error) {
+    logger.error('Failed to list functions', { error });
+    next(new AppError('Failed to list functions', 500, ERROR_CODES.INTERNAL_ERROR));
+  }
+});
+
+/**
+ * GET /api/functions/:slug
+ * Get specific function details including code
+ */
+router.get('/:slug', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { slug } = req.params;
+    const func = await functionService.getFunction(slug);
+
+    if (!func) {
+      throw new AppError('Function not found', 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    successResponse(res, func);
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * POST /api/functions
+ * Create a new function
+ */
+router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const validation = functionUploadRequestSchema.safeParse(req.body);
+    if (!validation.success) {
+      throw new AppError(JSON.stringify(validation.error.issues), 400, ERROR_CODES.INVALID_INPUT);
+    }
+
+    const created = await functionService.createFunction(validation.data);
+
+    // Log audit event
+    logger.info(`Function ${created.name} (${created.slug}) created by ${req.user?.email}`);
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'CREATE_FUNCTION',
+      module: 'FUNCTIONS',
+      details: {
+        functionId: created.id,
+        slug: created.slug,
+        name: created.name,
+        status: created.status,
+      },
+      ip_address: req.ip,
+    });
+
+    const socket = SocketManager.getInstance();
+    socket.broadcastToRoom(
+      'role:project_admin',
+      ServerEvents.DATA_UPDATE,
+      { resource: DataUpdateResourceType.FUNCTIONS },
+      'system'
+    );
+
+    successResponse(
+      res,
+      {
+        success: true,
+        function: created,
+      },
+      201
+    );
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * PUT /api/functions/:slug
+ * Update an existing function
+ */
+router.put('/:slug', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { slug } = req.params;
+    const validation = functionUpdateRequestSchema.safeParse(req.body);
+
+    if (!validation.success) {
+      throw new AppError(JSON.stringify(validation.error.issues), 400, ERROR_CODES.INVALID_INPUT);
+    }
+
+    const updated = await functionService.updateFunction(slug, validation.data);
+
+    if (!updated) {
+      throw new AppError('Function not found', 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    // Log audit event
+    logger.info(`Function ${slug} updated by ${req.user?.email}`);
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'UPDATE_FUNCTION',
+      module: 'FUNCTIONS',
+      details: {
+        slug,
+        changes: validation.data,
+      },
+      ip_address: req.ip,
+    });
+
+    const socket = SocketManager.getInstance();
+    socket.broadcastToRoom(
+      'role:project_admin',
+      ServerEvents.DATA_UPDATE,
+      { resource: DataUpdateResourceType.FUNCTIONS, data: { slug } },
+      'system'
+    );
+
+    successResponse(res, {
+      success: true,
+      function: updated,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * DELETE /api/functions/:slug
+ * Delete a function
+ */
+router.delete(
+  '/:slug',
+  verifyAdmin,
+  async (req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const { slug } = req.params;
+      const deleted = await functionService.deleteFunction(slug);
+
+      if (!deleted) {
+        throw new AppError('Function not found', 404, ERROR_CODES.NOT_FOUND);
+      }
+
+      // Log audit event
+      logger.info(`Function ${slug} deleted by ${req.user?.email}`);
+      await auditService.log({
+        actor: req.user?.email || 'api-key',
+        action: 'DELETE_FUNCTION',
+        module: 'FUNCTIONS',
+        details: {
+          slug,
+        },
+        ip_address: req.ip,
+      });
+
+      const socket = SocketManager.getInstance();
+      socket.broadcastToRoom(
+        'role:project_admin',
+        ServerEvents.DATA_UPDATE,
+        { resource: DataUpdateResourceType.FUNCTIONS },
+        'system'
+      );
+
+      successResponse(res, {
+        success: true,
+        message: `Function ${slug} deleted successfully`,
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+);
+
+export default router;

package/backend/src/api/routes/{logs.ts → logs/index.routes.ts}

@@ -1,9 +1,11 @@
 import { Router, Response, NextFunction } from 'express';
-import { AnalyticsManager } from '@/core/logs/analytics.js';
-import { AuditService } from '@/core/logs/audit.js';
-import { AuthRequest, verifyAdmin } from '@/api/middleware/auth.js';
+import { LogService } from '@/services/logs/log.service.js';
+import { AuditService } from '@/services/logs/audit.service.js';
+import { AuthRequest, verifyAdmin } from '@/api/middlewares/auth.js';
 import { successResponse, paginatedResponse } from '@/utils/response.js';
-import { AnalyticsLogResponse } from '@/types/logs.js';
+import { GetLogsResponse } from '@insforge/shared-schemas';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
 
 const router = Router();
 
@@ -68,12 +70,12 @@ router.delete('/audits', async (req: AuthRequest, res: Response, next: NextFunct
   }
 });
 
-// Analytics logs routes
-// GET /logs/analytics/sources - List all log sources
-router.get('/analytics/sources', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+// System logs routes
+// GET /logs/sources - List all log sources
+router.get('/sources', async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const analyticsManager = AnalyticsManager.getInstance();
-    const sources = await analyticsManager.getLogSources();
+    const logService = LogService.getInstance();
+    const sources = await logService.getLogSources();
 
     successResponse(res, sources);
   } catch (error) {
@@ -81,11 +83,11 @@ router.get('/analytics/sources', async (_req: AuthRequest, res: Response, next:
   }
 });
 
-// GET /logs/analytics/stats - Get statistics for all log sources
-router.get('/analytics/stats', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+// GET /logs/stats - Get statistics for all log sources
+router.get('/stats', async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const analyticsManager = AnalyticsManager.getInstance();
-    const stats = await analyticsManager.getLogSourceStats();
+    const logService = LogService.getInstance();
+    const stats = await logService.getLogSourceStats();
 
     successResponse(res, stats);
   } catch (error) {
@@ -93,21 +95,17 @@ router.get('/analytics/stats', async (_req: AuthRequest, res: Response, next: Ne
   }
 });
 
-// GET /logs/analytics/search - Search across all logs or specific source
-router.get('/analytics/search', async (req: AuthRequest, res: Response, next: NextFunction) => {
+// GET /logs/search - Search across all logs or specific source
+router.get('/search', async (req: AuthRequest, res: Response, next: NextFunction) => {
   try {
     const { q, source, limit = 100, offset = 0 } = req.query;
 
     if (!q || typeof q !== 'string') {
-      return res.status(400).json({
-        error: 'MISSING_QUERY',
-        message: 'Search query parameter (q) is required',
-        statusCode: 400,
-      });
+      throw new AppError('Search query parameter (q) is required', 400, ERROR_CODES.INVALID_INPUT);
     }
 
-    const analyticsManager = AnalyticsManager.getInstance();
-    const result = await analyticsManager.searchLogs(
+    const logService = LogService.getInstance();
+    const result = await logService.searchLogs(
       q,
       source as string | undefined,
       Number(limit),
@@ -120,25 +118,22 @@ router.get('/analytics/search', async (req: AuthRequest, res: Response, next: Ne
   }
 });
 
-// GET /logs/analytics/:source - Get logs from specific source
-router.get('/analytics/:source', async (req: AuthRequest, res: Response, next: NextFunction) => {
+// GET /logs/:source - Get logs from specific source
+router.get('/:source', async (req: AuthRequest, res: Response, next: NextFunction) => {
   try {
     const { source } = req.params;
     const { limit = 100, before_timestamp } = req.query;
 
-    const analyticsManager = AnalyticsManager.getInstance();
-    const result = await analyticsManager.getLogsBySource(
+    const logService = LogService.getInstance();
+    const result = await logService.getLogsBySource(
       source,
       Number(limit),
       before_timestamp as string | undefined
     );
 
-    const response: AnalyticsLogResponse = {
-      source,
+    const response: GetLogsResponse = {
       logs: result.logs,
       total: result.total,
-      page: 1, // Not applicable for timestamp-based pagination
-      pageSize: Number(limit),
     };
 
     successResponse(res, response);

package/backend/src/api/routes/{metadata.ts → metadata/index.routes.ts}

@@ -1,21 +1,26 @@
 import { Router, Response, NextFunction } from 'express';
-import { DatabaseAdvanceService } from '@/core/database/advance.js';
-import { AuthService } from '@/core/auth/auth.js';
-import { StorageService } from '@/core/storage/storage.js';
-import { AIConfigService } from '@/core/ai/config.js';
-import { FunctionsService } from '@/core/functions/functions.js';
-import { SocketService } from '@/core/socket/socket.js';
-import { verifyAdmin, AuthRequest } from '@/api/middleware/auth.js';
+import { DatabaseAdvanceService } from '@/services/database/database-advance.service.js';
+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 { ServerEvents } from '@/core/socket/types';
 import { ERROR_CODES } from '@/types/error-constants.js';
-import { AppError } from '@/api/middleware/error.js';
+import { AppError } from '@/api/middlewares/error.js';
 import type { AppMetadataSchema } from '@insforge/shared-schemas';
-import { SecretsService } from '@/core/secrets/secrets';
+import { SecretService } from '@/services/secrets/secret.service.js';
+import { DatabaseManager } from '@/infra/database/database.manager.js';
 
 const router = Router();
-const dbAdvanceService = new DatabaseAdvanceService();
-const aiConfigService = new AIConfigService();
+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();
 
 router.use(verifyAdmin);
 
@@ -23,17 +28,14 @@ router.use(verifyAdmin);
 router.get('/', async (req: AuthRequest, res: Response, next: NextFunction) => {
   try {
     // Gather metadata from all modules
-    const authService = AuthService.getInstance();
-    const storageService = StorageService.getInstance();
-    const functionsService = FunctionsService.getInstance();
 
     // Fetch all metadata in parallel for better performance
     const [auth, database, storage, aiConfig, functions] = await Promise.all([
       authService.getMetadata(),
-      dbAdvanceService.getMetadata(),
+      dbManager.getMetadata(),
       storageService.getMetadata(),
       aiConfigService.getMetadata(),
-      functionsService.getMetadata(),
+      functionService.getMetadata(),
     ]);
 
     // Get version from package.json or default
@@ -48,13 +50,6 @@ router.get('/', async (req: AuthRequest, res: Response, next: NextFunction) => {
       version,
     };
 
-    // Trigger Socket.IO event to notify frontend that MCP is connected
-    if (req.query.mcp === 'true') {
-      const socketService = SocketService.getInstance();
-      //Lyu note: this is triggered everytime when a mcp calls get-metadata. Do we have a better solution for this?
-      socketService.broadcastToRoom('role:project_admin', ServerEvents.MCP_CONNECTED);
-    }
-
     successResponse(res, metadata);
   } catch (error) {
     next(error);
@@ -64,7 +59,6 @@ router.get('/', async (req: AuthRequest, res: Response, next: NextFunction) => {
 // Get auth metadata
 router.get('/auth', async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const authService = AuthService.getInstance();
     const authMetadata = await authService.getMetadata();
     successResponse(res, authMetadata);
   } catch (error) {
@@ -75,7 +69,7 @@ router.get('/auth', async (_req: AuthRequest, res: Response, next: NextFunction)
 // Get database metadata
 router.get('/database', async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const databaseMetadata = await dbAdvanceService.getMetadata();
+    const databaseMetadata = await dbManager.getMetadata();
     successResponse(res, databaseMetadata);
   } catch (error) {
     next(error);
@@ -85,7 +79,6 @@ router.get('/database', async (_req: AuthRequest, res: Response, next: NextFunct
 // Get storage metadata
 router.get('/storage', async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const storageService = StorageService.getInstance();
     const storageMetadata = await storageService.getMetadata();
     successResponse(res, storageMetadata);
   } catch (error) {
@@ -106,19 +99,28 @@ router.get('/ai', async (_req: AuthRequest, res: Response, next: NextFunction) =
 // Get functions metadata
 router.get('/functions', async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
-    const functionsService = FunctionsService.getInstance();
-    const functionsMetadata = await functionsService.getMetadata();
+    const functionsMetadata = await functionService.getMetadata();
     successResponse(res, functionsMetadata);
   } catch (error) {
     next(error);
   }
 });
 
+// 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 {
-    const sercretService = new SecretsService();
-    const apiKey = await sercretService.getSecretByKey('API_KEY');
+    const secretService = SecretService.getInstance();
+    const apiKey = await secretService.getSecretByKey('API_KEY');
 
     successResponse(res, { apiKey: apiKey });
   } catch (error) {

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 };

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

@@ -0,0 +1,19 @@
+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';
+
+const router = Router();
+const channelService = RealtimeChannelService.getInstance();
+
+// Get realtime RLS permissions (subscribe on channels, publish on messages)
+router.get('/', verifyAdmin, async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const permissions = await channelService.getPermissions();
+    successResponse(res, permissions);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export { router as permissionsRouter };