Переработано окно эндпоинта, добавлены элементы дебага, добавлена возможность сохранять и загружать конфигурацию эндпоинта, добавлено отображение ошибок при загрузке конфигурации. Исправлены мелкие баги.

2026-03-01 16:00:26 +03:00
parent 7e2e0103fe
commit 6766cd81a1
15 changed files with 1677 additions and 172 deletions
--- a/backend/src/controllers/endpointController.ts
+++ b/backend/src/controllers/endpointController.ts
@@ -2,6 +2,8 @@ import { Response } from 'express';
 import { AuthRequest } from '../middleware/auth';
 import { mainPool } from '../config/database';
 import { v4 as uuidv4 } from 'uuid';
+import { ExportedEndpoint, ExportedScriptQuery } from '../types';
+import { encryptEndpointData, decryptEndpointData } from '../services/endpointCrypto';

 export const getEndpoints = async (req: AuthRequest, res: Response) => {
  try {
@@ -314,6 +316,11 @@ export const testEndpoint = async (req: AuthRequest, res: Response) => {
        data: result.rows,
        rowCount: result.rowCount,
        executionTime: result.executionTime,
+        logs: [
+          { type: 'info', message: `Query executed in ${result.executionTime}ms, returned ${result.rowCount} rows`, timestamp: Date.now() },
+        ],
+        queries: [],
+        processedQuery,
      });
    } else if (execType === 'script') {
      if (!script_language || !script_code) {
@@ -338,7 +345,9 @@ export const testEndpoint = async (req: AuthRequest, res: Response) => {

      res.json({
        success: true,
-        data: scriptResult,
+        data: scriptResult.result,
+        logs: scriptResult.logs,
+        queries: scriptResult.queries,
      });
    } else if (execType === 'aql') {
      if (!database_id) {
@@ -370,6 +379,10 @@ export const testEndpoint = async (req: AuthRequest, res: Response) => {
        data: result.rows,
        rowCount: result.rowCount,
        executionTime: result.executionTime,
+        logs: [
+          { type: 'info', message: `AQL ${aql_method} ${aql_endpoint} executed in ${result.executionTime}ms`, timestamp: Date.now() },
+        ],
+        queries: [],
      });
    } else {
      return res.status(400).json({ error: 'Invalid execution_type' });
@@ -378,6 +391,347 @@ export const testEndpoint = async (req: AuthRequest, res: Response) => {
    res.status(400).json({
      success: false,
      error: error.message,
+      detail: error.detail || undefined,
+      hint: error.hint || undefined,
+      logs: [],
+      queries: [],
    });
  }
 };
+
+export const exportEndpoint = async (req: AuthRequest, res: Response) => {
+  try {
+    const { id } = req.params;
+
+    const endpointResult = await mainPool.query(
+      'SELECT * FROM endpoints WHERE id = $1',
+      [id]
+    );
+    if (endpointResult.rows.length === 0) {
+      return res.status(404).json({ error: 'Endpoint not found' });
+    }
+    const endpoint = endpointResult.rows[0];
+
+    // Resolve database_id -> name & type
+    let databaseName: string | null = null;
+    let databaseType: string | null = null;
+    if (endpoint.database_id) {
+      const dbResult = await mainPool.query(
+        'SELECT name, type FROM databases WHERE id = $1',
+        [endpoint.database_id]
+      );
+      if (dbResult.rows.length > 0) {
+        databaseName = dbResult.rows[0].name;
+        databaseType = dbResult.rows[0].type;
+      }
+    }
+
+    // Resolve folder_id -> name
+    let folderName: string | null = null;
+    if (endpoint.folder_id) {
+      const folderResult = await mainPool.query(
+        'SELECT name FROM folders WHERE id = $1',
+        [endpoint.folder_id]
+      );
+      if (folderResult.rows.length > 0) {
+        folderName = folderResult.rows[0].name;
+      }
+    }
+
+    // Resolve database_ids in script_queries
+    const scriptQueries = endpoint.script_queries || [];
+    const exportedScriptQueries: ExportedScriptQuery[] = [];
+    for (const sq of scriptQueries) {
+      let sqDbName: string | undefined;
+      let sqDbType: string | undefined;
+      if (sq.database_id) {
+        const sqDbResult = await mainPool.query(
+          'SELECT name, type FROM databases WHERE id = $1',
+          [sq.database_id]
+        );
+        if (sqDbResult.rows.length > 0) {
+          sqDbName = sqDbResult.rows[0].name;
+          sqDbType = sqDbResult.rows[0].type;
+        }
+      }
+      exportedScriptQueries.push({
+        name: sq.name,
+        sql: sq.sql,
+        database_name: sqDbName,
+        database_type: sqDbType,
+        aql_method: sq.aql_method,
+        aql_endpoint: sq.aql_endpoint,
+        aql_body: sq.aql_body,
+        aql_query_params: sq.aql_query_params,
+      });
+    }
+
+    const exportData: ExportedEndpoint = {
+      _format: 'kabe_v1',
+      name: endpoint.name,
+      description: endpoint.description || '',
+      method: endpoint.method,
+      path: endpoint.path,
+      execution_type: endpoint.execution_type || 'sql',
+      database_name: databaseName,
+      database_type: databaseType,
+      sql_query: endpoint.sql_query || '',
+      parameters: endpoint.parameters || [],
+      script_language: endpoint.script_language || null,
+      script_code: endpoint.script_code || null,
+      script_queries: exportedScriptQueries,
+      aql_method: endpoint.aql_method || null,
+      aql_endpoint: endpoint.aql_endpoint || null,
+      aql_body: endpoint.aql_body || null,
+      aql_query_params: endpoint.aql_query_params || null,
+      is_public: endpoint.is_public || false,
+      enable_logging: endpoint.enable_logging || false,
+      detailed_response: endpoint.detailed_response || false,
+      folder_name: folderName,
+    };
+
+    const encrypted = encryptEndpointData(exportData);
+
+    const safeFileName = endpoint.name.replace(/[^a-zA-Z0-9_\-а-яА-ЯёЁ]/g, '_');
+    res.setHeader('Content-Type', 'application/octet-stream');
+    res.setHeader('Content-Disposition', `attachment; filename="${safeFileName}.kabe"`);
+    res.send(encrypted);
+  } catch (error) {
+    console.error('Export endpoint error:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+};
+
+export const importPreview = async (req: AuthRequest, res: Response) => {
+  try {
+    const buffer = req.body as Buffer;
+    if (!buffer || buffer.length === 0) {
+      return res.status(400).json({ error: 'No file uploaded' });
+    }
+
+    let exportData: ExportedEndpoint;
+    try {
+      exportData = decryptEndpointData(buffer) as ExportedEndpoint;
+    } catch (err) {
+      return res.status(400).json({ error: 'Invalid or corrupted .kabe file' });
+    }
+
+    if (exportData._format !== 'kabe_v1') {
+      return res.status(400).json({ error: 'Unsupported file format version' });
+    }
+
+    // Collect all referenced database names
+    const referencedDatabases: { name: string; type: string }[] = [];
+
+    if (exportData.database_name) {
+      referencedDatabases.push({
+        name: exportData.database_name,
+        type: exportData.database_type || 'unknown',
+      });
+    }
+
+    for (const sq of exportData.script_queries || []) {
+      if (sq.database_name && !referencedDatabases.find(d => d.name === sq.database_name)) {
+        referencedDatabases.push({
+          name: sq.database_name,
+          type: sq.database_type || 'unknown',
+        });
+      }
+    }
+
+    // Check which databases exist locally
+    const localDatabases = await mainPool.query(
+      'SELECT id, name, type FROM databases WHERE is_active = true'
+    );
+
+    const databaseMapping = referencedDatabases.map(ref => {
+      const found = localDatabases.rows.find(
+        (db: any) => db.name === ref.name && db.type === ref.type
+      );
+      return {
+        name: ref.name,
+        type: ref.type,
+        found: !!found,
+        local_id: found?.id || null,
+      };
+    });
+
+    // Check folder
+    let folder: { name: string; found: boolean; local_id: string | null } | null = null;
+    if (exportData.folder_name) {
+      const folderResult = await mainPool.query(
+        'SELECT id FROM folders WHERE name = $1',
+        [exportData.folder_name]
+      );
+      folder = {
+        name: exportData.folder_name,
+        found: folderResult.rows.length > 0,
+        local_id: folderResult.rows.length > 0 ? folderResult.rows[0].id : null,
+      };
+    }
+
+    // Check if path already exists
+    const pathCheck = await mainPool.query(
+      'SELECT id FROM endpoints WHERE path = $1',
+      [exportData.path]
+    );
+
+    res.json({
+      endpoint: {
+        name: exportData.name,
+        description: exportData.description,
+        method: exportData.method,
+        path: exportData.path,
+        execution_type: exportData.execution_type,
+        is_public: exportData.is_public,
+        enable_logging: exportData.enable_logging,
+        detailed_response: exportData.detailed_response,
+        folder_name: exportData.folder_name,
+      },
+      databases: databaseMapping,
+      all_databases_found: databaseMapping.every(d => d.found),
+      local_databases: localDatabases.rows.map((db: any) => ({
+        id: db.id,
+        name: db.name,
+        type: db.type,
+      })),
+      folder,
+      path_exists: pathCheck.rows.length > 0,
+    });
+  } catch (error) {
+    console.error('Import preview error:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+};
+
+export const importEndpoint = async (req: AuthRequest, res: Response) => {
+  try {
+    const {
+      file_data,
+      database_mapping,
+      folder_id,
+      override_path,
+    } = req.body;
+
+    if (!file_data) {
+      return res.status(400).json({ error: 'No file data provided' });
+    }
+
+    const buffer = Buffer.from(file_data, 'base64');
+    let exportData: ExportedEndpoint;
+    try {
+      exportData = decryptEndpointData(buffer) as ExportedEndpoint;
+    } catch (err) {
+      return res.status(400).json({ error: 'Invalid or corrupted .kabe file' });
+    }
+
+    // Resolve main database_id
+    let databaseId: string | null = null;
+    if (exportData.database_name) {
+      const mappedId = database_mapping?.[exportData.database_name];
+      if (mappedId) {
+        databaseId = mappedId;
+      } else {
+        const dbResult = await mainPool.query(
+          'SELECT id FROM databases WHERE name = $1 AND is_active = true',
+          [exportData.database_name]
+        );
+        if (dbResult.rows.length > 0) {
+          databaseId = dbResult.rows[0].id;
+        } else {
+          return res.status(400).json({
+            error: `Database "${exportData.database_name}" not found and no mapping provided`
+          });
+        }
+      }
+    }
+
+    // Resolve script_queries database_ids
+    const resolvedScriptQueries = [];
+    for (const sq of exportData.script_queries || []) {
+      let sqDatabaseId: string | undefined;
+      if (sq.database_name) {
+        const mappedId = database_mapping?.[sq.database_name];
+        if (mappedId) {
+          sqDatabaseId = mappedId;
+        } else {
+          const sqDbResult = await mainPool.query(
+            'SELECT id FROM databases WHERE name = $1 AND is_active = true',
+            [sq.database_name]
+          );
+          if (sqDbResult.rows.length > 0) {
+            sqDatabaseId = sqDbResult.rows[0].id;
+          } else {
+            return res.status(400).json({
+              error: `Database "${sq.database_name}" (script query "${sq.name}") not found and no mapping provided`
+            });
+          }
+        }
+      }
+      resolvedScriptQueries.push({
+        name: sq.name,
+        sql: sq.sql,
+        database_id: sqDatabaseId,
+        aql_method: sq.aql_method,
+        aql_endpoint: sq.aql_endpoint,
+        aql_body: sq.aql_body,
+        aql_query_params: sq.aql_query_params,
+      });
+    }
+
+    // Resolve folder
+    let resolvedFolderId: string | null = folder_id || null;
+    if (!resolvedFolderId && exportData.folder_name) {
+      const folderResult = await mainPool.query(
+        'SELECT id FROM folders WHERE name = $1',
+        [exportData.folder_name]
+      );
+      if (folderResult.rows.length > 0) {
+        resolvedFolderId = folderResult.rows[0].id;
+      }
+    }
+
+    const finalPath = override_path || exportData.path;
+
+    const result = await mainPool.query(
+      `INSERT INTO endpoints (
+        name, description, method, path, database_id, sql_query, parameters,
+        folder_id, user_id, is_public, enable_logging,
+        execution_type, script_language, script_code, script_queries,
+        aql_method, aql_endpoint, aql_body, aql_query_params, detailed_response
+      )
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20)
+       RETURNING *`,
+      [
+        exportData.name,
+        exportData.description || '',
+        exportData.method,
+        finalPath,
+        databaseId,
+        exportData.sql_query || '',
+        JSON.stringify(exportData.parameters || []),
+        resolvedFolderId,
+        req.user!.id,
+        exportData.is_public || false,
+        exportData.enable_logging || false,
+        exportData.execution_type || 'sql',
+        exportData.script_language || null,
+        exportData.script_code || null,
+        JSON.stringify(resolvedScriptQueries),
+        exportData.aql_method || null,
+        exportData.aql_endpoint || null,
+        exportData.aql_body || null,
+        JSON.stringify(exportData.aql_query_params || {}),
+        exportData.detailed_response || false,
+      ]
+    );
+
+    res.status(201).json(result.rows[0]);
+  } catch (error: any) {
+    console.error('Import endpoint error:', error);
+    if (error.code === '23505') {
+      return res.status(400).json({ error: 'Endpoint path already exists' });
+    }
+    res.status(500).json({ error: 'Internal server error' });
+  }
+};