blockmine 1.20.0 → 1.22.0

package/backend/src/core/utils/__tests__/jsonParser.test.js

@@ -0,0 +1,44 @@
+const { safeJsonParse } = require('../jsonParser');
+
+describe('safeJsonParse', () => {
+    it('should parse valid JSON string', () => {
+        const result = safeJsonParse('{"key":"value"}', null, 'test');
+        expect(result).toEqual({ key: 'value' });
+    });
+
+    it('should return default value for invalid JSON', () => {
+        const result = safeJsonParse('{invalid}', { default: true }, 'test');
+        expect(result).toEqual({ default: true });
+    });
+
+    it('should handle null input', () => {
+        const result = safeJsonParse(null, 'default', 'test');
+        expect(result).toBe('default');
+    });
+
+    it('should handle undefined input', () => {
+        const result = safeJsonParse(undefined, 'default', 'test');
+        expect(result).toBe('default');
+    });
+
+    it('should return non-string values as-is', () => {
+        const obj = { key: 'value' };
+        const result = safeJsonParse(obj, null, 'test');
+        expect(result).toBe(obj);
+    });
+
+    it('should parse arrays correctly', () => {
+        const result = safeJsonParse('[1,2,3]', [], 'test');
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('should return default for malformed JSON', () => {
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+        const result = safeJsonParse('{"key": undefined}', [], 'test');
+
+        expect(result).toEqual([]);
+        expect(consoleSpy).toHaveBeenCalled();
+
+        consoleSpy.mockRestore();
+    });
+});

package/backend/src/core/utils/jsonParser.js

@@ -0,0 +1,18 @@
+function safeJsonParse(jsonString, defaultValue = null, context = 'unknown') {
+    if (jsonString === null || jsonString === undefined) {
+        return defaultValue;
+    }
+
+    if (typeof jsonString !== 'string') {
+        return jsonString;
+    }
+
+    try {
+        return JSON.parse(jsonString);
+    } catch (error) {
+        console.error(`[JSONParser] Failed to parse JSON in ${context}:`, error.message);
+        return defaultValue;
+    }
+}
+
+module.exports = { safeJsonParse };

package/backend/src/core/utils/secretsFilter.js

@@ -0,0 +1,262 @@
+/**
+ * Утилита для работы со скрытыми (секретными) значениями настроек плагинов
+ * Позволяет маскировать чувствительные данные при отправке на фронтенд
+ */
+
+const SECRET_MASK = '********';
+
+/**
+ * Создает глубокую копию объекта
+ * @param {any} obj - объект для клонирования
+ * @returns {any} - глубокая копия объекта
+ */
+function deepClone(obj) {
+    // Используем structuredClone если доступен (Node.js 17+)
+    if (typeof structuredClone !== 'undefined') {
+        try {
+            return structuredClone(obj);
+        } catch (e) {
+            // Fallback для случаев когда structuredClone не может обработать объект
+        }
+    }
+    
+    // Fallback на JSON parse/stringify
+    // Ограничения: не сохраняет функции, undefined, Symbol, circular references
+    try {
+        return JSON.parse(JSON.stringify(obj));
+    } catch (e) {
+        console.error('[secretsFilter] Ошибка клонирования объекта:', e);
+        return obj;
+    }
+}
+
+/**
+ * Определяет, использует ли плагин группированные настройки
+ * Группированные настройки имеют структуру: { "CategoryName": { label: "...", setting1: {...}, ... } }
+ * @param {Object} manifestSettings - настройки из манифеста плагина
+ * @returns {boolean}
+ */
+function isGroupedSettings(manifestSettings) {
+    if (!manifestSettings || typeof manifestSettings !== 'object') {
+        return false;
+    }
+    
+    const firstKey = Object.keys(manifestSettings)[0];
+    if (!firstKey) {
+        return false;
+    }
+    
+    const firstValue = manifestSettings[firstKey];
+    
+    // Проверяем, что первое значение - объект с label и без type
+    // (настройки имеют type, группы имеют label)
+    return (
+        firstValue &&
+        typeof firstValue === 'object' &&
+        !Array.isArray(firstValue) &&
+        'label' in firstValue &&
+        !('type' in firstValue)
+    );
+}
+
+/**
+ * Определяет, является ли настройка секретной
+ * @param {Object} settingConfig - конфигурация настройки из manifest
+ * @returns {boolean}
+ */
+function isSecretSetting(settingConfig) {
+    if (!settingConfig) {
+        return false;
+    }
+    return settingConfig.secret === true;
+}
+
+/**
+ * Маскирует секретное значение
+ * @param {any} value - значение для маскировки
+ * @param {Object} settingConfig - конфигурация настройки
+ * @returns {any} - замаскированное значение
+ */
+function maskSecretValue(value, settingConfig) {
+    if (!isSecretSetting(settingConfig)) {
+        return value;
+    }
+
+    // Если значение пустое/null/undefined, возвращаем как есть
+    if (value === null || value === undefined || value === '') {
+        return value;
+    }
+
+    // Для массивов маскируем каждый элемент
+    if (Array.isArray(value)) {
+        return value.map(() => SECRET_MASK);
+    }
+
+    // Для объектов маскируем каждое значение
+    if (typeof value === 'object') {
+        const masked = {};
+        for (const key in value) {
+            masked[key] = SECRET_MASK;
+        }
+        return masked;
+    }
+
+    // Для остальных типов просто возвращаем маску
+    return SECRET_MASK;
+}
+
+/**
+ * Фильтрует настройки плагина, маскируя секретные значения
+ * @param {Object} settings - текущие настройки плагина
+ * @param {Object} manifestSettings - описание настроек из manifest
+ * @param {boolean} isGrouped - использует ли плагин группированные настройки
+ * @returns {Object} - отфильтрованные настройки
+ */
+function filterSecretSettings(settings, manifestSettings, isGrouped = false) {
+    if (!settings || !manifestSettings) {
+        return settings;
+    }
+
+    const filteredSettings = { ...settings };
+
+    if (isGrouped) {
+        // Обработка группированных настроек
+        for (const categoryKey in manifestSettings) {
+            const categoryConfig = manifestSettings[categoryKey];
+            if (typeof categoryConfig !== 'object' || !categoryConfig.label) {
+                continue;
+            }
+
+            for (const settingKey in categoryConfig) {
+                if (settingKey === 'label') continue;
+                
+                const settingConfig = categoryConfig[settingKey];
+                if (isSecretSetting(settingConfig) && settingKey in filteredSettings) {
+                    filteredSettings[settingKey] = maskSecretValue(
+                        filteredSettings[settingKey],
+                        settingConfig
+                    );
+                }
+            }
+        }
+    } else {
+        // Обработка обычных настроек
+        for (const settingKey in manifestSettings) {
+            const settingConfig = manifestSettings[settingKey];
+            if (isSecretSetting(settingConfig) && settingKey in filteredSettings) {
+                filteredSettings[settingKey] = maskSecretValue(
+                    filteredSettings[settingKey],
+                    settingConfig
+                );
+            }
+        }
+    }
+
+    return filteredSettings;
+}
+
+/**
+ * Проверяет, является ли значение замаскированным
+ * @param {any} value - значение для проверки
+ * @returns {boolean}
+ */
+function isMaskedValue(value) {
+    if (value === SECRET_MASK) {
+        return true;
+    }
+
+    if (Array.isArray(value)) {
+        // Пустой массив не является замаскированным
+        if (value.length === 0) {
+            return false;
+        }
+        return value.every(item => item === SECRET_MASK);
+    }
+
+    if (typeof value === 'object' && value !== null) {
+        const values = Object.values(value);
+        // Пустой объект не является замаскированным
+        if (values.length === 0) {
+            return false;
+        }
+        return values.every(v => v === SECRET_MASK);
+    }
+
+    return false;
+}
+
+/**
+ * Фильтрует обновления настроек, удаляя замаскированные значения
+ * Это предотвращает сохранение маски вместо реального значения
+ * @param {Object} newSettings - новые настройки для сохранения
+ * @param {Object} existingSettings - существующие настройки
+ * @param {Object} manifestSettings - описание настроек из manifest
+ * @param {boolean} isGrouped - использует ли плагин группированные настройки
+ * @returns {Object} - отфильтрованные настройки для сохранения
+ */
+function prepareSettingsForSave(newSettings, existingSettings, manifestSettings, isGrouped = false) {
+    if (!newSettings || !manifestSettings) {
+        return newSettings;
+    }
+
+    // Используем глубокое клонирование для избежания мутаций и side effects
+    const settingsToSave = deepClone(newSettings);
+
+    if (isGrouped) {
+        for (const categoryKey in manifestSettings) {
+            const categoryConfig = manifestSettings[categoryKey];
+            if (typeof categoryConfig !== 'object' || !categoryConfig.label) {
+                continue;
+            }
+
+            for (const settingKey in categoryConfig) {
+                if (settingKey === 'label') continue;
+                
+                const settingConfig = categoryConfig[settingKey];
+                
+                // Если настройка секретная и новое значение является маской,
+                // используем существующее значение
+                if (isSecretSetting(settingConfig) && 
+                    settingKey in settingsToSave && 
+                    isMaskedValue(settingsToSave[settingKey])) {
+                    
+                    if (existingSettings && settingKey in existingSettings) {
+                        settingsToSave[settingKey] = existingSettings[settingKey];
+                    } else {
+                        // Если существующего значения нет, удаляем ключ
+                        delete settingsToSave[settingKey];
+                    }
+                }
+            }
+        }
+    } else {
+        for (const settingKey in manifestSettings) {
+            const settingConfig = manifestSettings[settingKey];
+            
+            if (isSecretSetting(settingConfig) && 
+                settingKey in settingsToSave && 
+                isMaskedValue(settingsToSave[settingKey])) {
+                
+                if (existingSettings && settingKey in existingSettings) {
+                    settingsToSave[settingKey] = existingSettings[settingKey];
+                } else {
+                    delete settingsToSave[settingKey];
+                }
+            }
+        }
+    }
+
+    return settingsToSave;
+}
+
+module.exports = {
+    SECRET_MASK,
+    isSecretSetting,
+    maskSecretValue,
+    filterSecretSettings,
+    isMaskedValue,
+    prepareSettingsForSave,
+    isGroupedSettings,
+    deepClone
+};
+

package/backend/src/core/utils/variableParser.js

@@ -0,0 +1,89 @@
+const { safeJsonParse } = require('./jsonParser');
+
+/**
+ * Парсит значение переменной в зависимости от её типа
+ * @param {object} variable - Объект переменной с полями type, name, value
+ * @param {string} variable.type - Тип переменной ('number', 'boolean', 'array', 'string')
+ * @param {string} variable.name - Имя переменной (для логирования)
+ * @param {*} variable.value - Исходное значение переменной
+ * @param {string} [contextName] - Имя контекста для логирования (например, 'EventGraph ID 123')
+ * @returns {*} - Распарсенное значение переменной
+ */
+function parseVariableValue(variable, contextName = 'unknown context') {
+    const { type, name, value } = variable;
+
+    try {
+        switch (type) {
+            case 'number':
+                return Number(value) || 0;
+
+            case 'boolean':
+                return value === 'true';
+
+            case 'array': {
+                const parsedArray = safeJsonParse(value, [], `variable ${name}`);
+                if (!Array.isArray(parsedArray)) {
+                    console.warn(
+                        `[VariableParser] Failed to parse variable "${name}" as array in ${contextName}. ` +
+                        `Falling back to empty array. Raw value:`,
+                        value
+                    );
+                    return [];
+                }
+                return parsedArray;
+            }
+
+            default:
+                return value;
+        }
+    } catch (e) {
+        console.error(`[VariableParser] Error parsing variable "${name}" in ${contextName}:`, e);
+        return getDefaultValueForType(type);
+    }
+}
+
+/**
+ * Возвращает значение по умолчанию для типа переменной
+ * @param {string} type - Тип переменной
+ * @returns {*} - Значение по умолчанию
+ */
+function getDefaultValueForType(type) {
+    switch (type) {
+        case 'number':
+            return 0;
+        case 'boolean':
+            return false;
+        case 'array':
+            return [];
+        default:
+            return '';
+    }
+}
+
+/**
+ * Парсит массив переменных и возвращает объект с распарсенными значениями
+ * @param {Array} variables - Массив объектов переменных
+ * @param {string} [contextName] - Имя контекста для логирования
+ * @returns {object} - Объект с именами переменных в качестве ключей и распарсенными значениями
+ */
+function parseVariables(variables, contextName = 'unknown context') {
+    if (!Array.isArray(variables)) {
+        return {};
+    }
+
+    const result = {};
+    for (const variable of variables) {
+        if (!variable.name) {
+            console.warn(`[VariableParser] Skipping variable without name in ${contextName}`);
+            continue;
+        }
+        result[variable.name] = parseVariableValue(variable, contextName);
+    }
+    return result;
+}
+
+module.exports = {
+    parseVariableValue,
+    parseVariables,
+    getDefaultValueForType,
+};

package/backend/src/core/validation/__tests__/nodeSchemas.test.js

@@ -0,0 +1,175 @@
+const {
+    validateNodeConfig,
+    validateNodeData,
+    validateGraph,
+} = require('../nodeSchemas');
+
+describe('Node Validation Schemas', () => {
+    describe('validateNodeConfig', () => {
+        it('should validate correct node configuration', () => {
+            const validConfig = {
+                type: 'test:node',
+                label: 'Test Node',
+                category: 'Test',
+                inputs: [
+                    { id: 'input1', name: 'Input 1', type: 'String' }
+                ],
+                outputs: [
+                    { id: 'output1', name: 'Output 1', type: 'String' }
+                ],
+            };
+
+            const result = validateNodeConfig(validConfig);
+            expect(result.success).toBe(true);
+            expect(result.data).toBeDefined();
+        });
+
+        it('should fail validation for missing required fields', () => {
+            const invalidConfig = {
+                label: 'Test Node',
+            };
+
+            const result = validateNodeConfig(invalidConfig);
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+
+        it('should fail validation for invalid pin structure', () => {
+            const invalidConfig = {
+                type: 'test:node',
+                label: 'Test Node',
+                category: 'Test',
+                inputs: [
+                    { id: '', name: 'Input 1', type: 'String' }
+                ],
+            };
+
+            const result = validateNodeConfig(invalidConfig);
+            expect(result.success).toBe(false);
+        });
+
+        it('should accept optional fields', () => {
+            const configWithOptional = {
+                type: 'test:node',
+                label: 'Test Node',
+                category: 'Test',
+                description: 'A test node',
+                inputs: [],
+                outputs: [],
+            };
+
+            const result = validateNodeConfig(configWithOptional);
+            expect(result.success).toBe(true);
+        });
+    });
+
+    describe('validateNodeData', () => {
+        it('should validate correct node data', () => {
+            const validNodeData = {
+                id: 'node-123',
+                type: 'test:node',
+                position: { x: 100, y: 200 },
+                data: { pinCount: 2 },
+            };
+
+            const result = validateNodeData(validNodeData);
+            expect(result.success).toBe(true);
+        });
+
+        it('should fail validation for missing position coordinates', () => {
+            const invalidNodeData = {
+                id: 'node-123',
+                type: 'test:node',
+                position: { x: 100 },
+            };
+
+            const result = validateNodeData(invalidNodeData);
+            expect(result.success).toBe(false);
+        });
+
+        it('should accept empty data object', () => {
+            const nodeDataWithEmptyData = {
+                id: 'node-123',
+                type: 'test:node',
+                position: { x: 100, y: 200 },
+            };
+
+            const result = validateNodeData(nodeDataWithEmptyData);
+            expect(result.success).toBe(true);
+            expect(result.data.data).toEqual({});
+        });
+    });
+
+    describe('validateGraph', () => {
+        it('should validate correct graph structure', () => {
+            const validGraph = {
+                nodes: [
+                    {
+                        id: 'node-1',
+                        type: 'test:node',
+                        position: { x: 100, y: 200 },
+                        data: {},
+                    }
+                ],
+                connections: [
+                    {
+                        id: 'conn-1',
+                        sourceNodeId: 'node-1',
+                        targetNodeId: 'node-2',
+                        sourcePinId: 'output1',
+                        targetPinId: 'input1',
+                    }
+                ],
+                variables: [
+                    {
+                        id: 'var-1',
+                        name: 'testVar',
+                        type: 'string',
+                        value: 'test',
+                    }
+                ],
+            };
+
+            const result = validateGraph(validGraph);
+            expect(result.success).toBe(true);
+        });
+
+        it('should fail validation for missing nodes array', () => {
+            const invalidGraph = {
+                connections: [],
+            };
+
+            const result = validateGraph(invalidGraph);
+            expect(result.success).toBe(false);
+        });
+
+        it('should accept graph with empty variables', () => {
+            const graphWithoutVars = {
+                nodes: [],
+                connections: [],
+            };
+
+            const result = validateGraph(graphWithoutVars);
+            expect(result.success).toBe(true);
+            expect(result.data.variables).toEqual([]);
+        });
+
+        it('should fail validation for invalid variable type', () => {
+            const invalidGraph = {
+                nodes: [],
+                connections: [],
+                variables: [
+                    {
+                        id: 'var-1',
+                        name: 'testVar',
+                        type: 'invalid_type',
+                        value: 'test',
+                    }
+                ],
+            };
+
+            const result = validateGraph(invalidGraph);
+            expect(result.success).toBe(false);
+        });
+    });
+});

package/backend/src/core/validation/nodeSchemas.js

@@ -0,0 +1,112 @@
+const { z } = require('zod');
+const { GRAPH_TYPES } = require('../constants/graphTypes');
+
+const PinSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    type: z.string().min(1),
+    required: z.boolean().optional(),
+    defaultValue: z.any().optional(),
+});
+
+const NodeConfigSchema = z.object({
+    type: z.string().min(1),
+    label: z.string().min(1),
+    category: z.string().min(1),
+    description: z.string().optional(),
+    name: z.string().optional(),
+    graphType: z.enum([GRAPH_TYPES.ALL, GRAPH_TYPES.COMMAND, GRAPH_TYPES.EVENT]).optional(),
+    isEvent: z.boolean().optional(),
+    dynamicPins: z.boolean().optional(),
+    inputs: z.array(PinSchema).optional().default([]),
+    outputs: z.array(PinSchema).optional().default([]),
+    pins: z.object({
+        inputs: z.array(PinSchema).optional().default([]),
+        outputs: z.array(PinSchema).optional().default([]),
+    }).optional(),
+    executor: z.function().optional(),
+    evaluator: z.function().optional(),
+}).passthrough();
+
+const NodeDataSchema = z.object({
+    id: z.string().min(1),
+    type: z.string().min(1),
+    position: z.object({
+        x: z.number(),
+        y: z.number(),
+    }),
+    data: z.any().optional().default({}),
+    deletable: z.boolean().optional(),
+});
+
+const ConnectionSchema = z.object({
+    id: z.string().min(1),
+    sourceNodeId: z.string().min(1),
+    targetNodeId: z.string().min(1),
+    sourcePinId: z.string().min(1),
+    targetPinId: z.string().min(1),
+});
+
+const GraphSchema = z.object({
+    nodes: z.array(NodeDataSchema),
+    connections: z.array(ConnectionSchema),
+    variables: z.array(z.object({
+        id: z.string().min(1),
+        name: z.string().min(1),
+        type: z.enum(['string', 'number', 'boolean', 'array', 'object']),
+        value: z.any(),
+    })).optional().default([]),
+});
+
+function validateNodeConfig(nodeConfig) {
+    try {
+        return {
+            success: true,
+            data: NodeConfigSchema.parse(nodeConfig),
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error.issues || error.errors || [{ message: error.message }],
+        };
+    }
+}
+
+function validateNodeData(nodeData) {
+    try {
+        return {
+            success: true,
+            data: NodeDataSchema.parse(nodeData),
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error.issues || error.errors || [{ message: error.message }],
+        };
+    }
+}
+
+function validateGraph(graph) {
+    try {
+        return {
+            success: true,
+            data: GraphSchema.parse(graph),
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error.issues || error.errors || [{ message: error.message }],
+        };
+    }
+}
+
+module.exports = {
+    PinSchema,
+    NodeConfigSchema,
+    NodeDataSchema,
+    ConnectionSchema,
+    GraphSchema,
+    validateNodeConfig,
+    validateNodeData,
+    validateGraph,
+};