blockmine 1.20.0 → 1.22.0

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

@@ -0,0 +1,27 @@
+/**
+ * @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 val = await resolvePinValue(node, 'value');
+
+        const newObj = { ...obj };
+        newObj[key] = val;
+        return newObj;
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

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/strings/concat.js

@@ -0,0 +1,27 @@
+/**
+ * @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 pinCount = node.data?.pinCount || 2;
+        let finalString = '';
+        for (let i = 0; i < pinCount; i++) {
+            const part = await resolvePinValue(node, `pin_${i}`, '');
+            finalString += String(part ?? '');
+        }
+        return finalString;
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,41 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { traverse } = helpers;
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 haystack = String(await resolvePinValue(node, 'haystack', ''));
+        const needle = String(await resolvePinValue(node, 'needle', ''));
+        const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
+
+        if (caseSensitive) {
+            return haystack.includes(needle);
+        } else {
+            return haystack.toLowerCase().includes(needle.toLowerCase());
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

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

@@ -0,0 +1,43 @@
+/**
+ * @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;
+
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 str = String(await resolvePinValue(node, 'string', ''));
+        const suffix = String(await resolvePinValue(node, 'suffix', ''));
+        const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
+
+        if (caseSensitive) {
+            return str.endsWith(suffix);
+        } else {
+            return str.toLowerCase().endsWith(suffix.toLowerCase());
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

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

@@ -0,0 +1,36 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { traverse } = helpers;
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 strA = String(await resolvePinValue(node, 'a', ''));
+        const strB = String(await resolvePinValue(node, 'b', ''));
+        const caseSensitive = node.data?.case_sensitive ?? true;
+        return caseSensitive ? strA === strB : strA.toLowerCase() === strB.toLowerCase();
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

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

@@ -0,0 +1,36 @@
+/**
+ * @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;
+
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 === 'length') {
+        const str = String(await resolvePinValue(node, 'string', ''));
+        return str.length;
+    }
+
+    return 0;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

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

@@ -0,0 +1,39 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { traverse } = helpers;
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 str = String(await resolvePinValue(node, 'string', ''));
+        const regexStr = String(await resolvePinValue(node, 'regex', ''));
+        try {
+            return new RegExp(regexStr).test(str);
+        } catch (e) {
+            return false;
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

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

@@ -0,0 +1,37 @@
+/**
+ * @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;
+
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 === 'array') {
+        const str = String(await resolvePinValue(node, 'string', ''));
+        const separator = String(await resolvePinValue(node, 'separator', ''));
+        return str.split(separator);
+    }
+
+    return [];
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

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

@@ -0,0 +1,43 @@
+/**
+ * @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;
+
+    await traverse(node, 'exec');
+}
+
+/**
+ * @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 str = String(await resolvePinValue(node, 'string', ''));
+        const prefix = String(await resolvePinValue(node, 'prefix', ''));
+        const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
+
+        if (caseSensitive) {
+            return str.startsWith(prefix);
+        } else {
+            return str.toLowerCase().startsWith(prefix.toLowerCase());
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    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/users/check_blacklist.js

@@ -0,0 +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,
+};