blockmine 1.20.0 → 1.22.0

package/backend/src/core/nodes/flow/break.js

@@ -0,0 +1,14 @@
+const BreakLoopSignal = require('../../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ */
+async function execute(node, context, helpers) {
+    throw new BreakLoopSignal();
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow/delay.js

@@ -0,0 +1,43 @@
+/**
+ * Узел задержки выполнения.
+ *
+ * Логика:
+ * - Ждет указанное количество миллисекунд.
+ * - После ожидания продолжает выполнение по выходу exec.
+ *
+ * Использование в графе:
+ * - Вход exec подключается от предыдущего действия.
+ * - Вход delay (Number) можно задать константой или подать с другого узла.
+ * - Выход exec соединяется с следующим действием.
+ */
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    // Значение задержки в миллисекундах.
+    // Можно задать как data.delay в ноде, либо через входной пин delay.
+    let delayMs = await resolvePinValue(node, 'delay', node.data?.delay ?? 0);
+
+    // Нормализуем значение
+    delayMs = Number(delayMs);
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+        delayMs = 0;
+    }
+
+    if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow/for_each.js

@@ -0,0 +1,39 @@
+const BreakLoopSignal = require('../../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {Map} helpers.memo - Карта для мемоизации значений в рамках одного выполнения графа.
+ * @param {function} helpers.clearLoopBodyMemo - Функция для очистки мемоизации внутри тела цикла.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo, clearLoopBodyMemo } = helpers;
+
+    const array = await resolvePinValue(node, 'array', []);
+    if (Array.isArray(array)) {
+        try {
+            for (let i = 0; i < array.length; i++) {
+                const element = array[i];
+                memo.set(`${node.id}:element`, element);
+                memo.set(`${node.id}:index`, i);
+                clearLoopBodyMemo(node);
+                await traverse(node, 'loop_body');
+            }
+        } catch (e) {
+            if (e instanceof BreakLoopSignal) {
+                // Цикл был прерван узлом Break, это ожидаемое поведение.
+            } else {
+                // Перебрасываем другие, неожиданные ошибки.
+                throw e;
+            }
+        }
+    }
+    await traverse(node, 'completed');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow/sequence.js

@@ -0,0 +1,16 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const pinCount = node.data?.pinCount || 2;
+    for (let i = 0; i < pinCount; i++) {
+        await helpers.traverse(node, `exec_${i}`);
+    }
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow/switch.js

@@ -0,0 +1,47 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const value = await resolvePinValue(node, 'value');
+    const caseCount = node.data?.caseCount || 0;
+    let matched = false;
+
+    for (let i = 0; i < caseCount; i++) {
+        const caseValue = node.data?.[`case_${i}`];
+        if (caseValue !== undefined) {
+            let isMatch = false;
+
+            if (Array.isArray(value) && Array.isArray(caseValue)) {
+                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
+            } else if (typeof value === 'object' && typeof caseValue === 'object' && value !== null && caseValue !== null) {
+                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
+            } else if (typeof value === 'number' && typeof caseValue === 'number') {
+                isMatch = value === caseValue;
+            } else if (typeof value === 'boolean' && typeof caseValue === 'boolean') {
+                isMatch = value === caseValue;
+            } else {
+                isMatch = String(value) === String(caseValue);
+            }
+
+            if (isMatch) {
+                await traverse(node, `case_${i}`);
+                matched = true;
+                break;
+            }
+        }
+    }
+
+    if (!matched) {
+        await traverse(node, 'default');
+    }
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow/while.js

@@ -0,0 +1,64 @@
+const BreakLoopSignal = require('../../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {function} helpers.clearLoopBodyMemo - Функция для очистки мемоизации тела цикла.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, clearLoopBodyMemo, memo } = helpers;
+
+    let iteration = 0;
+    const maxIterations = 1000;
+
+    try {
+        while (iteration < maxIterations) {
+            const condition = await resolvePinValue(node, 'condition', false);
+            if (!condition) break;
+
+            memo.set(`${node.id}:iteration`, iteration);
+            clearLoopBodyMemo(node);
+            await traverse(node, 'loop_body');
+            iteration++;
+        }
+
+        if (iteration >= maxIterations) {
+            console.warn(`[GraphExecutionEngine] Цикл while достиг максимального количества итераций (${maxIterations})`);
+        }
+    } catch (e) {
+        if (e instanceof BreakLoopSignal) {
+            // Прерывание цикла - это нормально
+        } else {
+            throw e;
+        }
+    }
+
+    await traverse(node, 'completed');
+}
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { memo } = helpers;
+
+    if (pinId === 'iteration') {
+        return memo.get(`${node.id}:iteration`);
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

package/backend/src/core/nodes/logic/__tests__/compare.test.js

@@ -0,0 +1,83 @@
+describe('logic:compare node', () => {
+    const logicCompare = require('../compare');
+
+    const mockHelpers = (aValue, bValue) => ({
+        resolvePinValue: jest.fn(async (node, pinId) => {
+            if (pinId === 'a') return aValue;
+            if (pinId === 'b') return bValue;
+            return null;
+        }),
+    });
+
+    it('should compare greater than', async () => {
+        const node = { id: 'test', data: { operation: '>' } };
+        const helpers = mockHelpers(10, 5);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare less than', async () => {
+        const node = { id: 'test', data: { operation: '<' } };
+        const helpers = mockHelpers(5, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare equals', async () => {
+        const node = { id: 'test', data: { operation: '==' } };
+        const helpers = mockHelpers(10, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare not equals', async () => {
+        const node = { id: 'test', data: { operation: '!=' } };
+        const helpers = mockHelpers(10, 5);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare greater or equal', async () => {
+        const node = { id: 'test', data: { operation: '>=' } };
+        const helpers = mockHelpers(10, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare less or equal', async () => {
+        const node = { id: 'test', data: { operation: '<=' } };
+        const helpers = mockHelpers(5, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should handle string comparison', async () => {
+        const node = { id: 'test', data: { operation: '<' } };
+        const helpers = mockHelpers('apple', 'banana');
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should default to equals if no operation specified', async () => {
+        const node = { id: 'test', data: {} };
+        const helpers = mockHelpers(5, 5);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+});

package/backend/src/core/nodes/logic/compare.js

@@ -0,0 +1,33 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const op = node.data?.operation || '==';
+        const valA = await resolvePinValue(node, 'a');
+        const valB = await resolvePinValue(node, 'b');
+
+        switch (op) {
+            case '==': return valA == valB;
+            case '!=': return valA != valB;
+            case '>': return valA > valB;
+            case '<': return valA < valB;
+            case '>=': return valA >= valB;
+            case '<=': return valA <= valB;
+            default: return false;
+        }
+    }
+
+    return false;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/logic/operation.js

@@ -0,0 +1,35 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const op = node.data?.operation || 'AND';
+        const inputs = [];
+        const pinCount = node.data?.pinCount || 2;
+
+        for (let i = 0; i < pinCount; i++) {
+            const value = await resolvePinValue(node, `pin_${i}`, false);
+            inputs.push(value);
+        }
+
+        switch (op) {
+            case 'AND': return inputs.every(Boolean);
+            case 'OR': return inputs.some(Boolean);
+            case 'NOT': return !inputs[0];
+            default: return false;
+        }
+    }
+
+    return false;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/math/__tests__/operation.test.js

@@ -0,0 +1,65 @@
+describe('math:operation node', () => {
+    const mathOperation = require('../operation');
+
+    const mockHelpers = (aValue, bValue) => ({
+        resolvePinValue: jest.fn(async (node, pinId, defaultValue) => {
+            if (pinId === 'a') return aValue;
+            if (pinId === 'b') return bValue;
+            return defaultValue;
+        }),
+    });
+
+    it('should add two numbers', async () => {
+        const node = { id: 'test', data: { operation: '+' } };
+        const helpers = mockHelpers(5, 3);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(8);
+    });
+
+    it('should subtract two numbers', async () => {
+        const node = { id: 'test', data: { operation: '-' } };
+        const helpers = mockHelpers(10, 3);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(7);
+    });
+
+    it('should multiply two numbers', async () => {
+        const node = { id: 'test', data: { operation: '*' } };
+        const helpers = mockHelpers(4, 5);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(20);
+    });
+
+    it('should divide two numbers', async () => {
+        const node = { id: 'test', data: { operation: '/' } };
+        const helpers = mockHelpers(20, 4);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(5);
+    });
+
+    it('should handle division by zero', async () => {
+        const node = { id: 'test', data: { operation: '/' } };
+        const helpers = mockHelpers(10, 0);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(0);
+    });
+
+    it('should default to addition if operation not specified', async () => {
+        const node = { id: 'test', data: {} };
+        const helpers = mockHelpers(5, 3);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(8);
+    });
+});

package/backend/src/core/nodes/math/operation.js

@@ -0,0 +1,31 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const op = node.data?.operation || '+';
+        const a = Number(await resolvePinValue(node, 'a', 0));
+        const b = Number(await resolvePinValue(node, 'b', 0));
+
+        switch (op) {
+            case '+': return a + b;
+            case '-': return a - b;
+            case '*': return a * b;
+            case '/': return b !== 0 ? a / b : 0;
+            default: return 0;
+        }
+    }
+
+    return 0;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/math/random_number.js

@@ -0,0 +1,43 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const minRaw = await resolvePinValue(node, 'min', node.data.min ?? '0');
+        const maxRaw = await resolvePinValue(node, 'max', node.data.max ?? '1');
+
+        const minStr = String(minRaw);
+        const maxStr = String(maxRaw);
+
+        const min = parseFloat(minStr.replace(',', '.'));
+        const max = parseFloat(maxStr.replace(',', '.'));
+
+        if (isNaN(min) || isNaN(max)) {
+            return NaN;
+        }
+
+        const produceFloat = minStr.includes('.') || minStr.includes(',') || !Number.isInteger(min) ||
+                            maxStr.includes('.') || maxStr.includes(',') || !Number.isInteger(max);
+
+        if (produceFloat) {
+            return Math.random() * (max - min) + min;
+        } else {
+            const minInt = Math.ceil(min);
+            const maxInt = Math.floor(max);
+            return Math.floor(Math.random() * (maxInt - minInt + 1)) + minInt;
+        }
+    }
+
+    return 0;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/objects/create.js

@@ -0,0 +1,40 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'object') {
+        if (node.data?.advanced) {
+            try {
+                return JSON.parse(node.data.jsonValue || '{}');
+            } catch (e) {
+                console.error('Ошибка парсинга JSON в object:create:', e);
+                return {};
+            }
+        } else {
+            const numPins = node.data?.pinCount || 0;
+            const obj = {};
+
+            for (let i = 0; i < numPins; i++) {
+                const key = node.data[`key_${i}`];
+                if (key) {
+                    obj[key] = await resolvePinValue(node, `value_${i}`);
+                }
+            }
+
+            return obj;
+        }
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/objects/delete.js

@@ -0,0 +1,26 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'new_object') {
+        const obj = await resolvePinValue(node, 'object', {});
+        const key = await resolvePinValue(node, 'key', '');
+
+        const newObj = { ...obj };
+        delete newObj[key];
+        return newObj;
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/objects/get.js

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers, defaultValue = null) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'value') {
+        const obj = await resolvePinValue(node, 'object', {});
+        const key = await resolvePinValue(node, 'key', '');
+        return obj[key] ?? defaultValue;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/objects/has_key.js

@@ -0,0 +1,30 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue, memo } = helpers;
+
+    const obj = await resolvePinValue(node, 'object', {});
+    const key = await resolvePinValue(node, 'key', '');
+    const exists = obj.hasOwnProperty(key);
+
+    memo.set(`${node.id}:value`, exists ? obj[key] : null);
+
+    if (pinId === 'result') {
+        return exists;
+    } else if (pinId === 'value') {
+        return memo.get(`${node.id}:value`);
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};