insforge 0.3.1

package/backend/src/api/routes/logs.ts

@@ -0,0 +1,150 @@
+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 { successResponse, paginatedResponse } from '@/utils/response.js';
+import { AnalyticsLogResponse } from '@/types/logs.js';
+
+const router = Router();
+
+// All logs routes require admin authentication
+router.use(verifyAdmin);
+
+// GET /logs/audits - List audit logs
+router.get('/audits', async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { limit = 100, offset = 0, actor, action, module, start_date, end_date } = req.query;
+
+    const auditService = AuditService.getInstance();
+
+    // Build query parameters for audit service
+    const queryParams = {
+      limit: Number(limit),
+      offset: Number(offset),
+      ...(actor && typeof actor === 'string' && { actor }),
+      ...(action && typeof action === 'string' && { action }),
+      ...(module && typeof module === 'string' && { module }),
+      ...(start_date && typeof start_date === 'string' && { start_date: new Date(start_date) }),
+      ...(end_date && typeof end_date === 'string' && { end_date: new Date(end_date) }),
+    };
+
+    // Get audit logs with total count
+    const { records, total } = await auditService.query(queryParams);
+
+    paginatedResponse(res, records, total, Number(offset));
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /logs/audits/stats - Get audit logs statistics
+router.get('/audits/stats', async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { days = 7 } = req.query;
+
+    const auditService = AuditService.getInstance();
+    const stats = await auditService.getStats(Number(days));
+
+    successResponse(res, stats);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// DELETE /logs/audits - Clear audit logs (admin only)
+router.delete('/audits', async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { days_to_keep = 90 } = req.query;
+
+    const auditService = AuditService.getInstance();
+    const deletedCount = await auditService.cleanup(Number(days_to_keep));
+
+    successResponse(res, {
+      message: 'Audit logs cleared successfully',
+      deleted: deletedCount,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Analytics logs routes
+// GET /logs/analytics/sources - List all log sources
+router.get('/analytics/sources', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const analyticsManager = AnalyticsManager.getInstance();
+    const sources = await analyticsManager.getLogSources();
+
+    successResponse(res, sources);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /logs/analytics/stats - Get statistics for all log sources
+router.get('/analytics/stats', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const analyticsManager = AnalyticsManager.getInstance();
+    const stats = await analyticsManager.getLogSourceStats();
+
+    successResponse(res, stats);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /logs/analytics/search - Search across all logs or specific source
+router.get('/analytics/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,
+      });
+    }
+
+    const analyticsManager = AnalyticsManager.getInstance();
+    const result = await analyticsManager.searchLogs(
+      q,
+      source as string | undefined,
+      Number(limit),
+      Number(offset)
+    );
+
+    paginatedResponse(res, result.logs, result.total, Number(offset));
+  } catch (error) {
+    next(error);
+  }
+});
+
+// GET /logs/analytics/:source - Get logs from specific source
+router.get('/analytics/: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(
+      source,
+      Number(limit),
+      before_timestamp as string | undefined
+    );
+
+    const response: AnalyticsLogResponse = {
+      source,
+      logs: result.logs,
+      total: result.total,
+      page: 1, // Not applicable for timestamp-based pagination
+      pageSize: Number(limit),
+    };
+
+    successResponse(res, response);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export { router as logsRouter };

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

@@ -0,0 +1,160 @@
+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 { 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 type { AppMetadataSchema } from '@insforge/shared-schemas';
+import { SecretsService } from '@/core/secrets/secrets';
+
+const router = Router();
+const dbAdvanceService = new DatabaseAdvanceService();
+const aiConfigService = new AIConfigService();
+
+router.use(verifyAdmin);
+
+// Get full metadata (default endpoint)
+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(),
+      storageService.getMetadata(),
+      aiConfigService.getMetadata(),
+      functionsService.getMetadata(),
+    ]);
+
+    // Get version from package.json or default
+    const version = process.env.npm_package_version || '1.0.0';
+
+    const metadata: AppMetadataSchema = {
+      auth,
+      database,
+      storage,
+      functions,
+      aiIntegration: aiConfig,
+      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);
+  }
+});
+
+// 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) {
+    next(error);
+  }
+});
+
+// Get database metadata
+router.get('/database', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const databaseMetadata = await dbAdvanceService.getMetadata();
+    successResponse(res, databaseMetadata);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// 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) {
+    next(error);
+  }
+});
+
+// Get AI metadata
+router.get('/ai', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const aiMetadata = await aiConfigService.getMetadata();
+    successResponse(res, aiMetadata);
+  } catch (error) {
+    next(error);
+  }
+});
+
+// Get functions metadata
+router.get('/functions', async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const functionsService = FunctionsService.getInstance();
+    const functionsMetadata = await functionsService.getMetadata();
+    successResponse(res, functionsMetadata);
+  } 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');
+
+    successResponse(res, { apiKey: apiKey });
+  } 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) => {
+  try {
+    const { tableName } = req.params;
+    if (!tableName) {
+      throw new AppError('Table name is required', 400, ERROR_CODES.INVALID_INPUT);
+    }
+
+    const includeData = false;
+    const includeFunctions = false;
+    const includeSequences = false;
+    const includeViews = false;
+    const schemaResponse = await dbAdvanceService.exportDatabase(
+      [tableName],
+      'json',
+      includeData,
+      includeFunctions,
+      includeSequences,
+      includeViews
+    );
+
+    // When format is 'json', the data contains the tables object
+    const jsonData = schemaResponse.data as { tables: Record<string, unknown> };
+    const metadata = jsonData.tables;
+    successResponse(res, metadata);
+  } catch (error) {
+    next(error);
+  }
+});
+
+export { router as metadataRouter };

