n8n-nodes-chat2crm 0.1.3 → 0.1.5

package/dist/nodes/Chat2CrmSend/Chat2CrmSend.node.d.ts

@@ -0,0 +1,8 @@
+import { IExecuteFunctions, INodeType, INodeTypeDescription, INodeExecutionData, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+export declare class Chat2CrmSend implements INodeType {
+    description: INodeTypeDescription;
+    getStreams(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+    private static createRedisConnectionForLoadOptions;
+    private static getStreamDb;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Chat2CrmSend/Chat2CrmSend.node.js

@@ -0,0 +1,358 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat2CrmSend = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ioredis_1 = __importDefault(require("ioredis"));
+const RedisConnection_1 = require("../Chat2CrmTrigger/Infra/RedisConnection");
+class Chat2CrmSend {
+    constructor() {
+        this.description = {
+            displayName: 'Chat2Crm Send',
+            name: 'chat2CrmSend',
+            icon: 'file:chat2crm.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["streams"].join(", ")}}',
+            description: 'Send messages to Chat2Crm Redis streams',
+            defaults: {
+                name: 'Chat2Crm Send',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'chat2CrmRedisApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Stream Names or IDs',
+                    name: 'streams',
+                    type: 'multiOptions',
+                    required: true,
+                    description: 'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+                    typeOptions: {
+                        loadOptionsMethod: 'getStreams',
+                    },
+                    default: [],
+                },
+                {
+                    displayName: 'Message Data',
+                    name: 'messageData',
+                    type: 'json',
+                    required: true,
+                    default: '{}',
+                    description: 'Message data to send to Redis stream (JSON object)',
+                },
+                {
+                    displayName: 'Message ID',
+                    name: 'messageId',
+                    type: 'string',
+                    default: '*',
+                    description: 'Message ID (use * for auto-generate, or specify custom ID)',
+                },
+            ],
+        };
+    }
+    // Метод для динамической загрузки стримов из Redis
+    async getStreams() {
+        const credentials = await this.getCredentials('chat2CrmRedisApi');
+        const streams = [];
+        const foundStreams = new Set();
+        // Проверяем стримы в DB 0 и DB 1
+        for (const db of [0, 1]) {
+            let redis = null;
+            try {
+                // Создаем временное подключение для получения списка стримов
+                redis = await Chat2CrmSend.createRedisConnectionForLoadOptions(this, credentials, db);
+                // Получаем все ключи через SCAN
+                let cursor = '0';
+                do {
+                    if (!redis) {
+                        break;
+                    }
+                    const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', '*', 'COUNT', 100);
+                    cursor = nextCursor;
+                    // Проверяем каждый ключ, является ли он stream
+                    for (const key of keys) {
+                        if (foundStreams.has(key)) {
+                            continue;
+                        }
+                        if (!redis) {
+                            break;
+                        }
+                        try {
+                            const keyType = await redis.type(key);
+                            if (keyType === 'stream') {
+                                foundStreams.add(key);
+                                // Формируем отображаемое имя
+                                let displayName = key;
+                                try {
+                                    if (redis) {
+                                        const streamInfo = await redis.xinfo('STREAM', key);
+                                        if (streamInfo && Array.isArray(streamInfo)) {
+                                            const lengthIndex = streamInfo.indexOf('length');
+                                            if (lengthIndex >= 0 && lengthIndex < streamInfo.length - 1) {
+                                                const length = streamInfo[lengthIndex + 1];
+                                                displayName = `${key} (${length} msgs, DB ${db})`;
+                                            }
+                                            else {
+                                                displayName = `${key} (DB ${db})`;
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (e) {
+                                    displayName = `${key} (DB ${db})`;
+                                }
+                                streams.push({
+                                    name: displayName,
+                                    value: key,
+                                    description: `Redis stream in DB ${db}`,
+                                });
+                            }
+                        }
+                        catch (e) {
+                            continue;
+                        }
+                    }
+                } while (cursor !== '0' && redis);
+            }
+            catch (error) {
+                console.error(`[Chat2Crm Send] Error loading streams from DB ${db}:`, error.message);
+            }
+            finally {
+                if (redis) {
+                    try {
+                        redis.disconnect();
+                    }
+                    catch (e) {
+                        // Игнорируем ошибки при закрытии
+                    }
+                }
+            }
+        }
+        // Сортируем стримы по имени
+        streams.sort((a, b) => a.name.localeCompare(b.name));
+        if (streams.length === 0) {
+            return [
+                {
+                    name: 'No Streams Found. Check Redis Connection.',
+                    value: '',
+                    description: 'No streams available',
+                },
+            ];
+        }
+        return streams;
+    }
+    // Статический метод для создания подключения к Redis при загрузке опций
+    static async createRedisConnectionForLoadOptions(context, credentials, db) {
+        let redisHost = credentials.host;
+        let redisPort = credentials.port;
+        // Проверяем, используется ли SSH туннель
+        if (credentials.useSSH) {
+            // Пытаемся использовать SSH, если доступен helpers.getSSHClient
+            if (context.helpers && typeof context.helpers.getSSHClient === 'function') {
+                try {
+                    const sshCredentials = {
+                        sshHost: credentials.sshHost,
+                        sshPort: credentials.sshPort || 22,
+                        sshUser: credentials.sshUser,
+                        sshAuthenticateWith: credentials.sshAuthenticateWith || 'password',
+                    };
+                    if (sshCredentials.sshAuthenticateWith === 'password') {
+                        sshCredentials.sshPassword = credentials.sshPassword;
+                    }
+                    else {
+                        sshCredentials.privateKey = credentials.privateKey;
+                        sshCredentials.passphrase = credentials.passphrase;
+                    }
+                    const sshClient = await context.helpers.getSSHClient(sshCredentials);
+                    const remoteRedisHost = credentials.host || 'localhost';
+                    const remoteRedisPort = credentials.port || 6379;
+                    // Создаем SSH туннель
+                    const net = require('net');
+                    const localServer = net.createServer((localSocket) => {
+                        sshClient.forwardOut('127.0.0.1', 0, remoteRedisHost, remoteRedisPort, (err, stream) => {
+                            if (err) {
+                                localSocket.destroy();
+                                return;
+                            }
+                            localSocket.pipe(stream);
+                            stream.pipe(localSocket);
+                        });
+                    });
+                    await new Promise((resolve, reject) => {
+                        localServer.listen(0, '127.0.0.1', () => {
+                            const address = localServer.address();
+                            if (address && typeof address === 'object') {
+                                redisHost = '127.0.0.1';
+                                redisPort = address.port;
+                                resolve();
+                            }
+                            else {
+                                reject(new Error('Failed to get local server address'));
+                            }
+                        });
+                        localServer.on('error', reject);
+                    });
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.ApplicationError(`SSH tunnel failed in loadOptions: ${error.message}`, { level: 'error' });
+                }
+            }
+            else {
+                throw new n8n_workflow_1.ApplicationError('SSH tunnel is not supported in loadOptions context', { level: 'error' });
+            }
+        }
+        // Создаем подключение к Redis
+        const redis = new ioredis_1.default({
+            host: redisHost,
+            port: redisPort,
+            db: db,
+            password: credentials.password,
+            enableReadyCheck: true,
+            maxRetriesPerRequest: 1,
+            connectTimeout: 5000,
+            retryStrategy: () => null,
+        });
+        // Ждем готовности подключения
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                redis.disconnect();
+                reject(new Error('Connection timeout'));
+            }, 5000);
+            redis.once('ready', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            redis.once('error', (err) => {
+                clearTimeout(timeout);
+                redis.disconnect();
+                reject(err);
+            });
+        });
+        return redis;
+    }
+    // Определяем базу данных для стрима
+    static getStreamDb(stream) {
+        // Streams в DB 1 (CrmWorker)
+        if (stream === 'crm_outgoing_message' ||
+            stream === 'crm_incoming_message' ||
+            stream === 'crm_lazy_incoming_message' ||
+            stream === 'crm_contacts') {
+            return 1;
+        }
+        // Все остальные streams находятся в DB 0
+        return 0;
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('chat2CrmRedisApi');
+        const selectedStreams = this.getNodeParameter('streams', 0);
+        const messageId = this.getNodeParameter('messageId', 0);
+        // Проверяем, что выбраны streams
+        if (!selectedStreams || selectedStreams.length === 0) {
+            throw new n8n_workflow_1.ApplicationError('Please select at least one stream to send message to', { level: 'warning' });
+        }
+        // Группируем выбранные streams по базам данных
+        const streamsByDb = new Map();
+        selectedStreams.forEach(stream => {
+            const db = Chat2CrmSend.getStreamDb(stream);
+            if (!streamsByDb.has(db)) {
+                streamsByDb.set(db, []);
+            }
+            streamsByDb.get(db).push(stream);
+        });
+        // Создаем подключения к Redis только для нужных баз данных
+        const redisConnections = new Map();
+        try {
+            for (const db of streamsByDb.keys()) {
+                const redis = await RedisConnection_1.createRedisConnection.call(this, credentials, db);
+                redisConnections.set(db, redis);
+            }
+            // Обрабатываем каждый элемент входных данных
+            for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+                const messageDataParam = this.getNodeParameter('messageData', itemIndex);
+                // Парсим JSON данные сообщения
+                let messageData = {};
+                try {
+                    if (typeof messageDataParam === 'string') {
+                        messageData = JSON.parse(messageDataParam);
+                    }
+                    else if (typeof messageDataParam === 'object') {
+                        messageData = messageDataParam;
+                    }
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.ApplicationError(`Invalid JSON in messageData: ${error}`, { level: 'error' });
+                }
+                // Отправляем сообщение в каждый выбранный stream
+                const sent = [];
+                const errors = [];
+                for (const [db, dbStreams] of streamsByDb.entries()) {
+                    const redis = redisConnections.get(db);
+                    for (const stream of dbStreams) {
+                        try {
+                            // Подготавливаем поля для XADD
+                            const fields = [];
+                            for (const [key, value] of Object.entries(messageData)) {
+                                fields.push(key);
+                                // Преобразуем значение в строку
+                                if (typeof value === 'object' && value !== null) {
+                                    fields.push(JSON.stringify(value));
+                                }
+                                else {
+                                    fields.push(String(value));
+                                }
+                            }
+                            // Отправляем сообщение в stream
+                            const id = await redis.xadd(stream, messageId || '*', ...fields);
+                            if (!id) {
+                                throw new n8n_workflow_1.ApplicationError('Failed to add message to stream: XADD returned null', { level: 'error' });
+                            }
+                            sent.push({
+                                stream,
+                                db,
+                                messageId: id,
+                            });
+                        }
+                        catch (error) {
+                            errors.push({
+                                stream,
+                                db,
+                                error: error.message,
+                            });
+                        }
+                    }
+                }
+                // Возвращаем результат
+                returnData.push({
+                    json: {
+                        ...items[itemIndex].json,
+                        sent,
+                        errors,
+                    },
+                });
+            }
+        }
+        finally {
+            // Закрываем все подключения
+            for (const [db, redis] of redisConnections.entries()) {
+                try {
+                    redis.disconnect();
+                }
+                catch (error) {
+                    console.error(`[Chat2Crm Send] Error disconnecting Redis connection for DB ${db}:`, error);
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Chat2CrmSend = Chat2CrmSend;

package/dist/nodes/Chat2CrmSend/chat2crm.svg

@@ -0,0 +1,25 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="640.000000pt" height="640.000000pt" viewBox="0 0 640.000000 640.000000"
+ preserveAspectRatio="xMidYMid meet">
+
+<g transform="translate(0.000000,640.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M2150 4544 l0 -979 416 -416 415 -416 -3 -611 c-2 -337 0 -611 3
+-610 17 7 1036 1008 1192 1170 l177 186 0 248 0 249 -275 275 -275 275 0 -255
+0 -254 47 -48 47 -48 43 42 43 42 0 -453 c0 -249 -4 -451 -9 -449 -4 2 -231
+223 -504 492 l-495 489 -1 282 -1 283 -115 212 c-63 117 -114 215 -112 216 2
+2 52 -46 112 -106 60 -61 112 -110 115 -110 3 0 4 111 3 247 l-2 248 -313 298
+c-172 164 -357 338 -410 388 l-98 91 0 -978z"/>
+<path d="M3092 3547 l-32 -33 253 -249 c139 -138 286 -283 328 -323 l75 -72
+42 39 c52 49 56 81 10 81 l-32 0 32 33 c31 31 32 37 32 112 l0 79 -57 59 -58
+58 37 31 38 30 -87 94 -87 94 -231 0 -231 0 -32 -33z"/>
+<path d="M2643 1858 l-243 -243 0 93 c0 50 -1 92 -3 92 -2 0 -58 -55 -125
+-122 l-122 -123 0 -95 0 -95 125 125 125 125 0 -220 0 -220 245 245 245 245
+-2 218 -3 217 -242 -242z"/>
+<path d="M3415 1792 c-27 -25 -138 -131 -245 -236 l-194 -191 -1 -217 c0 -120
+3 -217 6 -215 4 1 115 108 248 238 l241 237 -2 215 -3 216 -50 -47z"/>
+</g>
+</svg>

package/dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.d.ts

@@ -1,7 +1,5 @@
-import { ITriggerFunctions, INodeType, INodeTypeDescription, ITriggerResponse, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+import { ITriggerFunctions, INodeType, INodeTypeDescription, ITriggerResponse } from 'n8n-workflow';
 export declare class Chat2CrmTrigger implements INodeType {
     description: INodeTypeDescription;
-    getStreams(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
-    private static createRedisConnectionForLoadOptions;
     trigger(this: ITriggerFunctions): Promise<ITriggerResponse | undefined>;
 }

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

@@ -1,11 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Chat2CrmTrigger = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const ioredis_1 = __importDefault(require("ioredis"));
 const RedisConnection_1 = require("./Infra/RedisConnection");
 class Chat2CrmTrigger {
     constructor() {
@@ -30,15 +26,74 @@ class Chat2CrmTrigger {
             ],
             properties: [
                 {
-                    displayName: 'Stream Names or IDs',
+                    displayName: 'Streams',
                     name: 'streams',
                     type: 'multiOptions',
-                    required: true,
-                    description: 'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
-                    typeOptions: {
-                        loadOptionsMethod: 'getStreams',
-                    },
-                    default: [],
+                    required: true, // Вернули required: true
+                    description: 'Select Redis streams to listen to',
+                    options: [
+                        {
+                            name: 'Chat Incoming Message',
+                            value: 'chat_incoming_message',
+                            description: 'Messages to chat (DB 0)',
+                        },
+                        {
+                            name: 'Chat Outgoing Message',
+                            value: 'chat_outgoing_message',
+                            description: 'Messages from chat to CRM (DB 0)',
+                        },
+                        {
+                            name: 'Chat Outgoing Status',
+                            value: 'chat_outgoing_status',
+                            description: 'Status messages from chat (DB 0)',
+                        },
+                        {
+                            name: 'Chat Outgoing Status (CRM)',
+                            value: 'chat_outgoing_status',
+                            description: 'Chat outgoing status in CRM DB (DB 1)',
+                        },
+                        {
+                            name: 'CRM Contacts',
+                            value: 'crm_contacts',
+                            description: 'CRM contacts stream (DB 1)',
+                        },
+                        {
+                            name: 'CRM Incoming Message',
+                            value: 'crm_incoming_message',
+                            description: 'Messages to CRM (DB 1)',
+                        },
+                        {
+                            name: 'CRM Incoming Status',
+                            value: 'crm_incoming_status',
+                            description: 'Status messages to CRM (DB 0)',
+                        },
+                        {
+                            name: 'CRM Lazy Incoming Message',
+                            value: 'crm_lazy_incoming_message',
+                            description: 'Lazy incoming messages to CRM (DB 1)',
+                        },
+                        {
+                            name: 'CRM Outgoing Message',
+                            value: 'crm_outgoing_message',
+                            description: 'Messages from CRM to chat (DB 1)',
+                        },
+                        {
+                            name: 'CRM Outgoing Status',
+                            value: 'crm_outgoing_status',
+                            description: 'Status messages from CRM (DB 1)',
+                        },
+                        {
+                            name: 'N8N Incoming Message',
+                            value: 'n8n_incoming_message',
+                            description: 'Incoming messages to N8N (DB 0)',
+                        },
+                        {
+                            name: 'N8N Outgoing Message',
+                            value: 'n8n_outgoing_message',
+                            description: 'Outgoing messages from N8N (DB 0)',
+                        },
+                    ],
+                    default: ['chat_outgoing_message'],
                 },
                 {
                     displayName: 'Block Time (Ms)',
@@ -64,188 +119,6 @@ class Chat2CrmTrigger {
             ],
         };
     }
-    // Метод для динамической загрузки стримов из Redis
-    async getStreams() {
-        const credentials = await this.getCredentials('chat2CrmRedisApi');
-        const streams = [];
-        const foundStreams = new Set();
-        // Проверяем стримы в DB 0 и DB 1
-        for (const db of [0, 1]) {
-            let redis = null;
-            try {
-                // Создаем временное подключение для получения списка стримов
-                redis = await Chat2CrmTrigger.createRedisConnectionForLoadOptions(this, credentials, db);
-                // Получаем все ключи через SCAN
-                let cursor = '0';
-                do {
-                    if (!redis) {
-                        break;
-                    }
-                    const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', '*', 'COUNT', 100);
-                    cursor = nextCursor;
-                    // Проверяем каждый ключ, является ли он stream
-                    for (const key of keys) {
-                        if (foundStreams.has(key)) {
-                            continue;
-                        }
-                        if (!redis) {
-                            break;
-                        }
-                        try {
-                            const keyType = await redis.type(key);
-                            if (keyType === 'stream') {
-                                foundStreams.add(key);
-                                // Формируем отображаемое имя
-                                let displayName = key;
-                                try {
-                                    if (redis) {
-                                        const streamInfo = await redis.xinfo('STREAM', key);
-                                        if (streamInfo && Array.isArray(streamInfo)) {
-                                            const lengthIndex = streamInfo.indexOf('length');
-                                            if (lengthIndex >= 0 && lengthIndex < streamInfo.length - 1) {
-                                                const length = streamInfo[lengthIndex + 1];
-                                                displayName = `${key} (${length} msgs, DB ${db})`;
-                                            }
-                                            else {
-                                                displayName = `${key} (DB ${db})`;
-                                            }
-                                        }
-                                    }
-                                }
-                                catch (e) {
-                                    displayName = `${key} (DB ${db})`;
-                                }
-                                streams.push({
-                                    name: displayName,
-                                    value: key,
-                                    description: `Redis stream in DB ${db}`,
-                                });
-                            }
-                        }
-                        catch (e) {
-                            continue;
-                        }
-                    }
-                } while (cursor !== '0' && redis);
-            }
-            catch (error) {
-                console.error(`[Chat2Crm Trigger] Error loading streams from DB ${db}:`, error.message);
-            }
-            finally {
-                if (redis) {
-                    try {
-                        redis.disconnect();
-                    }
-                    catch (e) {
-                        // Игнорируем ошибки при закрытии
-                    }
-                }
-            }
-        }
-        // Сортируем стримы по имени
-        streams.sort((a, b) => a.name.localeCompare(b.name));
-        if (streams.length === 0) {
-            return [
-                {
-                    name: 'No Streams Found. Check Redis Connection.',
-                    value: '',
-                    description: 'No streams available',
-                },
-            ];
-        }
-        return streams;
-    }
-    // Статический метод для создания подключения к Redis при загрузке опций
-    static async createRedisConnectionForLoadOptions(context, credentials, db) {
-        let redisHost = credentials.host;
-        let redisPort = credentials.port;
-        // Проверяем, используется ли SSH туннель
-        if (credentials.useSSH) {
-            // Пытаемся использовать SSH, если доступен helpers.getSSHClient
-            if (context.helpers && typeof context.helpers.getSSHClient === 'function') {
-                try {
-                    // Используем существующую логику из createRedisConnection
-                    // Но упрощенную версию для loadOptions
-                    const sshCredentials = {
-                        sshHost: credentials.sshHost,
-                        sshPort: credentials.sshPort || 22,
-                        sshUser: credentials.sshUser,
-                        sshAuthenticateWith: credentials.sshAuthenticateWith || 'password',
-                    };
-                    if (sshCredentials.sshAuthenticateWith === 'password') {
-                        sshCredentials.sshPassword = credentials.sshPassword;
-                    }
-                    else {
-                        sshCredentials.privateKey = credentials.privateKey;
-                        sshCredentials.passphrase = credentials.passphrase;
-                    }
-                    const sshClient = await context.helpers.getSSHClient(sshCredentials);
-                    const remoteRedisHost = credentials.host || 'localhost';
-                    const remoteRedisPort = credentials.port || 6379;
-                    // Создаем SSH туннель (упрощенная версия)
-                    const net = require('net');
-                    const localServer = net.createServer((localSocket) => {
-                        sshClient.forwardOut('127.0.0.1', 0, remoteRedisHost, remoteRedisPort, (err, stream) => {
-                            if (err) {
-                                localSocket.destroy();
-                                return;
-                            }
-                            localSocket.pipe(stream);
-                            stream.pipe(localSocket);
-                        });
-                    });
-                    await new Promise((resolve, reject) => {
-                        localServer.listen(0, '127.0.0.1', () => {
-                            const address = localServer.address();
-                            if (address && typeof address === 'object') {
-                                redisHost = '127.0.0.1';
-                                redisPort = address.port;
-                                resolve();
-                            }
-                            else {
-                                reject(new Error('Failed to get local server address'));
-                            }
-                        });
-                        localServer.on('error', reject);
-                    });
-                }
-                catch (error) {
-                    throw new n8n_workflow_1.ApplicationError(`SSH tunnel failed in loadOptions: ${error.message}`, { level: 'error' });
-                }
-            }
-            else {
-                throw new n8n_workflow_1.ApplicationError('SSH tunnel is not supported in loadOptions context', { level: 'error' });
-            }
-        }
-        // Создаем подключение к Redis
-        const redis = new ioredis_1.default({
-            host: redisHost,
-            port: redisPort,
-            db: db,
-            password: credentials.password,
-            enableReadyCheck: true,
-            maxRetriesPerRequest: 1,
-            connectTimeout: 5000,
-            retryStrategy: () => null,
-        });
-        // Ждем готовности подключения
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                redis.disconnect();
-                reject(new Error('Connection timeout'));
-            }, 5000);
-            redis.once('ready', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            redis.once('error', (err) => {
-                clearTimeout(timeout);
-                redis.disconnect();
-                reject(err);
-            });
-        });
-        return redis;
-    }
     async trigger() {
         const credentials = await this.getCredentials('chat2CrmRedisApi');
         const selectedStreams = this.getNodeParameter('streams', []);

package/index.js

@@ -1,6 +1,7 @@
 module.exports = {
   nodes: [
     require('./dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js'),
+    require('./dist/nodes/Chat2CrmSend/Chat2CrmSend.node.js'),
   ],
   credentials: [
     require('./dist/credentials/Chat2CrmRedisApi.credentials.js'),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-chat2crm",
-    "version": "0.1.3",
+    "version": "0.1.5",
     "description": "n8n node for Chat2Crm Redis integration",
     "keywords": [
         "n8n-community-node-package",
@@ -27,7 +27,8 @@
             "dist/credentials/Chat2CrmRedisApi.credentials.js"
         ],
         "nodes": [
-            "dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js"
+            "dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js",
+            "dist/nodes/Chat2CrmSend/Chat2CrmSend.node.js"
         ]
     },
     "devDependencies": {