insforge 1.2.10 → 1.4.8

package/backend/src/api/routes/database/advance.routes.ts

@@ -15,6 +15,7 @@ import logger from '@/utils/logger.js';
 import { SocketManager } from '@/infra/socket/socket.manager.js';
 import { DataUpdateResourceType, ServerEvents } from '@/types/socket.js';
 import { successResponse } from '@/utils/response.js';
+import { analyzeQuery, DatabaseResourceUpdate } from '@/utils/sql-parser.js';
 
 const router = Router();
 const dbAdvanceService = DatabaseAdvanceService.getInstance();
@@ -64,10 +65,17 @@ router.post(
         ip_address: req.ip,
       });
 
-      const socket = SocketManager.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.DATABASE,
-      });
+      // Broadcast changes if any modifying statements detected
+      const changes = analyzeQuery(query);
+      if (changes.length > 0) {
+        const socket = SocketManager.getInstance();
+        socket.broadcastToRoom(
+          'role:project_admin',
+          ServerEvents.DATA_UPDATE,
+          { resource: DataUpdateResourceType.DATABASE, data: { changes } },
+          'system'
+        );
+      }
 
       successResponse(res, response);
     } catch (error: unknown) {
@@ -115,10 +123,17 @@ router.post('/rawsql', verifyAdmin, async (req: AuthRequest, res: Response, next
       ip_address: req.ip,
     });
 
-    const socket = SocketManager.getInstance();
-    socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-      resource: DataUpdateResourceType.DATABASE,
-    });
+    // Broadcast changes if any modifying statements detected
+    const changes = analyzeQuery(query);
+    if (changes.length > 0) {
+      const socket = SocketManager.getInstance();
+      socket.broadcastToRoom(
+        'role:project_admin',
+        ServerEvents.DATA_UPDATE,
+        { resource: DataUpdateResourceType.DATABASE, data: { changes } },
+        'system'
+      );
+    }
 
     successResponse(res, response);
   } catch (error: unknown) {
@@ -235,12 +250,15 @@ router.post(
       });
 
       const socket = SocketManager.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.RECORDS,
-        data: {
-          tableName: table,
+      socket.broadcastToRoom(
+        'role:project_admin',
+        ServerEvents.DATA_UPDATE,
+        {
+          resource: DataUpdateResourceType.DATABASE,
+          data: { changes: [{ type: 'records', name: table }] as DatabaseResourceUpdate[] },
         },
-      });
+        'system'
+      );
 
       successResponse(res, response);
     } catch (error: unknown) {
@@ -302,9 +320,12 @@ router.post(
       });
 
       const socket = SocketManager.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.DATABASE,
-      });
+      socket.broadcastToRoom(
+        'role:project_admin',
+        ServerEvents.DATA_UPDATE,
+        { resource: DataUpdateResourceType.DATABASE },
+        'system'
+      );
 
       successResponse(res, response);
     } catch (error: unknown) {

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

@@ -1,13 +1,92 @@
-import { Router } from 'express';
+import { Router, Response, NextFunction } from 'express';
 import { databaseTablesRouter } from './tables.routes.js';
 import { databaseRecordsRouter } from './records.routes.js';
+import { databaseRpcRouter } from './rpc.routes.js';
 import databaseAdvanceRouter from './advance.routes.js';
+import { DatabaseService } from '@/services/database/database.service.js';
+import { verifyAdmin, AuthRequest } from '@/api/middlewares/auth.js';
+import { successResponse } from '@/utils/response.js';
+import logger from '@/utils/logger.js';
 
 const router = Router();
+const databaseService = DatabaseService.getInstance();
 
 // Mount database sub-routes
 router.use('/tables', databaseTablesRouter);
 router.use('/records', databaseRecordsRouter);
+router.use('/rpc', databaseRpcRouter);
 router.use('/advance', databaseAdvanceRouter);
 
+/**
+ * Get all database functions
+ * GET /api/database/functions
+ */
+router.get(
+  '/functions',
+  verifyAdmin,
+  async (_req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const response = await databaseService.getFunctions();
+      successResponse(res, response);
+    } catch (error: unknown) {
+      logger.warn('Get functions error:', error);
+      next(error);
+    }
+  }
+);
+
+/**
+ * Get all database indexes
+ * GET /api/database/indexes
+ */
+router.get(
+  '/indexes',
+  verifyAdmin,
+  async (_req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const response = await databaseService.getIndexes();
+      successResponse(res, response);
+    } catch (error: unknown) {
+      logger.warn('Get indexes error:', error);
+      next(error);
+    }
+  }
+);
+
+/**
+ * Get all RLS policies
+ * GET /api/database/policies
+ */
+router.get(
+  '/policies',
+  verifyAdmin,
+  async (_req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const response = await databaseService.getPolicies();
+      successResponse(res, response);
+    } catch (error: unknown) {
+      logger.warn('Get policies error:', error);
+      next(error);
+    }
+  }
+);
+
+/**
+ * Get all database triggers
+ * GET /api/database/triggers
+ */
+router.get(
+  '/triggers',
+  verifyAdmin,
+  async (_req: AuthRequest, res: Response, next: NextFunction) => {
+    try {
+      const response = await databaseService.getTriggers();
+      successResponse(res, response);
+    } catch (error: unknown) {
+      logger.warn('Get triggers error:', error);
+      next(error);
+    }
+  }
+);
+
 export default router;

