insforge 0.3.2 → 1.2.10

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

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import { databaseTablesRouter } from './tables.routes.js';
+import { databaseRecordsRouter } from './records.routes.js';
+import databaseAdvanceRouter from './advance.routes.js';
+
+const router = Router();
+
+// Mount database sub-routes
+router.use('/tables', databaseTablesRouter);
+router.use('/records', databaseRecordsRouter);
+router.use('/advance', databaseAdvanceRouter);
+
+export default router;

package/backend/src/api/routes/{database.records.ts → database/records.routes.ts}

@@ -2,20 +2,21 @@ import { Router, Response, NextFunction } from 'express';
 import axios from 'axios';
 import http from 'http';
 import https from 'https';
-import { AuthRequest, extractApiKey } from '@/api/middleware/auth.js';
-import { DatabaseManager } from '@/core/database/manager.js';
-import { AppError } from '@/api/middleware/error.js';
+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 { SecretsService } from '@/core/secrets/secrets.js';
-import { AuthService } from '@/core/auth/auth.js';
+import { SecretService } from '@/services/secrets/secret.service.js';
+import { SocketManager } from '@/infra/socket/socket.manager.js';
+import { DataUpdateResourceType, ServerEvents } from '@/types/socket.js';
 
 const router = Router();
-const authService = AuthService.getInstance();
-const secretService = new SecretsService();
+const secretService = SecretService.getInstance();
 const postgrestUrl = process.env.POSTGREST_BASE_URL || 'http://localhost:5430';
 
 // Create a dedicated HTTP agent with connection pooling for PostgREST
@@ -51,7 +52,8 @@ const postgrestAxios = axios.create({
 
 // Generate admin token once and reuse
 // If user request with api key, this token should be added automatically.
-const adminToken = authService.generateToken({
+const tokenManager = TokenManager.getInstance();
+const adminToken = tokenManager.generateToken({
   sub: 'project-admin-with-api-key',
   email: 'project-admin@email.com',
   role: 'project_admin',
@@ -203,6 +205,18 @@ const forwardToPostgrest = async (req: AuthRequest, res: Response, next: NextFun
       responseData = [];
     }
 
+    // Only send socket events for mutations (POST, DELETE)
+    const mutationMethods = ['POST', 'DELETE'];
+    if (mutationMethods.includes(req.method.toUpperCase())) {
+      const socket = SocketManager.getInstance();
+      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
+        resource: DataUpdateResourceType.RECORDS,
+        data: {
+          tableName: tableName,
+        },
+      });
+    }
+
     successResponse(res, responseData, response.status);
   } catch (error) {
     if (axios.isAxiosError(error)) {

package/backend/src/api/routes/{database.tables.ts → database/tables.routes.ts}

@@ -1,23 +1,21 @@
 import { Router, Response, NextFunction } from 'express';
-import { verifyAdmin, verifyUser, AuthRequest } from '@/api/middleware/auth.js';
-import { DatabaseTableService } from '@/core/database/table.js';
+import { verifyAdmin, AuthRequest } from '@/api/middlewares/auth.js';
+import { DatabaseTableService } from '@/services/database/database-table.service.js';
 import { successResponse } from '@/utils/response.js';
-import { AppError } from '@/api/middleware/error.js';
+import { AppError } from '@/api/middlewares/error.js';
 import { ERROR_CODES } from '@/types/error-constants.js';
 import { createTableRequestSchema, updateTableSchemaRequestSchema } from '@insforge/shared-schemas';
-import { SocketService } from '@/core/socket/socket';
-import { DataUpdateResourceType, ServerEvents } from '@/core/socket/types';
-import { AuditService } from '@/core/logs/audit';
+import { AuditService } from '@/services/logs/audit.service.js';
 
 const router = Router();
-const tableService = new DatabaseTableService();
+const tableService = DatabaseTableService.getInstance();
 const auditService = AuditService.getInstance();
 
 // All table routes accept either JWT token or API key authentication
 // router.use(verifyAdmin);
 
 // List all tables
-router.get('/', verifyUser, async (_req: AuthRequest, res: Response, next: NextFunction) => {
+router.get('/', verifyAdmin, async (_req: AuthRequest, res: Response, next: NextFunction) => {
   try {
     const tables = await tableService.listTables();
     successResponse(res, tables);
@@ -55,16 +53,26 @@ router.post('/', verifyAdmin, async (req: AuthRequest, res: Response, next: Next
       ip_address: req.ip,
     });
 
-    const socket = SocketService.getInstance();
-    socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-      resource: DataUpdateResourceType.DATABASE_SCHEMA,
-    });
     successResponse(res, result, 201);
   } catch (error) {
     next(error);
   }
 });
 
+// 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',
@@ -113,13 +121,6 @@ router.patch(
         ip_address: req.ip,
       });
 
-      const socket = SocketService.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.TABLE_SCHEMA,
-        data: {
-          name: tableName,
-        },
-      });
       successResponse(res, result);
     } catch (error) {
       next(error);
@@ -147,10 +148,6 @@ router.delete(
         ip_address: req.ip,
       });
 
-      const socket = SocketService.getInstance();
-      socket.broadcastToRoom('role:project_admin', ServerEvents.DATA_UPDATE, {
-        resource: DataUpdateResourceType.DATABASE_SCHEMA,
-      });
       successResponse(res, result);
     } catch (error) {
       next(error);

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

@@ -0,0 +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 };

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

@@ -0,0 +1,188 @@
+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,
+    });
+
+    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,
+      },
+    });
+
+    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,
+      });
+
+      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,24 @@
 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 { 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 dbManager = DatabaseManager.getInstance();
+const dbAdvanceService = DatabaseAdvanceService.getInstance();
+const aiConfigService = AIConfigService.getInstance();
 
 router.use(verifyAdmin);
 
@@ -23,17 +26,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 +48,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 +57,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 +67,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 +77,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,8 +97,7 @@ 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);
@@ -117,8 +107,8 @@ router.get('/functions', async (_req: AuthRequest, res: Response, next: NextFunc
 // 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) {