blockmine 1.25.0 → 1.27.1

package/backend/src/core/GraphTraversal.js

@@ -0,0 +1,80 @@
+class GraphTraversal {
+    constructor(activeGraph, memo) {
+        this.activeGraph = activeGraph;
+        this.memo = memo;
+    }
+
+    findConnection(nodeId, fromPinId) {
+        if (!this.activeGraph || !this.activeGraph.connections) return null;
+
+        return this.activeGraph.connections.find(c => {
+            if (c.sourceNodeId !== nodeId || c.sourcePinId !== fromPinId) return false;
+            const targetExists = this.activeGraph.nodes.some(n => n.id === c.targetNodeId);
+            return targetExists;
+        });
+    }
+
+    findNextNode(connection) {
+        if (!connection || !this.activeGraph) return null;
+        return this.activeGraph.nodes.find(n => n.id === connection.targetNodeId) || null;
+    }
+
+    clearLoopBodyMemo(loopNode) {
+        const nodesToClear = new Set();
+        const queue = [];
+
+        const initialConnection = this.activeGraph.connections.find(
+            c => c.sourceNodeId === loopNode.id && c.sourcePinId === 'loop_body'
+        );
+        if (initialConnection) {
+            const firstNode = this.activeGraph.nodes.find(n => n.id === initialConnection.targetNodeId);
+            if (firstNode) {
+                queue.push(firstNode);
+            }
+        }
+
+        const visited = new Set();
+        while (queue.length > 0) {
+            const currentNode = queue.shift();
+            if (visited.has(currentNode.id)) continue;
+            visited.add(currentNode.id);
+
+            nodesToClear.add(currentNode.id);
+
+            const connections = this.activeGraph.connections.filter(c => c.sourceNodeId === currentNode.id);
+            for (const conn of connections) {
+                const nextNode = this.activeGraph.nodes.find(n => n.id === conn.targetNodeId);
+                if (nextNode) {
+                    queue.push(nextNode);
+                }
+            }
+        }
+
+        for (const nodeId of nodesToClear) {
+            for (const key of this.memo.keys()) {
+                if (key.startsWith(nodeId)) {
+                    this.memo.delete(key);
+                }
+            }
+        }
+    }
+
+    getConnectionsFromNode(nodeId) {
+        if (!this.activeGraph || !this.activeGraph.connections) return [];
+        return this.activeGraph.connections.filter(c => c.sourceNodeId === nodeId);
+    }
+
+    getConnectionsToNode(nodeId) {
+        if (!this.activeGraph || !this.activeGraph.connections) return [];
+        return this.activeGraph.connections.filter(c => c.targetNodeId === nodeId);
+    }
+
+    hasConnection(nodeId, pinId) {
+        if (!this.activeGraph || !this.activeGraph.connections) return false;
+        return this.activeGraph.connections.some(conn =>
+            conn.targetNodeId === nodeId && conn.targetPinId === pinId
+        );
+    }
+}
+
+module.exports = GraphTraversal;

package/backend/src/core/GraphValidation.js