package/backend/src/api/routes/database/records.routes.ts

@@ -1,83 +1,41 @@
 import { Router, Response, NextFunction } from 'express';
 import axios from 'axios';
-import http from 'http';
-import https from 'https';
 import { AuthRequest, extractApiKey } from '@/api/middlewares/auth.js';
 import { DatabaseManager } from '@/infra/database/database.manager.js';
-import { TokenManager } from '@/infra/security/token.manager.js';
 import { AppError } from '@/api/middlewares/error.js';
 import { ERROR_CODES } from '@/types/error-constants.js';
 import { validateTableName } from '@/utils/validations.js';
 import { DatabaseRecord } from '@/types/database.js';
 import { successResponse } from '@/utils/response.js';
-import logger from '@/utils/logger.js';
-import { SecretService } from '@/services/secrets/secret.service.js';
 import { SocketManager } from '@/infra/socket/socket.manager.js';
 import { DataUpdateResourceType, ServerEvents } from '@/types/socket.js';
+import { DatabaseResourceUpdate } from '@/utils/sql-parser.js';
+import { PostgrestProxyService } from '@/services/database/postgrest-proxy.service.js';
 
 const router = Router();
-const secretService = SecretService.getInstance();
-const postgrestUrl = process.env.POSTGREST_BASE_URL || 'http://localhost:5430';
+const proxyService = PostgrestProxyService.getInstance();
 
