blockmine 1.21.0 → 1.22.0

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/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/{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,
+};

package/backend/src/core/nodes/{user_get_groups.js → users/get_groups.js}

@@ -1,36 +1,36 @@
-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 groups = [];
-    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 && user.groups) {
-            groups = user.groups.map(g => g.group.name);
-        }
-    }
-    
-    return groups;
-}
-
-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 groups = [];
+    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 && user.groups) {
+            groups = user.groups.map(g => g.group.name);
+        }
+    }
+    
+    return groups;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/{user_get_permissions.js → users/get_permissions.js}

@@ -1,36 +1,36 @@
-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 permissions = [];
-    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 && user.permissionsSet) {
-            permissions = Array.from(user.permissionsSet);
-        }
-    }
-    
-    return permissions;
-}
-
-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 permissions = [];
+    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 && user.permissionsSet) {
+            permissions = Array.from(user.permissionsSet);
+        }
+    }
+    
+    return permissions;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/{user_set_blacklist.js → users/set_blacklist.js}

@@ -1,37 +1,37 @@
-const User = require('../UserService');
-const { PrismaClient } = require('@prisma/client');
-const prisma = new PrismaClient();
-
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- * @param {Map} helpers.memo - Карта для мемоизации значений.
- */
-async function execute(node, context, helpers) {
-    const { resolvePinValue, traverse, memo } = helpers;
-
-    const userObject = await resolvePinValue(node, 'user', null);
-    const blacklistStatus = await resolvePinValue(node, 'blacklist_status', false);
-    let updatedUser = null;
-    
-    if (userObject && userObject.username) {
-        const user = await User.getUser(userObject.username, context.botId);
-        if (user) {
-            updatedUser = await prisma.user.update({
-                where: { id: user.id },
-                data: { isBlacklisted: blacklistStatus }
-            });
-            User.clearCache(userObject.username, context.botId);
-        }
-    }
-    
-    memo.set(`${node.id}:updated_user`, updatedUser);
-    await traverse(node, 'exec');
-}
-
-module.exports = {
-    execute,
-};
+const User = require('../../UserService');
+const prismaService = require('../../PrismaService');
+const prisma = prismaService.getClient();
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {Map} helpers.memo - Карта для мемоизации значений.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo } = helpers;
+
+    const userObject = await resolvePinValue(node, 'user', null);
+    const blacklistStatus = await resolvePinValue(node, 'blacklist_status', false);
+    let updatedUser = null;
+    
+    if (userObject && userObject.username) {
+        const user = await User.getUser(userObject.username, context.botId);
+        if (user) {
+            updatedUser = await prisma.user.update({
+                where: { id: user.id },
+                data: { isBlacklisted: blacklistStatus }
+            });
+            User.clearCache(userObject.username, context.botId);
+        }
+    }
+    
+    memo.set(`${node.id}:updated_user`, updatedUser);
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};