blockmine 1.21.0 → 1.23.0

package/backend/src/core/services/__tests__/ValidationService.test.js

@@ -0,0 +1,148 @@
+const validationService = require('../ValidationService');
+const { GRAPH_TYPES } = require('../../constants/graphTypes');
+
+describe('ValidationService', () => {
+    describe('parseGraph', () => {
+        it('should parse JSON string graph', () => {
+            const graphJson = JSON.stringify({ nodes: [], connections: [] });
+            const result = validationService.parseGraph(graphJson, 'test');
+
+            expect(result).toEqual({ nodes: [], connections: [] });
+        });
+
+        it('should return graph object as-is', () => {
+            const graphObj = { nodes: [], connections: [] };
+            const result = validationService.parseGraph(graphObj, 'test');
+
+            expect(result).toBe(graphObj);
+        });
+
+        it('should return null for invalid JSON', () => {
+            const result = validationService.parseGraph('invalid json', 'test');
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('hasValidBasicStructure', () => {
+        it('should return true for valid graph structure', () => {
+            const graph = { nodes: [], connections: [] };
+
+            expect(validationService.hasValidBasicStructure(graph)).toBe(true);
+        });
+
+        it('should return false for graph without nodes', () => {
+            const graph = { connections: [] };
+
+            expect(validationService.hasValidBasicStructure(graph)).toBe(false);
+        });
+
+        it('should return false for graph without connections', () => {
+            const graph = { nodes: [] };
+
+            expect(validationService.hasValidBasicStructure(graph)).toBe(false);
+        });
+
+        it('should return false for null graph', () => {
+            expect(validationService.hasValidBasicStructure(null)).toBe(false);
+        });
+
+        it('should return false for undefined graph', () => {
+            expect(validationService.hasValidBasicStructure(undefined)).toBe(false);
+        });
+    });
+
+    describe('validateGraphStructure', () => {
+        it('should validate correct graph structure', () => {
+            const graph = {
+                nodes: [
+                    {
+                        id: '1',
+                        type: 'event:command',
+                        position: { x: 0, y: 0 },
+                        data: {}
+                    }
+                ],
+                connections: [],
+                variables: []
+            };
+
+            const result = validationService.validateGraphStructure(graph, 'test');
+
+            expect(result.success).toBe(true);
+            expect(result.shouldSkip).toBe(false);
+        });
+
+        it('should fail validation for invalid graph', () => {
+            const graph = {
+                nodes: 'not an array',
+                connections: []
+            };
+
+            // В production mode не выбрасывает исключение, а возвращает shouldSkip: true
+            if (process.env.NODE_ENV === 'production') {
+                const result = validationService.validateGraphStructure(graph, 'test');
+
+                expect(result.success).toBe(false);
+                expect(result.shouldSkip).toBe(true);
+                expect(result.error).toBeDefined();
+            } else {
+                // В dev/test mode выбрасывает исключение
+                expect(() => {
+                    validationService.validateGraphStructure(graph, 'test');
+                }).toThrow('Invalid graph structure');
+            }
+        });
+    });
+
+    describe('validateNode', () => {
+        it('should validate correct node configuration', () => {
+            const nodeConfig = {
+                type: 'test:node',
+                label: 'Test Node',
+                category: 'Test',
+                description: 'Test description',
+                inputs: [],
+                outputs: [],
+                graphType: GRAPH_TYPES.ALL
+            };
+
+            const result = validationService.validateNode(nodeConfig, 'test');
+
+            expect(result.success).toBe(true);
+            expect(result.shouldSkip).toBe(false);
+        });
+
+        it('should fail validation for invalid node', () => {
+            const nodeConfig = {
+                type: 'test:node',
+                // Missing required fields
+            };
+
+            // В production mode не выбрасывает исключение, а возвращает shouldSkip: true
+            if (process.env.NODE_ENV === 'production') {
+                const result = validationService.validateNode(nodeConfig, 'test');
+
+                expect(result.success).toBe(false);
+                expect(result.shouldSkip).toBe(true);
+                expect(result.error).toBeDefined();
+            } else {
+                // В dev/test mode выбрасывает исключение
+                expect(() => {
+                    validationService.validateNode(nodeConfig, 'test');
+                }).toThrow();
+            }
+        });
+    });
+
+    describe('utility methods', () => {
+        it('isValidationEnabled should return true', () => {
+            expect(validationService.isValidationEnabled()).toBe(true);
+        });
+
+        it('isStrictMode should reflect environment', () => {
+            const expected = process.env.NODE_ENV !== 'production';
+            expect(validationService.isStrictMode()).toBe(expected);
+        });
+    });
+});

package/backend/src/core/services.js

@@ -1,11 +1,26 @@
-const botManager = require('./BotManager');
-const PluginManager = require('./PluginManager');
+const { asValue } = require('awilix');
+const configureContainer = require('../container');
 
-const pluginManager = new PluginManager(botManager);
+const container = configureContainer();
+
+const BotManager = require('./BotManager');
+const botManager = new BotManager(container.cradle);
+
+// Регистрируем botManager в контейнере для PluginManager
+container.register({
+    botManager: asValue(botManager)
+});
+
+const pluginManager = container.resolve('pluginManager');
+const eventGraphManager = container.resolve('eventGraphManager');
+
+// EventGraphManager требует botManager через setter из-за циклической зависимости
+eventGraphManager.setBotManager(botManager);
 
 botManager.initialize();
 
 module.exports = {
     botManager,
-    pluginManager
-}; 
+    pluginManager,
+    container
+};

package/backend/src/core/system/CommandContext.js

@@ -0,0 +1,84 @@
+const Transport = require('./Transport');
+const UserService = require('../UserService');
+
+/**
+ * CommandContext - контекст выполнения команды
+ * Предоставляет единый интерфейс для команд независимо от источника (Minecraft, WebSocket, Telegram)
+ */
+class CommandContext {
+    /**
+     * @param {object} bot - Экземпляр бота
+     * @param {object} user - User объект с методами
+     * @param {object} args - Аргументы команды
+     * @param {Transport} transport - Transport объект
+     */
+    constructor(bot, user, args, transport) {
+        this.bot = bot;
+        this.user = user;
+        this.args = args;
+        this.transport = transport;
+
+        // Для обратной совместимости
+        this.typeChat = transport.type;
+        
+        // Добавляем информацию о позиции бота
+        this.botEntity = bot.entity ? {
+            position: bot.entity.position,
+            yaw: bot.entity.yaw,
+            pitch: bot.entity.pitch
+        } : null;
+    }
+
+    /**
+     * Отправить ответ пользователю
+     * @param {string} message - Текст сообщения
+     * @returns {string|void} - Для websocket возвращает message, для остальных void
+     */
+    reply(message) {
+        return this.transport.send(message, this.user.username);
+    }
+
+    /**
+     * Отправить сообщение в определенный чат
+     * @param {string} chatType - Тип чата ('chat', 'clan', 'private', etc)
+     * @param {string} message - Текст сообщения
+     * @param {string} recipient - Получатель (для private)
+     */
+    sendTo(chatType, message, recipient = null) {
+        if (this.bot.api) {
+            this.bot.api.sendMessage(chatType, message, recipient);
+        }
+    }
+
+    /**
+     * Получить User объект с методами
+     * @param {string} username - Имя пользователя
+     * @returns {Promise<User>} - User объект с методами
+     */
+    async getUser(username) {
+        return await UserService.getUser(username, this.bot.config.id, this.bot.config);
+    }
+
+    /**
+     * Проверка, выполняется ли команда через WebSocket API
+     */
+    isWebSocket() {
+        return this.transport.type === 'websocket';
+    }
+
+    /**
+     * Проверка, выполняется ли команда из Minecraft
+     */
+    isMinecraft() {
+        return this.transport.isMinecraftTransport();
+    }
+
+    /**
+     * Получить название транспорта
+     */
+    getTransportName() {
+        return this.transport.getDisplayName();
+    }
+}
+
+module.exports = CommandContext;

package/backend/src/core/system/RuntimeCommandRegistry.js

@@ -0,0 +1,116 @@
+/**
+ * RuntimeCommandRegistry - реестр временных команд, созданных во время выполнения
+ * Хранит команды в памяти для каждого бота
+ */
+class RuntimeCommandRegistry {
+    constructor() {
+        // Map<botId, Map<commandName, Command>>
+        this.commands = new Map();
+    }
+
+    /**
+     * Добавить временную команду для бота
+     * @param {string} botId - ID бота
+     * @param {string} commandName - Имя команды
+     * @param {object} commandData - Данные команды
+     */
+    register(botId, commandName, commandData) {
+        if (!this.commands.has(botId)) {
+            this.commands.set(botId, new Map());
+        }
+
+        const botCommands = this.commands.get(botId);
+        botCommands.set(commandName, commandData);
+    }
+
+    /**
+     * Удалить временную команду
+     * @param {string} botId - ID бота
+     * @param {string} commandName - Имя команды
+     * @returns {boolean} - Успешно ли удалена команда
+     */
+    unregister(botId, commandName) {
+        if (!this.commands.has(botId)) {
+            return false;
+        }
+
+        const botCommands = this.commands.get(botId);
+        return botCommands.delete(commandName);
+    }
+
+    /**
+     * Получить временную команду
+     * @param {string} botId - ID бота
+     * @param {string} commandName - Имя команды
+     * @returns {object|null} - Данные команды или null
+     */
+    get(botId, commandName) {
+        if (!this.commands.has(botId)) {
+            return null;
+        }
+
+        return this.commands.get(botId).get(commandName) || null;
+    }
+
+    /**
+     * Получить все временные команды для бота
+     * @param {string} botId - ID бота
+     * @returns {Map<string, object>} - Map команд
+     */
+    getAllForBot(botId) {
+        return this.commands.get(botId) || new Map();
+    }
+
+    /**
+     * Проверить существование команды
+     * @param {string} botId - ID бота
+     * @param {string} commandName - Имя команды
+     * @returns {boolean}
+     */
+    has(botId, commandName) {
+        if (!this.commands.has(botId)) {
+            return false;
+        }
+
+        return this.commands.get(botId).has(commandName);
+    }
+
+    /**
+     * Очистить все команды для бота (при остановке бота)
+     * @param {string} botId - ID бота
+     */
+    clearForBot(botId) {
+        if (this.commands.has(botId)) {
+            this.commands.delete(botId);
+        }
+    }
+
+    /**
+     * Получить статистику
+     * @returns {object}
+     */
+    getStats() {
+        let totalCommands = 0;
+        for (const botCommands of this.commands.values()) {
+            totalCommands += botCommands.size;
+        }
+
+        return {
+            totalBots: this.commands.size,
+            totalCommands,
+        };
+    }
+}
+
+
+let instance = null;
+
+module.exports = {
+    RuntimeCommandRegistry,
+    getRuntimeCommandRegistry: () => {
+        if (!instance) {
+            instance = new RuntimeCommandRegistry();
+        }
+        return instance;
+    }
+};

package/backend/src/core/system/Transport.js

@@ -0,0 +1,74 @@
+/**
+ * Transport - абстракция для различных способов доставки сообщений
+ * Поддерживает: websocket, minecraft (chat/clan/private/command), telegram (будущее)
+ */
+class Transport {
+    constructor(type, bot = null) {
+        this.type = type; // 'websocket' | 'chat' | 'clan' | 'private' | 'command' | 'telegram'
+        this.bot = bot;
+    }
+
+    /**
+     * Отправить сообщение через этот транспорт
+     * @param {string} message - Текст сообщения
+     * @param {string} recipient - Получатель (для private/telegram)
+     * @returns {string|void} - Для websocket возвращает message, для остальных void
+     */
+    send(message, recipient = null) {
+        if (this.type === 'websocket') {
+            // WebSocket - возвращаем результат как есть
+            return message;
+        } else if (this.isMinecraftTransport()) {
+            // Minecraft - отправляем через бота
+            if (this.bot && this.bot.api) {
+                this.bot.api.sendMessage(this.type, message, recipient);
+            }
+        }
+    }
+
+    /**
+     * Проверка, является ли этот транспорт Minecraft-транспортом
+     */
+    isMinecraftTransport() {
+        return ['chat', 'local', 'clan', 'private', 'command'].includes(this.type);
+    }
+
+    /**
+     * Проверка, является ли этот транспорт универсальным (не требует проверки allowedChatTypes)
+     */
+    isUniversal() {
+        return this.type === 'websocket';
+    }
+
+    /**
+     * Проверка, может ли команда быть выполнена через этот транспорт
+     * @param {Array<string>} allowedTypes - Список разрешенных типов чата из команды
+     */
+    isAllowedFor(allowedTypes) {
+        // Универсальные транспорты всегда разрешены
+        if (this.isUniversal()) {
+            return true;
+        }
+
+        // Для остальных проверяем список разрешенных типов
+        return allowedTypes.includes(this.type);
+    }
+
+    /**
+     * Получить читаемое название транспорта
+     */
+    getDisplayName() {
+        const names = {
+            websocket: 'WebSocket API',
+            chat: 'Общий чат',
+            local: 'Локальный чат',
+            clan: 'Клан',
+            private: 'Личное сообщение',
+            command: 'Команда',
+            telegram: 'Telegram'
+        };
+        return names[this.type] || this.type;
+    }
+}
+
+module.exports = Transport;

package/backend/src/core/utils/__tests__/jsonParser.test.js

@@ -0,0 +1,44 @@
+const { safeJsonParse } = require('../jsonParser');
+
+describe('safeJsonParse', () => {
+    it('should parse valid JSON string', () => {
+        const result = safeJsonParse('{"key":"value"}', null, 'test');
+        expect(result).toEqual({ key: 'value' });
+    });
+
+    it('should return default value for invalid JSON', () => {
+        const result = safeJsonParse('{invalid}', { default: true }, 'test');
+        expect(result).toEqual({ default: true });
+    });
+
+    it('should handle null input', () => {
+        const result = safeJsonParse(null, 'default', 'test');
+        expect(result).toBe('default');
+    });
+
+    it('should handle undefined input', () => {
+        const result = safeJsonParse(undefined, 'default', 'test');
+        expect(result).toBe('default');
+    });
+
+    it('should return non-string values as-is', () => {
+        const obj = { key: 'value' };
+        const result = safeJsonParse(obj, null, 'test');
+        expect(result).toBe(obj);
+    });
+
+    it('should parse arrays correctly', () => {
+        const result = safeJsonParse('[1,2,3]', [], 'test');
+        expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('should return default for malformed JSON', () => {
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+        const result = safeJsonParse('{"key": undefined}', [], 'test');
+
+        expect(result).toEqual([]);
+        expect(consoleSpy).toHaveBeenCalled();
+
+        consoleSpy.mockRestore();
+    });
+});

package/backend/src/core/utils/jsonParser.js

@@ -0,0 +1,18 @@
+function safeJsonParse(jsonString, defaultValue = null, context = 'unknown') {
+    if (jsonString === null || jsonString === undefined) {
+        return defaultValue;
+    }
+
+    if (typeof jsonString !== 'string') {
+        return jsonString;
+    }
+
+    try {
+        return JSON.parse(jsonString);
+    } catch (error) {
+        console.error(`[JSONParser] Failed to parse JSON in ${context}:`, error.message);
+        return defaultValue;
+    }
+}
+
+module.exports = { safeJsonParse };