-// Create a dedicated HTTP agent with connection pooling for PostgREST
-// Optimized connection pool for Docker network communication
-const httpAgent = new http.Agent({
-  keepAlive: true,
-  keepAliveMsecs: 5000, // Shorter for Docker network
-  maxSockets: 20, // Reduced for stability
-  maxFreeSockets: 5,
-  timeout: 10000, // Match axios timeout
-});
-
-const httpsAgent = new https.Agent({
-  keepAlive: true,
-  keepAliveMsecs: 5000,
-  maxSockets: 20,
-  maxFreeSockets: 5,
-  timeout: 10000,
-});
-
-// Create axios instance with optimized configuration for PostgREST
-const postgrestAxios = axios.create({
-  httpAgent,
-  httpsAgent,
-  timeout: 10000, // Increased timeout for stability
-  maxRedirects: 0,
-  // Additional connection stability options
-  headers: {
-    Connection: 'keep-alive',
-    'Keep-Alive': 'timeout=5, max=10',
-  },
-});
-
-// Generate admin token once and reuse
-// If user request with api key, this token should be added automatically.
-const tokenManager = TokenManager.getInstance();
-const adminToken = tokenManager.generateToken({
-  sub: 'project-admin-with-api-key',
-  email: 'project-admin@email.com',
-  role: 'project_admin',
-});
-
-// anonymous users can access the database, postgREST does not require authentication, however we seed to unwrap session token for better auth, thus
-// we need to verify user token below.
-// router.use(verifyUserOrApiKey);
+/**
+ * Helper to handle PostgREST proxy errors
+ */
+function handleProxyError(error: unknown, res: Response, next: NextFunction) {
+  if (axios.isAxiosError(error) && error.response) {
+    res.status(error.response.status).json(error.response.data);
+  } else {
+    next(error);
+  }
+}
 
 /**
- * Forward database requests to PostgREST
+ * Forward database table requests to PostgREST
  */
 const forwardToPostgrest = async (req: AuthRequest, res: Response, next: NextFunction) => {
   const { tableName } = req.params;
   const wildcardPath = req.params[0] || '';
-
-  // Build the target URL early so it's available in error handling
-  const targetPath = wildcardPath ? `/${tableName}/${wildcardPath}` : `/${tableName}`;
-  const targetUrl = `${postgrestUrl}${targetPath}`;
+  const path = wildcardPath ? `/${tableName}/${wildcardPath}` : `/${tableName}`;
 
   try {
-    // Validate table name with operation type
-    const method = req.method.toUpperCase();
-
+    // Validate table name
     try {
       validateTableName(tableName);
     } catch (error) {
@@ -87,11 +45,14 @@ const forwardToPostgrest = async (req: AuthRequest, res: Response, next: NextFun
       throw new AppError('Invalid table name', 400, ERROR_CODES.INVALID_INPUT);
     }
 
-    // Process request body for POST/PATCH/PUT operations
-    if (['POST', 'PATCH', 'PUT'].includes(method) && req.body && typeof req.body === 'object') {
+    // Process request body for POST/PATCH/PUT (filter empty values based on column types)
+    const method = req.method.toUpperCase();
+    let body = req.body;
+
+    if (['POST', 'PATCH', 'PUT'].includes(method) && body && typeof body === 'object') {
       const columnTypeMap = await DatabaseManager.getColumnTypeMap(tableName);
-      if (Array.isArray(req.body)) {
-        req.body = req.body.map((item) => {
+      if (Array.isArray(body)) {
+        body = body.map((item) => {
           if (item && typeof item === 'object') {
             const filtered: DatabaseRecord = {};
             for (const key in item) {
@@ -105,7 +66,6 @@ const forwardToPostgrest = async (req: AuthRequest, res: Response, next: NextFun
           return item;
         });
       } else {
-        const body = req.body as DatabaseRecord;
         for (const key in body) {
           if (columnTypeMap[key] === 'uuid' && body[key] === '') {
             delete body[key];
@@ -114,142 +74,46 @@ const forwardToPostgrest = async (req: AuthRequest, res: Response, next: NextFun
       }
     }
 
-    // Forward the request
-    const axiosConfig: {
-      method: string;
-      url: string;
-      params: unknown;
-      headers: Record<string, string | string[] | undefined>;
-      data?: unknown;
-    } = {
+    // Forward to PostgREST via service
+    const result = await proxyService.forward({
       method: req.method,
-      url: targetUrl,
-      params: req.query,
-      headers: {
-        ...req.headers,
-        host: undefined, // Remove host header
-        'content-length': undefined, // Let axios calculate
-      },
-    };
-
-    // Check for API key using shared logic
-    const apiKey = extractApiKey(req);
-
-    // If we have an API key, verify it and use admin token for PostgREST
-    if (apiKey) {
-      const isValid = await secretService.verifyApiKey(apiKey);
-      if (isValid) {
-        axiosConfig.headers.authorization = `Bearer ${adminToken}`;
-      }
-    }
-
-    // Add body for methods that support it
-    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
-      axiosConfig.data = req.body;
-    }
-
-    // Enhanced retry logic with improved error handling
-    let response;
-    let lastError;
-    const maxRetries = 3; // Increased retries for connection resets
-
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        response = await postgrestAxios(axiosConfig);
-        break; // Success, exit retry loop
-      } catch (error) {
-        lastError = error;
-
-        // Retry on network errors (ECONNRESET, ECONNREFUSED, timeout) but not HTTP errors
-        const shouldRetry = axios.isAxiosError(error) && !error.response && attempt < maxRetries;
-
-        if (shouldRetry) {
-          logger.warn(`PostgREST request failed, retrying (attempt ${attempt}/${maxRetries})`, {
-            url: targetUrl,
-            errorCode: error.code,
-            message: error.message,
-          });
-
-          // Enhanced exponential backoff: 200ms, 500ms, 1000ms
-          const backoffDelay = Math.min(200 * Math.pow(2.5, attempt - 1), 1000);
-          await new Promise((resolve) => setTimeout(resolve, backoffDelay));
-        } else {
-          throw error; // Don't retry on HTTP errors or last attempt
-        }
-      }
-    }
-
-    if (!response) {
-      throw lastError || new Error('Failed to get response from PostgREST');
-    }
+      path,
+      query: req.query as Record<string, unknown>,
+      headers: req.headers as Record<string, string | string[] | undefined>,
+      body: ['POST', 'PUT', 'PATCH'].includes(req.method) ? body : undefined,
+      apiKey: extractApiKey(req) ?? undefined,
+    });
 
     // Forward response headers
-    Object.entries(response.headers).forEach(([key, value]) => {
-      const keyLower = key.toLowerCase();
-      if (
-        keyLower !== 'content-length' &&
-        keyLower !== 'transfer-encoding' &&
-        keyLower !== 'connection' &&
-        keyLower !== 'content-encoding'
-      ) {
-        res.setHeader(key, value);
-      }
-    });
+    const headers = PostgrestProxyService.filterHeaders(result.headers);
+    Object.entries(headers).forEach(([key, value]) => res.setHeader(key, value));
 
     // Handle empty responses
-    let responseData = response.data;
+    let responseData = result.data;
     if (
-      response.data === undefined ||
-      (typeof response.data === 'string' && response.data.trim() === '')
+      result.data === undefined ||
+      (typeof result.data === 'string' && result.data.trim() === '')
     ) {
       responseData = [];
     }
 
-    // Only send socket events for mutations (POST, DELETE)
-    const mutationMethods = ['POST', 'DELETE'];
-    if (mutationMethods.includes(req.method.toUpperCase())) {
+    // Broadcast socket events for mutations
+    if (['POST', 'DELETE'].includes(method)) {
       const socket = SocketManager.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.RECORDS,
-        data: {
-          tableName: tableName,
+      socket.broadcastToRoom(
+        'role:project_admin',
+        ServerEvents.DATA_UPDATE,
+        {
+          resource: DataUpdateResourceType.DATABASE,
+          data: { changes: [{ type: 'records', name: tableName }] as DatabaseResourceUpdate[] },
         },
-      });
+        'system'
+      );
     }
 
-    successResponse(res, responseData, response.status);
+    successResponse(res, responseData, result.status);
   } catch (error) {
-    if (axios.isAxiosError(error)) {
-      // Log more detailed error information
-      logger.error('PostgREST request failed', {
-        url: targetUrl,
-        method: req.method,
-        error: {
-          code: error.code,
-          message: error.message,
-          response: error.response?.data,
-          responseStatus: error.response?.status,
-        },
-      });
-
-      // Forward PostgREST errors
-      if (error.response) {
-        res.status(error.response.status).json(error.response.data);
-      } else {
-        // Network error - connection refused, DNS failure, etc.
-        const errorMessage =
-          error.code === 'ECONNREFUSED'
-            ? 'PostgREST connection refused'
-            : error.code === 'ENOTFOUND'
-              ? 'PostgREST service not found'
-              : 'Database service unavailable';
-
-        next(new AppError(errorMessage, 503, ERROR_CODES.INTERNAL_ERROR));
-      }
-    } else {
-      logger.error('Unexpected error in database route', { error });
-      next(error);
-    }
+    handleProxyError(error, res, next);
   }
 };
 

package/backend/src/api/routes/database/rpc.routes.ts

@@ -0,0 +1,69 @@
+import { Router, Response, NextFunction } from 'express';
+import axios from 'axios';
+import { AuthRequest, extractApiKey } from '@/api/middlewares/auth.js';
+import { AppError } from '@/api/middlewares/error.js';
+import { ERROR_CODES } from '@/types/error-constants.js';
+import { validateFunctionName } from '@/utils/validations.js';
+import { successResponse } from '@/utils/response.js';
+import { PostgrestProxyService } from '@/services/database/postgrest-proxy.service.js';
+
+const router = Router();
+const proxyService = PostgrestProxyService.getInstance();
+
+/**
+ * Helper to handle PostgREST proxy errors
+ */
+function handleProxyError(error: unknown, res: Response, next: NextFunction) {
+  if (axios.isAxiosError(error) && error.response) {
+    res.status(error.response.status).json(error.response.data);
+  } else {
+    next(error);
+  }
+}
+
+/**
+ * Forward RPC calls to PostgREST
+ */
+const forwardRpcToPostgrest = async (req: AuthRequest, res: Response, next: NextFunction) => {
+  const { functionName } = req.params;
+
+  try {
+    // Validate function name
+    try {
+      validateFunctionName(functionName);
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      throw new AppError(`Invalid function name: ${functionName}`, 400, ERROR_CODES.INVALID_INPUT);
+    }
+
+    const result = await proxyService.forward({
+      method: req.method,
+      path: `/rpc/${functionName}`,
+      query: req.query as Record<string, unknown>,
+      headers: req.headers as Record<string, string | string[] | undefined>,
+      body: req.body,
+      apiKey: extractApiKey(req) ?? undefined,
+    });
+
+    const headers = PostgrestProxyService.filterHeaders(result.headers);
+    Object.entries(headers).forEach(([key, value]) => res.setHeader(key, value));
+
+    let responseData = result.data;
+    if (
+      result.data === undefined ||
+      (typeof result.data === 'string' && result.data.trim() === '')
+    ) {
+      responseData = null;
+    }
+
+    successResponse(res, responseData, result.status);
+  } catch (error) {
+    handleProxyError(error, res, next);
+  }
+};
+
+router.all('/:functionName', forwardRpcToPostgrest);
+
+export { router as databaseRpcRouter };

package/backend/src/api/routes/database/tables.routes.ts

@@ -59,20 +59,6 @@ router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: Next
   }
 });
 
-// Get all table schemas
-router.get(
-  '/schemas',
-  verifyAdmin,
-  async (_req: AuthRequest, res: Response, next: NextFunction) => {
-    try {
-      const schemas = await tableService.getAllTableSchemas();
-      successResponse(res, schemas);
-    } catch (error) {
-      next(error);
-    }
-  }
-);
-
 // Get table schema
 router.get(
   '/:tableName/schema',