@@ -0,0 +1,73 @@
+const validationService = require('./services/ValidationService');
+
+class GraphValidation {
+    static validateGraphForExecution(graph, source) {
+        if (!graph || graph === 'null') {
+            return { shouldSkip: true, error: null };
+        }
+
+        const parsedGraph = validationService.parseGraph(graph, source);
+        if (!parsedGraph) {
+            return { shouldSkip: true, error: 'Invalid graph' };
+        }
+
+        const validation = validationService.validateGraphStructure(parsedGraph, source);
+        if (validation.shouldSkip) {
+            return { shouldSkip: true, error: validation.reason };
+        }
+
+        return { shouldSkip: false, graph: parsedGraph };
+    }
+
+    static findStartNode(graph, eventType) {
+        if (!graph || !graph.nodes) return null;
+
+        const eventName = eventType || 'command';
+        return graph.nodes.find(n => n.type === `event:${eventName}`) || null;
+    }
+
+    static getNodeInputPins(nodeConfig, nodeData) {
+        if (!nodeConfig) return [];
+
+        let inputPins = [];
+        try {
+            if (typeof nodeConfig.getInputs === 'function') {
+                inputPins = nodeConfig.getInputs(nodeData || {}) || [];
+            } else if (typeof nodeConfig.computeInputs === 'function') {
+                inputPins = nodeConfig.computeInputs(nodeData || {}) || [];
+            } else if (nodeConfig.pins && Array.isArray(nodeConfig.pins.inputs)) {
+                inputPins = nodeConfig.pins.inputs;
+            }
+        } catch (e) {
+            inputPins = nodeConfig.pins?.inputs || [];
+        }
+
+        return inputPins;
+    }
+
+    static getNodeOutputPins(nodeConfig, nodeData) {
+        if (!nodeConfig) return [];
+
+        let outputPins = [];
+        try {
+            if (typeof nodeConfig.getOutputs === 'function') {
+                outputPins = nodeConfig.getOutputs(nodeData || {}) || [];
+            } else if (typeof nodeConfig.computeOutputs === 'function') {
+                outputPins = nodeConfig.computeOutputs(nodeData || {}) || [];
+            } else if (nodeConfig.pins && Array.isArray(nodeConfig.pins.outputs)) {
+                outputPins = nodeConfig.pins.outputs;
+            }
+        } catch (e) {
+            outputPins = nodeConfig.pins?.outputs || [];
+        }
+
+        return outputPins;
+    }
+
+    static isDataNode(nodeConfig) {
+        const inputPins = GraphValidation.getNodeInputPins(nodeConfig, {});
+        return !inputPins.some(p => p && p.type === 'Exec');
+    }
+}
+
+module.exports = GraphValidation;

package/backend/src/core/NodeDefinition.js

