blockmine 1.21.0 → 1.23.0

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/not.js

@@ -0,0 +1,22 @@
+/**
+ * @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 value = await resolvePinValue(node, 'value', false);
+        return !value;
+    }
+
+    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/strings/__tests__/concat.test.js

@@ -0,0 +1,89 @@
+describe('strings:concat node', () => {
+    const stringConcat = require('../concat');
+
+    const mockHelpers = (...strings) => ({
+        resolvePinValue: jest.fn(async (node, pinId, defaultValue) => {
+            const match = pinId.match(/^pin_(\d+)$/);
+            if (match) {
+                const index = parseInt(match[1]);
+                return strings[index] !== undefined ? strings[index] : defaultValue;
+            }
+            return defaultValue;
+        }),
+    });
+
+    it('should concatenate two strings', async () => {
+        const node = { id: 'test', data: { pinCount: 2 } };
+        const helpers = mockHelpers('Hello', ' World');
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('Hello World');
+    });
+
+    it('should concatenate multiple strings', async () => {
+        const node = { id: 'test', data: { pinCount: 4 } };
+        const helpers = mockHelpers('A', 'B', 'C', 'D');
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('ABCD');
+    });
+
+    it('should handle empty strings', async () => {
+        const node = { id: 'test', data: { pinCount: 3 } };
+        const helpers = mockHelpers('Hello', '', 'World');
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('HelloWorld');
+    });
+
+    it('should use default pinCount of 2', async () => {
+        const node = { id: 'test', data: {} };
+        const helpers = mockHelpers('A', 'B');
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('AB');
+    });
+
+    it('should handle non-string inputs by converting to string', async () => {
+        const node = { id: 'test', data: { pinCount: 4 } };
+        const helpers = mockHelpers('String: ', 123, ' Boolean: ', true);
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('String: 123 Boolean: true');
+    });
+
+    it('should handle null and undefined inputs', async () => {
+        const node = { id: 'test', data: { pinCount: 4 } };
+        const helpers = mockHelpers('Value: ', null, ' | ', undefined);
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        // null и undefined заменяются на пустые строки в текущей реализации
+        expect(result).toBe('Value:  | ');
+    });
+
+    it('should handle very large number of inputs', async () => {
+        const node = { id: 'test', data: { pinCount: 100 } };
+        const inputs = Array(100).fill('x');
+        const helpers = mockHelpers(...inputs);
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('x'.repeat(100));
+        expect(result.length).toBe(100);
+    });
+
+    it('should handle object inputs by stringifying', async () => {
+        const node = { id: 'test', data: { pinCount: 2 } };
+        const helpers = mockHelpers('Object: ', { key: 'value' });
+
+        const result = await stringConcat.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe('Object: [object Object]');
+    });
+});

package/backend/src/core/nodes/{string_starts_with.js → strings/starts_with.js}

@@ -23,7 +23,7 @@ async function evaluate(node, pinId, context, helpers) {
     const { resolvePinValue } = helpers;
 
     if (pinId === 'result') {
-        const str = String(await resolvePinValue(node, 'string', ''));
+        const str = String(await resolvePinValue(node, 'text', ''));
         const prefix = String(await resolvePinValue(node, 'prefix', ''));
         const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
 

package/backend/src/core/nodes/strings/to_lower.js

@@ -0,0 +1,22 @@
+/**
+ * @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 text = String(await resolvePinValue(node, 'text', ''));
+        return text.toLowerCase();
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/strings/to_upper.js

@@ -0,0 +1,22 @@
+/**
+ * @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 text = String(await resolvePinValue(node, 'text', ''));
+        return text.toUpperCase();
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/time/__tests__/now.test.js

@@ -0,0 +1,24 @@
+describe('time:now node', () => {
+    const timeNow = require('../now');
+
+    it('should return current date from now pin', async () => {
+        const node = { id: 'test', type: 'time:now' };
+        const context = {};
+        const helpers = {};
+
+        const result = await timeNow.evaluate(node, 'now', context, helpers);
+
+        expect(result).toBeInstanceOf(Date);
+        expect(result.getTime()).toBeLessThanOrEqual(Date.now());
+    });
+
+    it('should return null for unknown pin', async () => {
+        const node = { id: 'test', type: 'time:now' };
+        const context = {};
+        const helpers = {};
+
+        const result = await timeNow.evaluate(node, 'unknown', context, helpers);
+
+        expect(result).toBeNull();
+    });
+});

package/backend/src/core/nodes/time/add.js

@@ -0,0 +1,33 @@
+const { add } = require('date-fns');
+
+/**
+ * @param {object} node
+ * @param {string} pinId
+ * @param {object} context
+ * @param {object} helpers
+ * @returns {Promise<any>}
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const date = await resolvePinValue(node, 'date', new Date());
+        const duration = await resolvePinValue(node, 'duration', {});
+
+        if (date instanceof Date && !isNaN(date.getTime())) {
+            try {
+                return add(date, duration);
+            } catch (error) {
+                // Либо пробросить ошибку, либо вернуть null
+                throw new Error(`Ошибка добавления продолжительности: ${error.message}`);
+            }
+        }
+        throw new Error('Невалидная входная дата');
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,35 @@
+const { isAfter, isBefore, isEqual } = require('date-fns');
+
+/**
+ * @param {object} node
+ * @param {string} pinId
+ * @param {object} context
+ * @param {object} helpers
+ * @returns {Promise<any>}
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const dateLeft = await resolvePinValue(node, 'date_left', new Date());
+        const dateRight = await resolvePinValue(node, 'date_right', new Date());
+        const op = await resolvePinValue(node, 'operation', 'after');
+
+        if (dateLeft instanceof Date && !isNaN(dateLeft.getTime()) &&
+            dateRight instanceof Date && !isNaN(dateRight.getTime())) {
+            switch (op) {
+                case 'after': return isAfter(dateLeft, dateRight);
+                case 'before': return isBefore(dateLeft, dateRight);
+                case 'equal': return isEqual(dateLeft, dateRight);
+                default: return false;
+            }
+        }
+        return false;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/time/diff.js

@@ -0,0 +1,29 @@
+const { differenceInMilliseconds } = require('date-fns');
+
+/**
+ * @param {object} node
+ * @param {string} pinId
+ * @param {object} context
+ * @param {object} helpers
+ * @returns {Promise<any>}
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'diff') {
+        const dateLeft = await resolvePinValue(node, 'date_left', new Date());
+        const dateRight = await resolvePinValue(node, 'date_right', new Date());
+
+        if (dateLeft instanceof Date && !isNaN(dateLeft.getTime()) &&
+            dateRight instanceof Date && !isNaN(dateRight.getTime())) {
+            return differenceInMilliseconds(dateLeft, dateRight);
+        }
+        return 0;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/time/format.js

@@ -0,0 +1,32 @@
+const { format } = require('date-fns');
+
+/**
+ * @param {object} node
+ * @param {string} pinId
+ * @param {object} context
+ * @param {object} helpers
+ * @returns {Promise<any>}
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'formatted') {
+        const date = await resolvePinValue(node, 'date', new Date());
+        const formatString = await resolvePinValue(node, 'format', 'yyyy-MM-dd HH:mm:ss');
+
+        if (date instanceof Date && !isNaN(date.getTime())) {
+            try {
+                return format(date, formatString);
+            } catch (error) {
+                throw new Error(`Ошибка форматирования: ${error.message}`);
+            }
+        }
+        throw new Error('Ошибка: невалидная дата');
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/time/now.js

@@ -0,0 +1,18 @@
+/**
+ * @param {object} node
+ * @param {string} pinId
+ * @param {object} context
+ * @param {object} helpers
+ * @returns {Promise<any>}
+ */
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId === 'now') {
+        return new Date();
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/type/to_string.js

@@ -0,0 +1,32 @@
+/**
+ * @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 value = await resolvePinValue(node, 'value', '');
+
+        // Преобразуем в строку
+        if (value === null || value === undefined) {
+            return '';
+        }
+
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+
+        return String(value);
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/{user_check_blacklist.js → users/check_blacklist.js}

@@ -1,37 +1,37 @@
-const User = require('../UserService');
-
-/**
- * @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;
-
-    const userIdentifier = await resolvePinValue(node, 'user', null);
-    let isBlacklisted = false;
-    let usernameToFind = null;
-
-    if (typeof userIdentifier === 'string') {
-        usernameToFind = userIdentifier;
-    } else if (userIdentifier && typeof userIdentifier === 'object' && userIdentifier.username) {
-        usernameToFind = userIdentifier.username;
-    }
-
-    if (usernameToFind) {
-        const user = await User.getUser(usernameToFind, context.botId);
-        if (user) {
-            isBlacklisted = user.isBlacklisted;
-        }
-    }
-    
-    // Этот узел имеет только один выходной пин данных
-    return isBlacklisted;
-}
-
-module.exports = {
-    evaluate,
-};
+const User = require('../../UserService');
+
+/**
+ * @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;
+
+    const userIdentifier = await resolvePinValue(node, 'user', null);
+    let isBlacklisted = false;
+    let usernameToFind = null;
+
+    if (typeof userIdentifier === 'string') {
+        usernameToFind = userIdentifier;
+    } else if (userIdentifier && typeof userIdentifier === 'object' && userIdentifier.username) {
+        usernameToFind = userIdentifier.username;
+    }
+
+    if (usernameToFind) {
+        const user = await User.getUser(usernameToFind, context.botId);
+        if (user) {
+            isBlacklisted = user.isBlacklisted;
+        }
+    }
+    
+    // Этот узел имеет только один выходной пин данных
+    return isBlacklisted;
+}
+
+module.exports = {
+    evaluate,
+};