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

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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.
+
 ## [1.1.7] - 2025-07-22
 ### Added
 - Mocha tests for the configuration node ensure sessions are reused correctly.
@@ -26,4 +36,3 @@ All notable changes to this project will be documented in this file.
 ## [1.1.12] - 2025-08-06
 ### Fixed
 - Auth node now emits the generated `stringSession` so it can be used by other nodes.
-

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). 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. 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. |
@@ -22,4 +22,3 @@ Below is a short description of each node. For a full list of configuration opti
 All nodes forward any properties on the incoming `msg` outside of `msg.payload` unchanged.
 
 All nodes provide a **Debug** checkbox. When enabled the node will log its input and output messages to aid troubleshooting.
-

package/nodes/receiver.html

@@ -7,7 +7,9 @@
             name: { value: '' },
             config: { type: 'config', required: false },
             ignore: { value:""},
-            debug: { value: false }
+            ignoreMessageTypes: { value: "" },
+            debug: { value: false },
+            maxFileSizeMb: { value: "" }
         },
         inputs: 1,
         outputs: 1,
@@ -49,15 +51,39 @@
     </div>
     <div class="form-row">
       <label for="node-input-ignore">
-        <i class="fa fa-tag"></i> Config
+        <i class="fa fa-user-times"></i> Ignore list
       </label>
       <textarea
         type="text"
         id="node-input-ignore"
-        placeholder="Config"
+        placeholder="Enter user IDs, one per line"
         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)
+      </label>
+      <input
+        type="number"
+        id="node-input-maxFileSizeMb"
+        placeholder="Leave blank to disable"
+        min="0"
+        step="0.1"
+        style="width: 60%"
+      />
+    </div>
   </script>
 
 <script type="text/html" data-help-name="receiver">
@@ -86,6 +112,16 @@
             <span class="property-type">string</span>
         </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>
+        <dd>Skip updates that include media exceeding this size. Leave blank to process all media.</dd>
     </dl>
 
     <h3>Details</h3>
@@ -128,8 +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,7 +155,90 @@ module.exports = function (RED) {
     this.debugEnabled = config.debug;
     var node = this;
     const client =  this.config.client;
-    const ignore = config.ignore.split(/\n/);
+    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
+        : null;
+
+    const toNumber = (value) => {
+        if (typeof value === 'number') {
+            return value;
+        }
+        if (typeof value === 'bigint') {
+            const result = Number(value);
+            return Number.isFinite(result) ? result : Number.MAX_SAFE_INTEGER;
+        }
+        return undefined;
+    };
+
+    const extractPhotoSize = (photo) => {
+        if (!photo || !Array.isArray(photo.sizes)) {
+            return null;
+        }
+        let max = 0;
+        for (const size of photo.sizes) {
+            if (size == null) {
+                continue;
+            }
+            if (Array.isArray(size.sizes)) {
+                for (const nested of size.sizes) {
+                    const nestedValue = toNumber(nested);
+                    if (nestedValue != null && nestedValue > max) {
+                        max = nestedValue;
+                    }
+                }
+            }
+            const value = toNumber(size.size ?? size.length ?? size.bytes);
+            if (value != null && value > max) {
+                max = value;
+            }
+        }
+        return max > 0 ? max : null;
+    };
+
+    const extractMediaSize = (media) => {
+        if (!media) {
+            return null;
+        }
+
+        if (media.document && media.document.size != null) {
+            const value = toNumber(media.document.size);
+            if (value != null) {
+                return value;
+            }
+        }
+
+        if (media.photo) {
+            const photoSize = extractPhotoSize(media.photo);
+            if (photoSize != null) {
+                return photoSize;
+            }
+        }
+
+        if (media.webpage) {
+            const { document, photo } = media.webpage;
+            const docSize = document && toNumber(document.size);
+            if (docSize != null) {
+                return docSize;
+            }
+            const photoSize = extractPhotoSize(photo);
+            if (photoSize != null) {
+                return photoSize;
+            }
+        }
+
+        const className = media.className || media._;
+        if ((className === 'MessageMediaDocument' || className === 'MessageMediaPhoto') && media.size != null) {
+            const value = toNumber(media.size);
+            if (value != null) {
+                return value;
+            }
+        }
+
+        return null;
+    };
 
     const event = new NewMessage();
     const handler = (update) => {
@@ -16,7 +246,38 @@ module.exports = function (RED) {
         if (debug) {
             node.log('receiver update: ' + util.inspect(update, { depth: null }));
         }
-        if (update.message.fromId != null && update.message.fromId.userId != null && !ignore.includes(update.message.fromId.userId.toString())) {
+        const message = update && update.message;
+        if (!message) {
+            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) {
+                if (debug) {
+                    node.log(`receiver ignoring update with media size ${mediaSize} bytes exceeding limit ${maxFileSizeBytes}`);
+                }
+                return;
+            }
+        }
+
+        const senderId = message.fromId && message.fromId.userId;
+        if (senderId != null && ignore.includes(senderId.toString())) {
+            return;
+        }
+
+        if (message.fromId != null && message.fromId.userId != null) {
             const out = { payload: { update } };
             node.send(out);
             if (debug) {

package/package.json

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

package/test/receiver.test.js

@@ -40,4 +40,52 @@ describe('Receiver node', function() {
     assert.strictEqual(removeCalls[0].fn, addCalls[0].fn);
     assert.strictEqual(removeCalls[0].event, addCalls[0].event);
   });
+
+  it('skips media updates when size exceeds threshold', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'5'});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({ message: { fromId: { userId: 123 }, media: { document: { size: 6 * 1024 * 1024 } } } });
+
+    assert.strictEqual(sent.length, 0);
+  });
+
+  it('delivers media updates when size is below threshold', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'5'});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({ message: { fromId: { userId: 123 }, media: { document: { size: 3 * 1024 * 1024 } } } });
+
+    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);
+  });
 });