n8n-nodes-chat2crm 0.1.0 → 0.1.3

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

@@ -1,5 +1,7 @@
-import { ITriggerFunctions, INodeType, INodeTypeDescription, ITriggerResponse } from 'n8n-workflow';
+import { ITriggerFunctions, INodeType, INodeTypeDescription, ITriggerResponse, ILoadOptionsFunctions, INodePropertyOptions } 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,7 +1,11 @@
 "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() {
@@ -26,64 +30,15 @@ class Chat2CrmTrigger {
             ],
             properties: [
                 {
-                    displayName: 'Streams',
+                    displayName: 'Stream Names or IDs',
                     name: 'streams',
                     type: 'multiOptions',
-                    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)',
-                        },
-                    ],
-                    default: ['chat_outgoing_message'],
+                    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: 'Block Time (Ms)',
@@ -109,6 +64,188 @@ 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,8 +1,8 @@
-module.exports = {
-  nodes: [
-    require('./dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js'),
-  ],
-  credentials: [
-    require('./dist/credentials/Chat2CrmRedisApi.credentials.js'),
-  ],
-};
+module.exports = {
+  nodes: [
+    require('./dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js'),
+  ],
+  credentials: [
+    require('./dist/credentials/Chat2CrmRedisApi.credentials.js'),
+  ],
+};

package/package.json

@@ -1,53 +1,53 @@
-{
-    "name": "n8n-nodes-chat2crm",
-    "version": "0.1.0",
-    "description": "n8n node for Chat2Crm Redis integration",
-    "keywords": [
-        "n8n-community-node-package",
-        "chat2crm",
-        "redis",
-        "messaging"
-    ],
-    "main": "index.js",
-    "scripts": {
-        "build": "rm -rf dist && tsc && gulp build:icons",
-        "dev": "npm run build && npx n8n",
-        "dev:watch": "tsc --watch",
-        "format": "prettier nodes credentials --write",
-        "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\"",
-        "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\" --fix",
-        "prepublishOnly": "npm run build && npm run lint -s"
-    },
-    "files": [
-        "dist"
-    ],
-    "n8n": {
-        "n8nNodesApiVersion": 1,
-        "credentials": [
-            "dist/credentials/Chat2CrmRedisApi.credentials.js"
-        ],
-        "nodes": [
-            "dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js"
-        ]
-    },
-    "devDependencies": {
-        "@types/node": "^20.10.0",
-        "@typescript-eslint/parser": "^6.13.0",
-        "@typescript-eslint/eslint-plugin": "^6.13.0",
-        "@types/uuid": "^9.0.7",
-        "eslint": "^8.57.1",
-        "eslint-plugin-n8n-nodes-base": "^1.11.0",
-        "gulp": "^4.0.2",
-        "n8n": "*",
-        "n8n-workflow": "*",
-        "prettier": "^3.1.0",
-        "typescript": "^5.3.0"
-    },
-    "dependencies": {
-        "ioredis": "^5.3.2",
-        "uuid": "^9.0.1"
-    },
-    "peerDependencies": {
-        "n8n-workflow": "*"
-    }
-}
+{
+    "name": "n8n-nodes-chat2crm",
+    "version": "0.1.3",
+    "description": "n8n node for Chat2Crm Redis integration",
+    "keywords": [
+        "n8n-community-node-package",
+        "chat2crm",
+        "redis",
+        "messaging"
+    ],
+    "main": "index.js",
+    "scripts": {
+        "build": "rm -rf dist && tsc && gulp build:icons",
+        "dev": "npm run build && npx n8n",
+        "dev:watch": "tsc --watch",
+        "format": "prettier nodes credentials --write",
+        "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\"",
+        "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" \"package.json\" --fix",
+        "prepublishOnly": "npm run build && npm run lint -s"
+    },
+    "files": [
+        "dist"
+    ],
+    "n8n": {
+        "n8nNodesApiVersion": 1,
+        "credentials": [
+            "dist/credentials/Chat2CrmRedisApi.credentials.js"
+        ],
+        "nodes": [
+            "dist/nodes/Chat2CrmTrigger/Chat2CrmTrigger.node.js"
+        ]
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "@typescript-eslint/parser": "^6.13.0",
+        "@typescript-eslint/eslint-plugin": "^6.13.0",
+        "@types/uuid": "^9.0.7",
+        "eslint": "^8.57.1",
+        "eslint-plugin-n8n-nodes-base": "^1.11.0",
+        "gulp": "^4.0.2",
+        "n8n": "*",
+        "n8n-workflow": "*",
+        "prettier": "^3.1.0",
+        "typescript": "^5.3.0"
+    },
+    "dependencies": {
+        "ioredis": "^5.3.2",
+        "uuid": "^9.0.1"
+    },
+    "peerDependencies": {
+        "n8n-workflow": "*"
+    }
+}