@@ -0,0 +1,138 @@
+/**
+ * Базовый класс для определения ноды в визуальном редакторе.
+ * Используется как единый формат для всех нод - и backend и frontend.
+ */
+class NodeDefinition {
+  constructor(config) {
+    this.type = config.type;
+    this.category = config.category || 'Other';
+    this.label = config.label || config.type;
+    this.description = config.description || '';
+
+    // Функции для вычисления пинов динамически (поддержка conditional pins)
+    this.computeInputs = config.computeInputs || (() => []);
+    this.computeOutputs = config.computeOutputs || (() => []);
+
+    // Статичные пиньи (fallback для обратной совместимости)
+    this.pins = config.pins || { inputs: [], outputs: [] };
+
+    // Исполнители ноды
+    // executor - для action нод с exec пинами (асинхронный)
+    // evaluator - для data пинов (вычисление значений)
+    this.executor = config.executor || null;
+    this.evaluator = config.evaluator || null;
+
+    // Метаданные ноды
+    this.defaultData = config.defaultData || {};
+    this.theme = config.theme || {};
+    this.icon = config.icon || null;
+    this.graphType = config.graphType || 'ALL'; // 'COMMAND', 'EVENT', 'ALL'
+
+    // Валидация
+    if (!this.type) {
+      throw new Error('NodeDefinition: type is required');
+    }
+  }
+
+  /**
+   * Получить входные пиньи для данного состояния ноды
+   * @param {object} data - данные ноды (для условных пиннов)
+   * @returns {Array} массив описаний входных пиннов
+   */
+  getInputs(data = {}) {
+    if (typeof this.computeInputs === 'function') {
+      return this.computeInputs(data);
+    }
+    return this.pins.inputs || [];
+  }
+
+  /**
+   * Получить выходные пиньи для данного состояния ноды
+   * @param {object} data - данные ноды (для условных пиннов)
+   * @returns {Array} массив описаний выходных пиннов
+   */
+  getOutputs(data = {}) {
+    if (typeof this.computeOutputs === 'function') {
+      return this.computeOutputs(data);
+    }
+    return this.pins.outputs || [];
+  }
+
+  /**
+   * Проверить, является ли нода action-нодой (с exec пинами)
+   */
+  isActionNode() {
+    const inputs = this.getInputs();
+    return inputs.some(pin => pin.type === 'Exec');
+  }
+
+  /**
+   * Проверить, является ли нода data-нодой (только вычисляемые значения)
+   */
+  isDataNode() {
+    return !this.isActionNode();
+  }
+
+  /**
+   * Проверить, есть ли у ноды executor
+   */
+  hasExecutor() {
+    return typeof this.executor === 'function';
+  }
+
+  /**
+   * Проверить, есть ли у ноды evaluator
+   */
+  hasEvaluator() {
+    return typeof this.evaluator === 'function';
+  }
+
+  /**
+   * Конвертировать в JSON-сериализуемый формат
+   * Используется для отправки в frontend
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      category: this.category,
+      label: this.label,
+      description: this.description,
+      pins: {
+        inputs: this.pins.inputs || [],
+        outputs: this.pins.outputs || []
+      },
+      defaultData: this.defaultData,
+      theme: this.theme,
+      icon: this.icon,
+      graphType: this.graphType,
+      isActionNode: this.isActionNode()
+    };
+  }
+
+  /**
+   * Получить пин по ID
+   * @param {string} pinId - ID пина
+   * @param {string} direction - 'input' или 'output'
+   */
+  getPin(pinId, direction) {
+    const pins = direction === 'input' ? this.pins.inputs : this.pins.outputs;
+    return pins.find(pin => pin.id === pinId);
+  }
+
+  /**
+   * Проверить, является ли пин обязательным
+   */
+  isPinRequired(pinId, direction = 'input') {
+    const pin = this.getPin(pinId, direction);
+    return pin?.required === true;
+  }
+}
+
+/**
+ * Создать определение ноды с билдером
+ */
+function createNodeDefinition(config) {
+  return new NodeDefinition(config);
+}
+
+module.exports = { NodeDefinition, createNodeDefinition };

package/backend/src/core/NodeRegistry.js

