@patricktobias86/node-red-telegram-account 1.1.15 → 1.1.16

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.16] - 2025-09-22
+### Added
+- Receiver node option to ignore configurable message types (such as videos or documents) to prevent oversized uploads.
+### Changed
+- Receiver node collects detailed media type metadata to power the new filter while keeping debug logging informative.
+
 ## [1.1.15] - 2025-09-21
 ### Added
 - Receiver node option to drop updates when media exceeds a configurable size threshold, preventing large downloads.

package/README.md

@@ -18,7 +18,7 @@ See [docs/NODES.md](docs/NODES.md) for a detailed description of every node. Bel
 
 - **config** – stores your API credentials and caches sessions for reuse.
 - **auth** – interactive login that outputs a `stringSession` (also set on `msg.stringSession`).
-- **receiver** – emits messages for every incoming update (with optional ignore list and media size limit). Event listeners are cleaned up on node close so redeploys won't duplicate messages.
+- **receiver** – emits messages for every incoming update (with optional ignore list, message type filter, and media size limit). Event listeners are cleaned up on node close so redeploys won't duplicate messages.
 - **command** – triggers when an incoming message matches a command or regex. Event listeners are removed on redeploy to prevent duplicates.
 - **send-message** – sends text or media messages with rich options.
 - **send-files** – uploads one or more files with captions and buttons.

package/docs/NODES.md

@@ -8,7 +8,7 @@ Below is a short description of each node. For a full list of configuration opti
 |------|-------------|
 | **config** | Configuration node storing API credentials and connection options. Other nodes reference this to share a Telegram client and reuse the session. Connections are tracked in a Map with a reference count so multiple nodes can wait for the same connection. |
 | **auth** | Starts an interactive login flow. Produces a `stringSession` (available in both <code>msg.payload.stringSession</code> and <code>msg.stringSession</code>) that can be reused with the `config` node. |
-| **receiver** | Emits an output message for every incoming Telegram message. Can ignore specific user IDs and optionally skip media above a configurable size. Event handlers are automatically removed when the node is closed. |
+| **receiver** | Emits an output message for every incoming Telegram message. Can ignore specific user IDs, skip selected message types (e.g. videos or documents), and optionally drop media above a configurable size. Event handlers are automatically removed when the node is closed. |
 | **command** | Listens for new messages and triggers when a message matches a configured command or regular expression. The event listener is cleaned up on node close to avoid duplicates. |
 | **send-message** | Sends text messages or media files to a chat. Supports parse mode, buttons, scheduling, and more. |
 | **send-files** | Uploads one or more files to a chat with optional caption, thumbnails and other parameters. |

package/nodes/receiver.html

@@ -7,6 +7,7 @@
             name: { value: '' },
             config: { type: 'config', required: false },
             ignore: { value:""},
+            ignoreMessageTypes: { value: "" },
             debug: { value: false },
             maxFileSizeMb: { value: "" }
         },
@@ -59,6 +60,17 @@
         style="width: 60%"
       ></textarea>
     </div>
+    <div class="form-row">
+      <label for="node-input-ignoreMessageTypes">
+        <i class="fa fa-ban"></i> Ignore message types
+      </label>
+      <textarea
+        id="node-input-ignoreMessageTypes"
+        placeholder="e.g. video, document, sticker"
+        style="width: 60%"
+      ></textarea>
+      <p class="form-tips">Separate types with commas or new lines.</p>
+    </div>
     <div class="form-row">
       <label for="node-input-maxFileSizeMb">
         <i class="fa fa-download"></i> Max media size (MB)
@@ -101,6 +113,11 @@
         </dt>
         <dd>A newline-separated list of user IDs to ignore. Messages from these users will not trigger the output.</dd>
 
+        <dt>Ignore message types
+            <span class="property-type">string</span>
+        </dt>
+        <dd>List of message or media types to skip (for example <code>video</code>, <code>document</code>, or <code>sticker</code>). Separate multiple entries with commas or new lines.</dd>
+
         <dt>Max media size (MB)
             <span class="property-type">number</span>
         </dt>
@@ -147,6 +164,7 @@
     <ul>
         <li>Ensure the Telegram bot has sufficient permissions to receive messages in the configured chat or channel.</li>
         <li>The <b>Ignore List</b> only filters messages based on the sender's user ID.</li>
+        <li>Use <b>Ignore message types</b> to drop updates that contain media you don't want to process, such as large videos or documents.</li>
         <li>For advanced filtering based on message content, consider chaining this node with additional processing nodes in Node-RED.</li>
     </ul>
 </script>

package/nodes/receiver.js

@@ -1,6 +1,153 @@
 const { NewMessage } = require("telegram/events");
 const util = require("util");
 
