@atom8n/n8n-nodes-base 2.5.6 → 2.5.7

package/dist/known/credentials.json

@@ -2615,7 +2615,8 @@
     "sourcePath": "dist/credentials/TelegramApi.credentials.js",
     "supportedNodes": [
       "telegram",
-      "telegramTrigger"
+      "telegramTrigger",
+      "telegramPollingTrigger"
     ]
   },
   "theHiveProjectApi": {

package/dist/known/nodes.json

@@ -1499,6 +1499,10 @@
     "className": "TelegramTrigger",
     "sourcePath": "dist/nodes/Telegram/TelegramTrigger.node.js"
   },
+  "telegramPollingTrigger": {
+    "className": "TelegramPollingTrigger",
+    "sourcePath": "dist/nodes/Telegram/TelegramPollingTrigger.node.js"
+  },
   "theHiveProject": {
     "className": "TheHiveProject",
     "sourcePath": "dist/nodes/TheHiveProject/TheHiveProject.node.js"

package/dist/nodes/ActionNetwork/GenericFunctions.d.ts

@@ -16,14 +16,14 @@ export declare const isPrimary: (field: FieldWithPrimaryField) => boolean;
 declare function adjustLocation(allFields: AllFieldsUi): AllFieldsUi | {
     location: IDataObject;
     languages_spoken: import("./types").LanguageCodes;
-    phone_numbers: {
-        phone_numbers_fields: import("./types").PhoneNumberField[];
-    };
+    email_addresses: import("./types").EmailAddressUi;
     postal_addresses: {
         postal_addresses_fields: import("./types").PostalAddressField[];
     };
+    phone_numbers: {
+        phone_numbers_fields: import("./types").PhoneNumberField[];
+    };
     target: string;
-    email_addresses: import("./types").EmailAddressUi;
 };
 declare function adjustTargets(allFields: AllFieldsUi): AllFieldsUi | {
     target: {
@@ -33,13 +33,13 @@ declare function adjustTargets(allFields: AllFieldsUi): AllFieldsUi | {
         postal_addresses_fields: import("./types").PostalAddressField;
     };
     languages_spoken: import("./types").LanguageCodes;
-    phone_numbers: {
-        phone_numbers_fields: import("./types").PhoneNumberField[];
-    };
+    email_addresses: import("./types").EmailAddressUi;
     postal_addresses: {
         postal_addresses_fields: import("./types").PostalAddressField[];
     };
-    email_addresses: import("./types").EmailAddressUi;
+    phone_numbers: {
+        phone_numbers_fields: import("./types").PhoneNumberField[];
+    };
 };
 export declare const adjustPersonPayload: (...args: any[]) => any;
 export declare const adjustPetitionPayload: typeof adjustTargets;
@@ -58,18 +58,18 @@ export declare const simplifyResponse: (response: Response, resource: Resource)
     language_spoken: any;
     postal_address: {
         address_lines: string;
-        region: string;
-        primary: boolean;
-        locality: string;
-        postal_code: string;
-        country: string;
-        language: import("./types").LanguageCodes;
         location: {
             location_fields: {
                 latitude: string;
                 longitude: string;
             };
         };
+        country: string;
+        region: string;
+        primary: boolean;
+        locality: string;
+        postal_code: string;
+        language: import("./types").LanguageCodes;
     };
     phone_number: string;
     email_address: string;
@@ -79,18 +79,18 @@ export declare const simplifyResponse: (response: Response, resource: Resource)
         language_spoken: any;
         postal_address: {
             address_lines: string;
-            region: string;
-            primary: boolean;
-            locality: string;
-            postal_code: string;
-            country: string;
-            language: import("./types").LanguageCodes;
             location: {
                 location_fields: {
                     latitude: string;
                     longitude: string;
                 };
             };
+            country: string;
+            region: string;
+            primary: boolean;
+            locality: string;
+            postal_code: string;
+            language: import("./types").LanguageCodes;
         };
         phone_number: string;
         email_address: string;

package/dist/nodes/ExecuteWorkflow/ExecuteWorkflowTrigger/ExecuteWorkflowTrigger.node.js

@@ -93,7 +93,7 @@ class ExecuteWorkflowTrigger {
                         description: 'Use all incoming data from the parent workflow',
                     },
                 ],
-                default: constants_1.WORKFLOW_INPUTS,
+                default: constants_1.PASSTHROUGH,
                 noDataExpression: true,
                 displayOptions: {
                     show: { '@version': [{ _cnd: { gte: 1.1 } }] },

package/dist/nodes/MySql/v2/helpers/utils.d.ts

@@ -2,7 +2,10 @@ import type { IDataObject, IExecuteFunctions, INode, INodeExecutionData, IPaired
 import { NodeOperationError } from 'n8n-workflow';
 import type { Mysql2Pool, QueryValues, QueryWithValues, SortRule, WhereClause } from './interfaces';
 export declare function escapeSqlIdentifier(identifier: string): string;
-export declare const prepareQueryAndReplacements: (rawQuery: string, nodeVersion: number, replacements?: QueryValues) => QueryWithValues;
+export declare const prepareQueryAndReplacements: (rawQuery: string, nodeVersion: number, replacements?: QueryValues) => {
+    query: string;
+    values: QueryValues;
+};
 export declare const prepareQueryLegacy: (rawQuery: string, replacements: QueryValues) => QueryWithValues;
 export declare function prepareErrorItem(item: IDataObject, error: IDataObject | NodeOperationError | Error, index: number): INodeExecutionData;
 export declare function parseMySqlError(this: IExecuteFunctions, error: any, itemIndex?: number, queries?: string[]): NodeOperationError;

package/dist/nodes/Telegram/GenericFunctions.d.ts

@@ -1,4 +1,4 @@
-import type { IDataObject, IExecuteFunctions, IHookFunctions, IHttpRequestMethods, ILoadOptionsFunctions, IWebhookFunctions } from 'n8n-workflow';
+import type { IDataObject, IExecuteFunctions, IHookFunctions, IHttpRequestMethods, ILoadOptionsFunctions, IPollFunctions, ITriggerFunctions, IWebhookFunctions } from 'n8n-workflow';
 export interface IMarkupKeyboard {
     rows?: IMarkupKeyboardRow[];
 }
@@ -45,7 +45,7 @@ export declare function addAdditionalFields(this: IExecuteFunctions, body: IData
  * Make an API request to Telegram
  *
  */
-export declare function apiRequest(this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions | IWebhookFunctions, method: IHttpRequestMethods, endpoint: string, body: IDataObject, query?: IDataObject, option?: IDataObject): Promise<any>;
+export declare function apiRequest(this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions | IPollFunctions | ITriggerFunctions | IWebhookFunctions, method: IHttpRequestMethods, endpoint: string, body: IDataObject, query?: IDataObject, option?: IDataObject): Promise<any>;
 export declare function getImageBySize(photos: IDataObject[], size: string): IDataObject | undefined;
 export declare function getPropertyName(operation: string): string;
 export declare function getSecretToken(this: IHookFunctions | IWebhookFunctions): string;

package/dist/nodes/Telegram/TelegramPollingTrigger.node.d.ts

@@ -0,0 +1,15 @@
+import type { ITriggerFunctions, INodeType, INodeTypeDescription, ITriggerResponse } from 'n8n-workflow';
+/**
+ * Telegram Polling Trigger — uses getUpdates (true long-polling) instead of webhooks.
+ *
+ * This lets the trigger work on local / HTTP-only n8n instances without
+ * requiring an HTTPS URL or a tunnelling service like ngrok.
+ *
+ * Design mirrors openclaw's approach: continuous loop calling getUpdates with
+ * a 30-second long-poll timeout, filtering by allowed update types, and
+ * persisting the offset across restarts.
+ */
+export declare class TelegramPollingTrigger implements INodeType {
+    description: INodeTypeDescription;
+    trigger(this: ITriggerFunctions): Promise<ITriggerResponse>;
+}

package/dist/nodes/Telegram/TelegramPollingTrigger.node.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramPollingTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+/**
+ * Telegram Polling Trigger — uses getUpdates (true long-polling) instead of webhooks.
+ *
+ * This lets the trigger work on local / HTTP-only n8n instances without
+ * requiring an HTTPS URL or a tunnelling service like ngrok.
+ *
+ * Design mirrors openclaw's approach: continuous loop calling getUpdates with
+ * a 30-second long-poll timeout, filtering by allowed update types, and
+ * persisting the offset across restarts.
+ */
+class TelegramPollingTrigger {
+    description = {
+        displayName: 'Telegram Polling Trigger',
+        name: 'telegramPollingTrigger',
+        icon: 'file:telegram.svg',
+        group: ['trigger'],
+        version: 1,
+        subtitle: '=Updates: {{$parameter["updates"].join(", ")}}',
+        description: 'Starts the workflow on a Telegram update using long-polling (no HTTPS required, works locally)',
+        defaults: {
+            name: 'Telegram Polling Trigger',
+        },
+        inputs: [],
+        outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        credentials: [
+            {
+                name: 'telegramApi',
+                required: true,
+            },
+        ],
+        triggerPanel: {
+            header: '',
+            executionsHelp: {
+                inactive: "<b>While building your workflow</b>, click the 'execute step' button, then send a message to your Telegram bot. This will trigger an execution, which will show up in this editor.<br /><br /><b>Once you're happy with your workflow</b>, publish it. Then every time a message arrives, the workflow will execute. These executions will show up in the <a data-key='executions'>executions list</a>, but not in the editor.",
+                active: "<b>While building your workflow</b>, click the 'execute step' button, then send a message to your Telegram bot. This will trigger an execution, which will show up in this editor.<br /><br /><b>Your workflow will also execute automatically</b>, since it's activated. Every time a message arrives, this node will trigger an execution. These executions will show up in the <a data-key='executions'>executions list</a>, but not in the editor.",
+            },
+            activationHint: "Once you've finished building your workflow, publish it to have it also listen continuously (you just won't see those executions here).",
+        },
+        properties: [
+            {
+                displayName: 'This trigger uses long-polling (getUpdates) instead of webhooks, so it works locally without HTTPS. Any existing webhook for this bot will be removed when the trigger starts.',
+                name: 'pollingNotice',
+                type: 'notice',
+                default: '',
+            },
+            {
+                displayName: 'Due to Telegram API limitations, you can use just one Telegram trigger for each bot at a time',
+                name: 'telegramTriggerNotice',
+                type: 'notice',
+                default: '',
+            },
+            {
+                displayName: 'Trigger On',
+                name: 'updates',
+                type: 'multiOptions',
+                options: [
+                    {
+                        name: '*',
+                        value: '*',
+                        description: 'All updates',
+                    },
+                    {
+                        name: 'Callback Query',
+                        value: 'callback_query',
+                        description: 'Trigger on new incoming callback query',
+                    },
+                    {
+                        name: 'Channel Post',
+                        value: 'channel_post',
+                        description: 'Trigger on new incoming channel post of any kind — text, photo, sticker, etc',
+                    },
+                    {
+                        name: 'Edited Channel Post',
+                        value: 'edited_channel_post',
+                        description: 'Trigger on new version of a channel post that is known to the bot and was edited',
+                    },
+                    {
+                        name: 'Edited Message',
+                        value: 'edited_message',
+                        description: 'Trigger on new version of a message that is known to the bot and was edited',
+                    },
+                    {
+                        name: 'Inline Query',
+                        value: 'inline_query',
+                        description: 'Trigger on new incoming inline query',
+                    },
+                    {
+                        name: 'Message',
+                        value: 'message',
+                        description: 'Trigger on new incoming message of any kind — text, photo, sticker, etc',
+                    },
+                    {
+                        name: 'Poll',
+                        value: 'poll',
+                        action: 'On Poll Change',
+                        description: 'Trigger on new poll state. Bots receive only updates about stopped polls and polls, which are sent by the bot.',
+                    },
+                    {
+                        name: 'Pre-Checkout Query',
+                        value: 'pre_checkout_query',
+                        description: 'Trigger on new incoming pre-checkout query. Contains full information about checkout.',
+                    },
+                    {
+                        name: 'Shipping Query',
+                        value: 'shipping_query',
+                        description: 'Trigger on new incoming shipping query. Only for invoices with flexible price.',
+                    },
+                ],
+                required: true,
+                default: [],
+            },
+            {
+                displayName: 'Additional Fields',
+                name: 'additionalFields',
+                type: 'collection',
+                placeholder: 'Add Field',
+                default: {},
+                options: [
+                    {
+                        displayName: 'Restrict to Chat IDs',
+                        name: 'chatIds',
+                        type: 'string',
+                        default: '',
+                        description: 'The chat IDs to restrict the trigger to. Multiple can be defined separated by comma.',
+                    },
+                    {
+                        displayName: 'Restrict to User IDs',
+                        name: 'userIds',
+                        type: 'string',
+                        default: '',
+                        description: 'The user IDs to restrict the trigger to. Multiple can be defined separated by comma.',
+                    },
+                    {
+                        displayName: 'Send Typing Indicator',
+                        name: 'sendTyping',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Whether to show "typing..." in Telegram instantly when a message is received (like openclaw). This gives the user immediate feedback while the workflow processes.',
+                    },
+                ],
+            },
+        ],
+    };
+    async trigger() {
+        const allowedUpdates = this.getNodeParameter('updates');
+        const additionalFields = this.getNodeParameter('additionalFields');
+        const nodeStaticData = this.getWorkflowStaticData('node');
+        const sendTypingEnabled = additionalFields.sendTyping !== false; // defaults to true
+        // Extract chat_id from any update type for sending typing indicator
+        const extractChatId = (update) => {
+            for (const key of ['message', 'edited_message', 'channel_post', 'edited_channel_post']) {
+                const msg = update[key];
+                if (msg?.chat) {
+                    return msg.chat.id;
+                }
+            }
+            // callback_query has message.chat
+            const callbackQuery = update.callback_query;
+            if (callbackQuery?.message) {
+                const cbMsg = callbackQuery.message;
+                if (cbMsg.chat) {
+                    return cbMsg.chat.id;
+                }
+            }
+            return undefined;
+        };
+        // Send "typing..." indicator — fire-and-forget (don't delay workflow)
+        const sendTypingIndicator = (update) => {
+            if (!sendTypingEnabled) {
+                return;
+            }
+            const chatId = extractChatId(update);
+            if (chatId === undefined) {
+                return;
+            }
+            void GenericFunctions_1.apiRequest
+                .call(this, 'POST', 'sendChatAction', {
+                chat_id: chatId,
+                action: 'typing',
+            })
+                .catch(() => {
+                // Ignore — typing indicator is best-effort
+            });
+        };
+        let aborted = false;
+        // Clear any existing webhook so getUpdates works.
+        // Telegram rejects getUpdates when a webhook is active.
+        try {
+            await GenericFunctions_1.apiRequest.call(this, 'POST', 'deleteWebhook', {});
+        }
+        catch {
+            // Ignore — webhook may not have been set
+        }
+        // Build allowed_updates array for getUpdates
+        const allowedUpdateTypes = allowedUpdates.length > 0 && !allowedUpdates.includes('*') ? allowedUpdates : undefined;
+        // Backoff state for error recovery (mirrors openclaw's TELEGRAM_POLL_RESTART_POLICY)
+        const BACKOFF = { initialMs: 2000, maxMs: 30_000, factor: 1.8, jitter: 0.25 };
+        let consecutiveErrors = 0;
+        const pollLoop = async () => {
+            while (!aborted) {
+                try {
+                    // Build getUpdates request — true long-polling with 30s timeout (like openclaw)
+                    const body = {
+                        timeout: 30,
+                    };
+                    // Resume from last known update_id
+                    const lastUpdateId = nodeStaticData.lastUpdateId;
+                    if (lastUpdateId !== undefined) {
+                        body.offset = lastUpdateId + 1;
+                    }
+                    if (allowedUpdateTypes) {
+                        body.allowed_updates = JSON.stringify(allowedUpdateTypes);
+                    }
+                    const responseData = await GenericFunctions_1.apiRequest.call(this, 'POST', 'getUpdates', body);
+                    consecutiveErrors = 0; // Reset on success
+                    const updates = responseData.result;
+                    if (!Array.isArray(updates) || updates.length === 0) {
+                        continue;
+                    }
+                    // Track the highest update_id
+                    let maxUpdateId = nodeStaticData.lastUpdateId ?? 0;
+                    for (const update of updates) {
+                        const updateId = update.update_id;
+                        if (updateId > maxUpdateId) {
+                            maxUpdateId = updateId;
+                        }
+                        // Filter by update type
+                        if (allowedUpdateTypes && allowedUpdateTypes.length > 0) {
+                            const updateType = Object.keys(update).find((key) => key !== 'update_id');
+                            if (updateType && !allowedUpdateTypes.includes(updateType)) {
+                                continue;
+                            }
+                        }
+                        // Filter by chat ID
+                        if (additionalFields.chatIds) {
+                            const chatIds = additionalFields.chatIds
+                                .split(',')
+                                .map((id) => id.trim());
+                            const messageChatId = String(update.message?.chat
+                                ? update.message.chat.id
+                                : '');
+                            if (messageChatId && !chatIds.includes(messageChatId)) {
+                                continue;
+                            }
+                        }
+                        // Filter by user ID
+                        if (additionalFields.userIds) {
+                            const userIds = additionalFields.userIds
+                                .split(',')
+                                .map((id) => id.trim());
+                            const messageUserId = String(update.message?.from
+                                ? update.message.from.id
+                                : '');
+                            if (messageUserId && !userIds.includes(messageUserId)) {
+                                continue;
+                            }
+                        }
+                        // Send typing indicator instantly (like openclaw)
+                        sendTypingIndicator(update);
+                        // Emit each matched update as a separate workflow execution
+                        this.emit([this.helpers.returnJsonArray([update])]);
+                    }
+                    // Persist offset even if no updates matched filters — we consumed them
+                    nodeStaticData.lastUpdateId = maxUpdateId;
+                }
+                catch (error) {
+                    if (aborted) {
+                        break;
+                    }
+                    // On 409 conflict, another instance is polling — back off
+                    const errorCode = error.statusCode ??
+                        error.error_code;
+                    if (errorCode === 409) {
+                        // getUpdates conflict — another bot instance is polling
+                        consecutiveErrors++;
+                    }
+                    else {
+                        consecutiveErrors++;
+                    }
+                    // Exponential backoff with jitter (same algorithm as openclaw)
+                    const baseDelay = Math.min(BACKOFF.maxMs, BACKOFF.initialMs * Math.pow(BACKOFF.factor, consecutiveErrors - 1));
+                    const jitter = 1 + (Math.random() * 2 - 1) * BACKOFF.jitter;
+                    const delayMs = Math.min(BACKOFF.maxMs, Math.round(baseDelay * jitter));
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            }
+        };
+        // Manual trigger mode: wait for the first message then return
+        const manualTriggerFunction = async () => {
+            try {
+                await GenericFunctions_1.apiRequest.call(this, 'POST', 'deleteWebhook', {});
+            }
+            catch {
+                // Ignore
+            }
+            const body = {
+                timeout: 30,
+            };
+            const lastUpdateId = nodeStaticData.lastUpdateId;
+            if (lastUpdateId !== undefined) {
+                body.offset = lastUpdateId + 1;
+            }
+            if (allowedUpdateTypes) {
+                body.allowed_updates = JSON.stringify(allowedUpdateTypes);
+            }
+            // Keep polling until we get at least one update
+            while (!aborted) {
+                const responseData = await GenericFunctions_1.apiRequest.call(this, 'POST', 'getUpdates', body);
+                const updates = responseData.result;
+                if (Array.isArray(updates) && updates.length > 0) {
+                    let maxUpdateId = nodeStaticData.lastUpdateId ?? 0;
+                    for (const update of updates) {
+                        const updateId = update.update_id;
+                        if (updateId > maxUpdateId) {
+                            maxUpdateId = updateId;
+                        }
+                    }
+                    nodeStaticData.lastUpdateId = maxUpdateId;
+                    // Send typing indicator for the first update
+                    if (updates.length > 0) {
+                        sendTypingIndicator(updates[0]);
+                    }
+                    this.emit([this.helpers.returnJsonArray(updates)]);
+                    return;
+                }
+                // No updates yet, loop again with long-poll
+            }
+        };
+        // In production trigger mode, start the continuous loop
+        if (this.getMode() === 'trigger') {
+            void pollLoop();
+        }
+        async function closeFunction() {
+            aborted = true;
+        }
+        return {
+            closeFunction,
+            manualTriggerFunction,
+        };
+    }
+}
+exports.TelegramPollingTrigger = TelegramPollingTrigger;

package/dist/nodes/Zoho/GenericFunctions.d.ts

@@ -78,8 +78,8 @@ export declare const adjustDealPayload: (allFields: AllFields) => {
             name: string;
         };
     };
-    accountId?: string | undefined;
     contactId?: string | undefined;
+    accountId?: string | undefined;
     dealId?: string | undefined;
     Product_Details?: ProductDetails;
 };
@@ -129,8 +129,8 @@ export declare const adjustProductPayload: (allFields: AllFields) => {
             name: string;
         };
     };
-    accountId?: string | undefined;
     contactId?: string | undefined;
+    accountId?: string | undefined;
     dealId?: string | undefined;
     Product_Details?: ProductDetails;
 };