@@ -1,141 +1,153 @@
-const validationService = require('./services/ValidationService');
-const { GRAPH_TYPES } = require('./constants/graphTypes');
-
-/**
- * @typedef {object} NodePin
- * @property {string} id - Уникальный идентификатор пина (например, "exec", "data_result").
- * @property {string} name - Читаемое имя пина.
- * @property {string} type - Тип данных пина ("Exec", "String", "Boolean" и т.д.).
- * @property {boolean} [required] - Является ли этот пин обязательным.
- */
-
-/**
- * @typedef {object} NodeConfig
- * @property {string} type - Уникальный идентификатор типа узла (например, "action:send_message").
- * @property {string} label - Читаемое имя узла.
- * @property {string} category - Категория для группировки в интерфейсе.
- * @property {string} description - Описание узла.
- * @property {NodePin[]} inputs - Массив описаний входных пинов.
- * @property {NodePin[]} outputs - Массив описаний выходных пинов.
- * @property {Function} [executor] - Функция для выполнения этого узла (на бэкенде).
- */
-
-/**
- * Реестр для управления всеми доступными типами узлов.
- */
-class NodeRegistry {
-  constructor() {
-    this.nodes = new Map();
-    this._registerBaseNodes();
-  }
-
-  /**
-   * Регистрирует новый тип узла.
-   * @param {NodeConfig} nodeConfig - Конфигурация узла.
-   */
-  registerNodeType(nodeConfig) {
-    if (!nodeConfig.type) {
-      throw new Error('Node type is required');
-    }
-
-    const validation = validationService.validateNode(nodeConfig, 'NodeRegistry');
-    if (validation.shouldSkip) {
-      return;
-    }
-
-    if (this.nodes.has(nodeConfig.type)) {
-      console.warn(`Node type '${nodeConfig.type}' is already registered. Overriding.`);
-    }
-
-    this.nodes.set(nodeConfig.type, nodeConfig);
-    //console.log(`Registered node type: ${nodeConfig.type}`);
-  }
-
-  /**
-   * Получает конфигурацию узла по его типу.
-   * @param {string} nodeType - Идентификатор типа узла.
-   * @returns {NodeConfig|undefined}
-   */
-  getNodeConfig(nodeType) {
-    return this.nodes.get(nodeType);
-  }
-
-  /**
-   * Получает все зарегистрированные типы узлов.
-   * @returns {NodeConfig[]}
-   */
-  getAllNodes() {
-    return Array.from(this.nodes.values());
-  }
-
-  /**
-   * Возвращает узлы, сгруппированные по категориям.
-   * @param {string} [graphType] - Тип графа ('command' или 'event') для фильтрации узлов.
-   * @returns {Object.<string, NodeConfig[]>} - Объект с узлами, сгруппированными по категориям.
-   */
-  getNodesByCategory(graphType) {
-    const result = {};
-    for (const node of this.nodes.values()) {
-      if (node.graphType === GRAPH_TYPES.ALL || node.graphType === graphType) {
-        if (!result[node.category]) {
-          result[node.category] = [];
-        }
-        result[node.category].push(node);
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Проверяет, существует ли тип узла.
-   * @param {string} nodeType - Идентификатор типа узла.
-   * @returns {boolean}
-   */
-  hasNodeType(nodeType) {
-    return this.nodes.has(nodeType);
-  }
-
-  /**
-   * Регистрирует базовую библиотеку узлов.
-   * Автоматически обнаруживает и загружает все файлы из директории node-registries.
-   * @private
-   */
-  _registerBaseNodes() {
-    const fs = require('fs');
-    const path = require('path');
-
-    const registriesDir = path.join(__dirname, 'node-registries');
-
-    try {
-      // Получаем все файлы .js из директории node-registries
-      const files = fs.readdirSync(registriesDir)
-        .filter(file => file.endsWith('.js'));
-
-      // Загружаем и регистрируем ноды из каждого файла
-      for (const file of files) {
-        try {
-          const registry = require(path.join(registriesDir, file));
-
-          if (typeof registry.registerNodes === 'function') {
-            registry.registerNodes(this);
-          } else {
-            console.warn(`NodeRegistry: Файл ${file} не экспортирует функцию registerNodes`);
-          }
-        } catch (error) {
-          console.error(`NodeRegistry: Ошибка загрузки реестра из ${file}:`, error.message);
-        }
-      }
-
-      console.log(`NodeRegistry: Registered ${this.nodes.size} base nodes from ${files.length} registries`);
-    } catch (error) {
-      console.error('NodeRegistry: Ошибка чтения директории node-registries:', error.message);
-    }
-  }
-
-  getNodesByTypes(types) {
-    return types.map(type => this.nodes.get(type)).filter(Boolean);
-  }
-}
-
-const nodeRegistryInstance = new NodeRegistry();
-module.exports = nodeRegistryInstance;
+const validationService = require('./services/ValidationService');
+const { GRAPH_TYPES } = require('./constants/graphTypes');
+const { NodeDefinition } = require('./NodeDefinition');
+
+class NodeRegistry {
+  constructor() {
+    this.nodes = new Map();
+    this._registerBaseNodes();
+  }
+
+  registerNodeType(config) {
+    if (!config.type) {
+      throw new Error('Node type is required');
+    }
+
+    const validation = validationService.validateNode(config, 'NodeRegistry');
+    if (validation.shouldSkip) {
+      return;
+    }
+
+    if (this.nodes.has(config.type)) {
+      console.warn(`Node type '${config.type}' is already registered. Overriding.`);
+    }
+
+    let nodeDef;
+
+    if (config instanceof NodeDefinition) {
+      nodeDef = config;
+    } else {
+      nodeDef = this._normalizeToNodeDefinition(config);
+    }
+
+    this.nodes.set(config.type, nodeDef);
+  }
+
+  _normalizeToNodeDefinition(config) {
+    const inputs = config.computeInputs
+      ? config.computeInputs
+      : (() => config.pins?.inputs || []);
+
+    const outputs = config.computeOutputs
+      ? config.computeOutputs
+      : (() => config.pins?.outputs || []);
+
+    return new NodeDefinition({
+      type: config.type,
+      category: config.category || 'Other',
+      label: config.label || config.type,
+      description: config.description || '',
+      computeInputs: inputs,
+      computeOutputs: outputs,
+      pins: config.pins || { inputs: [], outputs: [] },
+      executor: config.executor || null,
+      evaluator: config.evaluator || null,
+      defaultData: config.defaultData || {},
+      theme: config.theme || {},
+      icon: config.icon || null,
+      graphType: config.graphType || GRAPH_TYPES.ALL
+    });
+  }
+
+  getNodeConfig(nodeType) {
+    return this.nodes.get(nodeType);
+  }
+
+  getAllNodes() {
+    return Array.from(this.nodes.values());
+  }
+
+  getNodesByCategory(graphType) {
+    const result = {};
+    for (const node of this.nodes.values()) {
+      if (node.graphType === GRAPH_TYPES.ALL || node.graphType === graphType) {
+        if (!result[node.category]) {
+          result[node.category] = [];
+        }
+        result[node.category].push(node);
+      }
+    }
+    return result;
+  }
+
+  hasNodeType(nodeType) {
+    return this.nodes.has(nodeType);
+  }
+
+  getNodesByTypes(types) {
+    return types.map(type => this.nodes.get(type)).filter(Boolean);
+  }
+
+  _registerBaseNodes() {
+    const fs = require('fs');
+    const path = require('path');
+
+    const registriesDir = path.join(__dirname, 'node-registries');
+
+    try {
+      const files = fs.readdirSync(registriesDir)
+        .filter(file => file.endsWith('.js'));
+
+      for (const file of files) {
+        try {
+          const registry = require(path.join(registriesDir, file));
+
+          if (typeof registry.registerNodes === 'function') {
+            registry.registerNodes(this);
+          } else if (Array.isArray(registry)) {
+            for (const def of registry) {
+              this.registerNodeType(def);
+            }
+          } else if (typeof registry.registerNodeDefinitions === 'function') {
+            const definitions = registry.registerNodeDefinitions();
+            for (const def of definitions) {
+              this.registerNodeType(def);
+            }
+          } else if (typeof registry.createNodeDefinitions === 'function' ||
+                     typeof registry.getNodesByCategory === 'function' ||
+                     typeof registry.getAllNodeTypes === 'function') {
+            // Это служебный модуль (index.js), не содержит нод напрямую
+            // Пропускаем без варнинга
+          } else {
+            console.warn(`NodeRegistry: Файл ${file} не экспортирует registerNodes, массив нод или registerNodeDefinitions`);
+          }
+        } catch (error) {
+          console.error(`NodeRegistry: Ошибка загрузки реестра из ${file}:`, error.message);
+        }
+      }
+
+      console.log(`NodeRegistry: Registered ${this.nodes.size} base nodes from ${files.length} registries`);
+    } catch (error) {
+      console.error('NodeRegistry: Ошибка чтения директории node-registries:', error.message);
+    }
+  }
+
+  toJSON() {
+    const result = {};
+    for (const [type, nodeDef] of this.nodes) {
+      result[type] = nodeDef.toJSON();
+    }
+    return result;
+  }
+
+  getNodesByCategoryFlat() {
+    const flat = [];
+    for (const node of this.nodes.values()) {
+      flat.push(node.toJSON());
+    }
+    return flat;
+  }
+}
+
+const nodeRegistryInstance = new NodeRegistry();
+module.exports = nodeRegistryInstance;