n8n-nodes-chat2crm 0.1.15 → 0.1.17

package/dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js

@@ -97,13 +97,23 @@ class Chat2CrmTrigger {
         const redisConnections = new Map();
         for (const db of streamsByDb.keys()) {
             // Создаем отдельное соединение для каждой базы данных
+            // ВАЖНО: Каждое соединение уже настроено на свою базу данных через параметр db
             const redis = await RedisConnection_1.createRedisConnection.call(this, credentials, db);
             redisConnections.set(db, redis);
-            // ДИАГНОСТИКА: Проверяем, что соединение использует правильную базу данных
+            // ДИАГНОСТИКА: Сразу после создания соединения проверяем stream'ы
             try {
-                // Проверяем все ключи сразу после подключения
                 const testKeys = await redis.keys('*');
-                console.log(`[Chat2Crm Trigger] Test keys in DB ${db} after connection:`, testKeys);
+                console.log(`[Chat2Crm Trigger] Keys in DB ${db} immediately after connection:`, testKeys);
+                // Проверяем конкретно N8N_INCOMING_MESSAGE
+                if (streamsByDb.get(db)?.includes('N8N_INCOMING_MESSAGE')) {
+                    try {
+                        const testInfo = await redis.xinfo('STREAM', 'N8N_INCOMING_MESSAGE');
+                        console.log(`[Chat2Crm Trigger] N8N_INCOMING_MESSAGE found immediately after connection!`, testInfo);
+                    }
+                    catch (e) {
+                        console.error(`[Chat2Crm Trigger] N8N_INCOMING_MESSAGE NOT found immediately after connection:`, e.message);
+                    }
+                }
             }
             catch (error) {
                 console.error(`[Chat2Crm Trigger] Error checking keys in DB ${db}:`, error.message);
@@ -111,6 +121,10 @@ class Chat2CrmTrigger {
         }
         // Храним последние прочитанные ID для каждого stream
         const lastReadIds = new Map();
+        // ИСПРАВЛЕНИЕ: Добавляем флаг для предотвращения параллельных вызовов
+        let isReading = false;
+        // ИСПРАВЛЕНИЕ: Добавляем Set для отслеживания уже обработанных messageId
+        const processedMessageIds = new Set();
         // Собираем информацию о найденных streams для вывода
         const foundStreams = [];
         // Инициализируем lastReadIds для каждого stream и собираем информацию
@@ -120,6 +134,18 @@ class Chat2CrmTrigger {
             try {
                 const selectResult = await redis.select(db);
                 console.log(`[Chat2Crm Trigger] SELECT ${db} result:`, selectResult);
+                // ДИАГНОСТИКА: Проверяем текущую базу данных через CLIENT INFO или другой способ
+                // Попробуем напрямую проверить stream после SELECT
+                for (const stream of dbStreams) {
+                    try {
+                        console.log(`[Chat2Crm Trigger] Direct XINFO check for "${stream}" immediately after SELECT ${db}`);
+                        const directInfo = await redis.xinfo('STREAM', stream);
+                        console.log(`[Chat2Crm Trigger] Direct XINFO SUCCESS for "${stream}":`, directInfo);
+                    }
+                    catch (directError) {
+                        console.error(`[Chat2Crm Trigger] Direct XINFO FAILED for "${stream}":`, directError.message);
+                    }
+                }
                 // ДИАГНОСТИКА: Проверяем все stream'ы через SCAN
                 const streamKeys = [];
                 let cursor = '0';
@@ -135,6 +161,24 @@ class Chat2CrmTrigger {
                 } while (cursor !== '0');
                 console.log(`[Chat2Crm Trigger] Found ${streamKeys.length} streams in DB ${db}:`, streamKeys);
                 console.log(`[Chat2Crm Trigger] Looking for:`, dbStreams);
+                // ДИАГНОСТИКА: Проверяем конкретно N8N_INCOMING_MESSAGE через разные методы
+                if (dbStreams.includes('N8N_INCOMING_MESSAGE')) {
+                    console.log(`[Chat2Crm Trigger] Special check for N8N_INCOMING_MESSAGE in DB ${db}`);
+                    try {
+                        const exists = await redis.exists('N8N_INCOMING_MESSAGE');
+                        console.log(`[Chat2Crm Trigger] EXISTS check for N8N_INCOMING_MESSAGE:`, exists);
+                    }
+                    catch (e) {
+                        console.error(`[Chat2Crm Trigger] EXISTS check failed:`, e.message);
+                    }
+                    try {
+                        const type = await redis.type('N8N_INCOMING_MESSAGE');
+                        console.log(`[Chat2Crm Trigger] TYPE check for N8N_INCOMING_MESSAGE:`, type);
+                    }
+                    catch (e) {
+                        console.error(`[Chat2Crm Trigger] TYPE check failed:`, e.message);
+                    }
+                }
             }
             catch (error) {
                 console.error(`[Chat2Crm Trigger] Failed to select DB ${db}:`, error.message);
@@ -202,87 +246,97 @@ class Chat2CrmTrigger {
         let isClosing = false;
         // Функция для чтения сообщений
         const readMessages = async () => {
-            // Проверяем, не закрывается ли триггер
-            if (isClosing) {
+            // ИСПРАВЛЕНИЕ: Предотвращаем параллельные вызовы
+            if (isReading || isClosing) {
                 return;
             }
-            for (const [db, dbStreams] of streamsByDb.entries()) {
-                // Проверяем снова перед каждой итерацией
-                if (isClosing) {
-                    break;
-                }
-                const redis = redisConnections.get(db);
-                // Читаем каждый stream отдельно через XREAD
-                // XREAD читает напрямую из stream, независимо от consumer groups
-                for (const stream of dbStreams) {
+            isReading = true;
+            try {
+                for (const [db, dbStreams] of streamsByDb.entries()) {
                     if (isClosing) {
                         break;
                     }
-                    try {
-                        const lastId = lastReadIds.get(stream) || '$';
-                        // Используем более короткий block time для возможности быстрого закрытия
-                        const blockTime = isClosing ? 0 : Math.min(block, MAX_BLOCK_TIME_FOR_RESPONSIVENESS_MS);
-                        // Используем XREAD чтобы читать все сообщения напрямую из stream
-                        // Это позволяет читать сообщения даже если они уже обработаны другими consumer'ами
-                        const messages = await redis.xread('COUNT', count, 'BLOCK', blockTime, 'STREAMS', stream, lastId);
-                        // Проверяем снова после блокирующей операции
+                    const redis = redisConnections.get(db);
+                    for (const stream of dbStreams) {
                         if (isClosing) {
-                            return;
+                            break;
                         }
-                        if (messages && Array.isArray(messages) && messages.length > 0) {
-                            // XREAD возвращает массив с одним элементом [streamName, messages]
-                            const streamData = messages[0];
-                            const [streamName, streamMessages] = streamData;
-                            if (Array.isArray(streamMessages) && streamMessages.length > 0) {
-                                // Обновляем lastReadId на последний прочитанный ID
-                                const lastMessageId = streamMessages[streamMessages.length - 1][0];
-                                lastReadIds.set(streamName, lastMessageId);
-                                for (const [messageId, fields] of streamMessages) {
-                                    if (isClosing) {
-                                        break;
-                                    }
-                                    const messageData = {};
-                                    // Parse fields
-                                    for (let j = 0; j < fields.length; j += 2) {
-                                        messageData[fields[j]] = fields[j + 1];
-                                    }
-                                    // Parse commands if it's a string
-                                    if (messageData.commands && typeof messageData.commands === 'string') {
-                                        try {
-                                            messageData.commands = JSON.parse(messageData.commands);
+                        try {
+                            const lastId = lastReadIds.get(stream) || '$';
+                            const blockTime = isClosing ? 0 : Math.min(block, MAX_BLOCK_TIME_FOR_RESPONSIVENESS_MS);
+                            const messages = await redis.xread('COUNT', count, 'BLOCK', blockTime, 'STREAMS', stream, lastId);
+                            if (isClosing) {
+                                return;
+                            }
+                            if (messages && Array.isArray(messages) && messages.length > 0) {
+                                const streamData = messages[0];
+                                const [streamName, streamMessages] = streamData;
+                                if (Array.isArray(streamMessages) && streamMessages.length > 0) {
+                                    // ИСПРАВЛЕНИЕ: Фильтруем уже обработанные сообщения
+                                    const newMessages = streamMessages.filter(([messageId]) => {
+                                        const messageKey = `${streamName}:${messageId}`;
+                                        if (processedMessageIds.has(messageKey)) {
+                                            return false; // Пропускаем уже обработанное сообщение
+                                        }
+                                        processedMessageIds.add(messageKey);
+                                        return true;
+                                    });
+                                    // ИСПРАВЛЕНИЕ: Обновляем lastReadId сразу после чтения, ДО обработки
+                                    const lastMessageId = streamMessages[streamMessages.length - 1][0];
+                                    lastReadIds.set(streamName, lastMessageId);
+                                    // ИСПРАВЛЕНИЕ: Обрабатываем только новые сообщения
+                                    for (const [messageId, fields] of newMessages) {
+                                        if (isClosing) {
+                                            break;
                                         }
-                                        catch (e) {
-                                            // Ignore parse errors
+                                        const messageData = {};
+                                        for (let j = 0; j < fields.length; j += 2) {
+                                            messageData[fields[j]] = fields[j + 1];
                                         }
+                                        if (messageData.commands && typeof messageData.commands === 'string') {
+                                            try {
+                                                messageData.commands = JSON.parse(messageData.commands);
+                                            }
+                                            catch (e) {
+                                                // Ignore parse errors
+                                            }
+                                        }
+                                        const executionData = {
+                                            json: {
+                                                messageId,
+                                                stream: streamName,
+                                                data: messageData,
+                                                commandList: messageData,
+                                            },
+                                        };
+                                        this.emit([[executionData]]);
+                                    }
+                                    // ИСПРАВЛЕНИЕ: Очищаем старые записи из Set для предотвращения утечки памяти
+                                    // Оставляем только последние 1000 обработанных ID
+                                    if (processedMessageIds.size > 1000) {
+                                        const entries = Array.from(processedMessageIds);
+                                        const toRemove = entries.slice(0, entries.length - 1000);
+                                        toRemove.forEach(id => processedMessageIds.delete(id));
                                     }
-                                    // Триггерим workflow с данными сообщения
-                                    const executionData = {
-                                        json: {
-                                            messageId,
-                                            stream: streamName,
-                                            data: messageData,
-                                            commandList: messageData,
-                                        },
-                                    };
-                                    this.emit([[executionData]]);
                                 }
                             }
                         }
-                    }
-                    catch (error) {
-                        // Игнорируем ошибки при закрытии
-                        if (isClosing && (error.message?.includes('Connection is closed') || error.message?.includes('disconnect'))) {
-                            return;
-                        }
-                        // Игнорируем ошибки для несуществующих streams
-                        if (error.message?.includes('Invalid stream ID') || error.message?.includes('no such key')) {
-                            continue;
+                        catch (error) {
+                            if (isClosing && (error.message?.includes('Connection is closed') || error.message?.includes('disconnect'))) {
+                                return;
+                            }
+                            if (error.message?.includes('Invalid stream ID') || error.message?.includes('no such key')) {
+                                continue;
+                            }
+                            console.error(`[Chat2Crm Trigger] Error reading stream ${stream} from Redis DB ${db}:`, error);
                         }
-                        // Логируем только критические ошибки
-                        console.error(`[Chat2Crm Trigger] Error reading stream ${stream} from Redis DB ${db}:`, error);
                     }
                 }
             }
+            finally {
+                // ИСПРАВЛЕНИЕ: Всегда сбрасываем флаг, даже при ошибке
+                isReading = false;
+            }
         };
         // Начинаем polling с более коротким интервалом
         let interval = null;

package/dist/nodes/Chat2CrmTrigger/Infra/RedisConnection.js

@@ -172,7 +172,7 @@ async function createRedisConnection(credentials, db = 0) {
     const redis = new ioredis_1.default({
         host: redisHost,
         port: redisPort,
-        db: selectedDb, // Явно используем переданный параметр db
+        db: selectedDb,
         password: credentials.password,
         enableReadyCheck: true,
         maxRetriesPerRequest: 3,
@@ -182,6 +182,18 @@ async function createRedisConnection(credentials, db = 0) {
             return delay;
         },
     });
+    // Ждем подключения и явно выбираем базу данных
+    await new Promise((resolve, reject) => {
+        redis.once('ready', () => {
+            resolve();
+        });
+        redis.once('error', (err) => {
+            reject(err);
+        });
+    });
+    // Явно выбираем базу данных после подключения
+    await redis.select(selectedDb);
+    console.log(`[Redis Connection] Explicitly selected DB ${selectedDb} after connection`);
     // Добавляем обработчики событий для диагностики
     redis.on('connect', () => {
         console.log(`[Redis Connection] Connected to Redis at ${redisHost}:${redisPort}, DB ${selectedDb}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-chat2crm",
-    "version": "0.1.15",
+    "version": "0.1.17",
     "description": "n8n node for Chat2Crm Redis integration",
     "keywords": [
         "n8n-community-node-package",