+const splitList = (value) => {
+    if (typeof value !== 'string') {
+        return [];
+    }
+    return value
+        .split(/[\n,\r]/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+};
+
+const toLowerCaseSet = (values) => {
+    const result = new Set();
+    for (const value of values) {
+        result.add(value.toLowerCase());
+    }
+    return result;
+};
+
+const addType = (target, value) => {
+    if (!value) {
+        return;
+    }
+    target.add(String(value).toLowerCase());
+};
+
+const collectDocumentTypes = (document, types) => {
+    if (!document) {
+        return;
+    }
+
+    addType(types, 'document');
+
+    if (Array.isArray(document.attributes)) {
+        for (const attribute of document.attributes) {
+            if (!attribute) {
+                continue;
+            }
+            const attributeName = attribute.className || attribute._;
+            addType(types, attributeName);
+            switch (attributeName) {
+                case 'DocumentAttributeVideo':
+                    addType(types, 'video');
+                    break;
+                case 'DocumentAttributeAudio':
+                    addType(types, 'audio');
+                    if (attribute.voice) {
+                        addType(types, 'voice');
+                    }
+                    break;
+                case 'DocumentAttributeAnimated':
+                    addType(types, 'animation');
+                    break;
+                case 'DocumentAttributeSticker':
+                    addType(types, 'sticker');
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    if (typeof document.mimeType === 'string') {
+        const mimeType = document.mimeType.toLowerCase();
+        addType(types, mimeType);
+        const slashIndex = mimeType.indexOf('/');
+        if (slashIndex > 0) {
+            addType(types, mimeType.slice(0, slashIndex));
+        }
+        if (mimeType.startsWith('video/')) {
+            addType(types, 'video');
+        } else if (mimeType.startsWith('audio/')) {
+            addType(types, 'audio');
+        } else if (mimeType.startsWith('image/')) {
+            addType(types, 'image');
+        }
+    }
+};
+
+const collectMediaTypes = (media, types) => {
+    if (!media) {
+        return;
+    }
+    addType(types, 'media');
+    addType(types, media.className || media._);
+
+    if (media.document) {
+        collectDocumentTypes(media.document, types);
+    }
+    if (media.photo) {
+        addType(types, 'photo');
+    }
+    if (media.webpage) {
+        addType(types, 'webpage');
+        if (media.webpage.document) {
+            collectDocumentTypes(media.webpage.document, types);
+        }
+        if (media.webpage.photo) {
+            addType(types, 'photo');
+        }
+    }
+    if (media.poll) {
+        addType(types, 'poll');
+    }
+    if (media.contact) {
+        addType(types, 'contact');
+    }
+    if (media.geo || media.geoPoint) {
+        addType(types, 'location');
+    }
+    if (media.venue) {
+        addType(types, 'venue');
+    }
+    if (media.game) {
+        addType(types, 'game');
+    }
+    if (media.sticker) {
+        addType(types, 'sticker');
+    }
+};
+
+const collectMessageTypes = (message) => {
+    const types = new Set();
+    if (!message || typeof message !== 'object') {
+        return types;
+    }
+
+    collectMediaTypes(message.media, types);
+
+    if (typeof message.message === 'string' && message.message.length > 0 && !message.media) {
+        addType(types, 'text');
+    }
+
+    if (message.action) {
+        const actionName = message.action.className || message.action._;
+        addType(types, actionName);
+        if (actionName) {
+            addType(types, 'service');
+        }
+    }
+
+    if (message.ttlPeriod) {
+        addType(types, 'self-destructing');
+    }
+
+    return types;
+};
+
 module.exports = function (RED) {
   function Receiver(config) {
     RED.nodes.createNode(this, config);
@@ -8,10 +155,8 @@ module.exports = function (RED) {
     this.debugEnabled = config.debug;
     var node = this;
     const client =  this.config.client;
-    const ignore = (config.ignore || "")
-        .split(/\n/)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
+    const ignore = splitList(config.ignore || "");
+    const ignoredMessageTypes = toLowerCaseSet(splitList(config.ignoreMessageTypes || ""));
     const maxFileSizeMb = Number(config.maxFileSizeMb);
     const maxFileSizeBytes = Number.isFinite(maxFileSizeMb) && maxFileSizeMb > 0
         ? maxFileSizeMb * 1024 * 1024
@@ -106,6 +251,17 @@ module.exports = function (RED) {
             return;
         }
 
+        if (ignoredMessageTypes.size > 0) {
+            const messageTypes = collectMessageTypes(message);
+            const shouldIgnoreType = Array.from(messageTypes).some((type) => ignoredMessageTypes.has(type));
+            if (shouldIgnoreType) {
+                if (debug) {
+                    node.log(`receiver ignoring update with types: ${Array.from(messageTypes).join(', ')}`);
+                }
+                return;
+            }
+        }
+
         if (maxFileSizeBytes != null) {
             const mediaSize = extractMediaSize(message.media);
             if (mediaSize != null && mediaSize > maxFileSizeBytes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patricktobias86/node-red-telegram-account",
-  "version": "1.1.15",
+  "version": "1.1.16",
   "description": "Node-RED nodes to communicate with GramJS.",
   "main": "nodes/config.js",
   "keywords": [

package/test/receiver.test.js

@@ -44,7 +44,7 @@ describe('Receiver node', function() {
   it('skips media updates when size exceeds threshold', function() {
     const { NodeCtor, addCalls } = load();
     const sent = [];
-    const node = new NodeCtor({config:'c', ignore:'', maxFileSizeMb:'5'});
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'5'});
     node.send = (msg) => sent.push(msg);
     const handler = addCalls[0].fn;
 
@@ -56,7 +56,7 @@ describe('Receiver node', function() {
   it('delivers media updates when size is below threshold', function() {
     const { NodeCtor, addCalls } = load();
     const sent = [];
-    const node = new NodeCtor({config:'c', ignore:'', maxFileSizeMb:'5'});
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'5'});
     node.send = (msg) => sent.push(msg);
     const handler = addCalls[0].fn;
 
@@ -64,4 +64,28 @@ describe('Receiver node', function() {
 
     assert.strictEqual(sent.length, 1);
   });
+
+  it('skips updates when media type is ignored', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'video\ndocument', maxFileSizeMb:''});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({ message: { fromId: { userId: 123 }, media: { document: { mimeType: 'video/mp4', attributes: [{ className: 'DocumentAttributeVideo' }] } } } });
+
+    assert.strictEqual(sent.length, 0);
+  });
+
+  it('delivers updates when media type is not ignored', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'voice', maxFileSizeMb:''});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({ message: { fromId: { userId: 123 }, media: { document: { mimeType: 'video/mp4', attributes: [{ className: 'DocumentAttributeVideo' }] } } } });
+
+    assert.strictEqual(sent.length, 1);
+  });
 });