package/backend/src/api/routes/openapi.ts

@@ -0,0 +1,82 @@
+import { Router, Request, Response } from 'express';
+import { OpenAPIService } from '@/core/documentation/openapi.js';
+import { AppError } from '@/api/middleware/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { successResponse } from '@/utils/response.js';
+import logger from '@/utils/logger.js';
+
+const router = Router();
+const openAPIService = OpenAPIService.getInstance();
+
+/**
+ * GET /api/openapi
+ * Get the OpenAPI specification document
+ */
+router.get('/', async (_req: Request, res: Response, next) => {
+  try {
+    const openAPIDocument = await openAPIService.generateOpenAPIDocument();
+    successResponse(res, openAPIDocument);
+  } catch (error) {
+    logger.error('Failed to generate OpenAPI document', {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    next(new AppError('Failed to generate OpenAPI document', 500, ERROR_CODES.INTERNAL_ERROR));
+  }
+});
+
+/**
+ * GET /api/openapi/swagger
+ * Serve Swagger UI HTML page
+ */
+router.get('/swagger', (_req: Request, res: Response) => {
+  const html = `
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>InsForge API Documentation</title>
+      <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css" />
+      <style>
+        body {
+          margin: 0;
+          padding: 0;
+        }
+        .swagger-ui .topbar {
+          display: none;
+        }
+      </style>
+    </head>
+    <body>
+      <div id="swagger-ui"></div>
+      <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+      <script>
+        window.onload = () => {
+          window.ui = SwaggerUIBundle({
+            url: '/api/openapi',
+            dom_id: '#swagger-ui',
+            deepLinking: true,
+            presets: [
+              SwaggerUIBundle.presets.apis,
+              SwaggerUIBundle.SwaggerUIStandalonePreset
+            ],
+            layout: 'BaseLayout',
+            tryItOutEnabled: true,
+            requestInterceptor: (request) => {
+              // Add API key from localStorage if available
+              const apiKey = localStorage.getItem('insforge_api_key');
+              if (apiKey) {
+                request.headers['x-api-key'] = apiKey;
+              }
+              return request;
+            }
+          });
+        };
+      </script>
+    </body>
+    </html>
+  `;
+  res.type('html').send(html);
+});
+
+export { router as openAPIRouter };

package/backend/src/api/routes/secrets.ts

@@ -0,0 +1,199 @@
+import { Router, Response, NextFunction } from 'express';
+import { SecretsService } from '@/core/secrets/secrets.js';
+import { verifyAdmin, AuthRequest } from '@/api/middleware/auth.js';
+import { AuditService } from '@/core/logs/audit.js';
+import { AppError } from '@/api/middleware/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+
+const router = Router();
+const secretsService = new SecretsService();
+const auditService = AuditService.getInstance();
+
+/**
+ * List all secrets (metadata only, no values)
+ * GET /api/secrets
+ */
+router.get('/', verifyAdmin, async (_req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const secrets = await secretsService.listSecrets();
+    res.json({ secrets });
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Get a specific secret value by key
+ * GET /api/secrets/:key
+ */
+router.get('/:key', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { key } = req.params;
+    const value = await secretsService.getSecretByKey(key);
+
+    if (value === null) {
+      throw new AppError(`Secret not found: ${key}`, 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    // Log audit
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'GET_SECRET',
+      module: 'SECRETS',
+      details: { key },
+      ip_address: req.ip,
+    });
+
+    res.json({ key, value });
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Create a new secret
+ * POST /api/secrets
+ */
+router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { key, value, isReserved, expiresAt } = req.body;
+
+    // Validate input
+    if (!key || !value) {
+      throw new AppError('Both key and value are required', 400, ERROR_CODES.INVALID_INPUT);
+    }
+
+    // Validate key format (uppercase alphanumeric with underscores only)
+    if (!/^[A-Z0-9_]+$/.test(key)) {
+      throw new AppError(
+        'Invalid key format. Use uppercase letters, numbers, and underscores only (e.g., STRIPE_API_KEY)',
+        400,
+        ERROR_CODES.INVALID_INPUT
+      );
+    }
+
+    // Check if secret already exists
+    const existing = await secretsService.getSecretByKey(key);
+    if (existing !== null) {
+      throw new AppError(`Secret already exists: ${key}`, 409, ERROR_CODES.INVALID_INPUT);
+    }
+
+    const result = await secretsService.createSecret({
+      key,
+      value,
+      isReserved: isReserved || false,
+      expiresAt: expiresAt ? new Date(expiresAt) : undefined,
+    });
+
+    // Log audit
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'CREATE_SECRET',
+      module: 'SECRETS',
+      details: { key, id: result.id },
+      ip_address: req.ip,
+    });
+
+    res.status(201).json({
+      success: true,
+      message: `Secret ${key} has been created successfully`,
+      id: result.id,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Update an existing secret
+ * PUT /api/secrets/:key
+ */
+router.put('/:key', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { key } = req.params;
+    const { value, isActive, isReserved, expiresAt } = req.body;
+
+    // Get existing secret
+    const secrets = await secretsService.listSecrets();
+    const secret = secrets.find((s) => s.key === key);
+
+    if (!secret) {
+      throw new AppError(`Secret not found: ${key}`, 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    const success = await secretsService.updateSecret(secret.id, {
+      value,
+      isActive,
+      isReserved,
+      expiresAt: expiresAt !== undefined ? (expiresAt ? new Date(expiresAt) : null) : undefined,
+    });
+
+    if (!success) {
+      throw new AppError(`Failed to update secret: ${key}`, 500, ERROR_CODES.INTERNAL_ERROR);
+    }
+
+    // Log audit
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'UPDATE_SECRET',
+      module: 'SECRETS',
+      details: { key, updates: { hasNewValue: !!value, isActive, isReserved, expiresAt } },
+      ip_address: req.ip,
+    });
+
+    res.json({
+      success: true,
+      message: `Secret ${key} has been updated successfully`,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+/**
+ * Delete a secret (mark as inactive)
+ * DELETE /api/secrets/:key
+ */
+router.delete('/:key', verifyAdmin, async (req: AuthRequest, res: Response, next: NextFunction) => {
+  try {
+    const { key } = req.params;
+
+    // Get existing secret
+    const secrets = await secretsService.listSecrets();
+    const secret = secrets.find((s) => s.key === key);
+
+    if (!secret) {
+      throw new AppError(`Secret not found: ${key}`, 404, ERROR_CODES.NOT_FOUND);
+    }
+
+    // Check if secret is reserved
+    if (secret.isReserved) {
+      throw new AppError(`Cannot delete reserved secret: ${key}`, 403, ERROR_CODES.FORBIDDEN);
+    }
+
+    // Mark as inactive instead of hard delete
+    const success = await secretsService.updateSecret(secret.id, { isActive: false });
+
+    if (!success) {
+      throw new AppError(`Failed to delete secret: ${key}`, 500, ERROR_CODES.INTERNAL_ERROR);
+    }
+
+    // Log audit
+    await auditService.log({
+      actor: req.user?.email || 'api-key',
+      action: 'DELETE_SECRET',
+      module: 'SECRETS',
+      details: { key },
+      ip_address: req.ip,
+    });
+
+    res.json({
+      success: true,
+      message: `Secret ${key} has been deleted successfully`,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;