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

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.17] - 2026-01-05
+### Fixed
+- Receiver node now listens to Raw MTProto updates and derives sender/chat identity safely so valid messages (channel posts, anonymous admins, service messages, missing fromId) are no longer dropped.
+
+## [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 Telegram message using Raw MTProto updates (with optional ignore list, message type filter, and media size limit), including channel posts and service messages. 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 using Raw MTProto updates (so channel posts, anonymous admins and service messages are not missed). Can ignore specific user IDs, skip selected message types (e.g. videos or documents), and optionally drop media above a configurable size. Output includes derived `peer`, `sender`, `senderType`, `senderId`, `chatId`, `isSilent`, and `messageTypes`. 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,331 @@
-const { NewMessage } = require("telegram/events");
+const { Raw } = 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;
+};
+
+const getClassName = (value) => {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    return value.className || value._;
+};
+
+const toPeerInfo = (peer) => {
+    if (!peer || typeof peer !== 'object') {
+        return null;
+    }
+
+    const className = getClassName(peer);
+    const userId = peer.userId ?? peer.user_id;
+    const chatId = peer.chatId ?? peer.chat_id;
+    const channelId = peer.channelId ?? peer.channel_id;
+
+    // GramJS TL objects represent peers as PeerUser / PeerChat / PeerChannel.
+    // MTProto updates can omit fromId (anonymous admins, channel posts, etc.), so
+    // we normalize peer identity from whichever peer object we have.
+    if (userId != null) {
+        return { type: 'user', userId, chatId: null, channelId: null, peer };
+    }
+    if (chatId != null) {
+        return { type: 'chat', userId: null, chatId, channelId: null, peer };
+    }
+    if (channelId != null) {
+        return { type: 'channel', userId: null, chatId: null, channelId, peer };
+    }
+
+    if (className) {
+        return { type: className, userId: null, chatId: null, channelId: null, peer };
+    }
+    return { type: 'unknown', userId: null, chatId: null, channelId: null, peer };
+};
+
+const toSafeNumber = (value) => {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === 'bigint') {
+        const result = Number(value);
+        return Number.isFinite(result) ? result : Number.MAX_SAFE_INTEGER;
+    }
+    return null;
+};
+
+const peerChatId = (peerInfo) => {
+    if (!peerInfo) {
+        return null;
+    }
+    // For Node-RED flows "chatId" typically means "the conversation identifier".
+    // For private chats that's the userId; for groups it's chatId; for channels it's channelId.
+    if (peerInfo.type === 'user') {
+        return toSafeNumber(peerInfo.userId);
+    }
+    if (peerInfo.type === 'chat') {
+        return toSafeNumber(peerInfo.chatId);
+    }
+    if (peerInfo.type === 'channel') {
+        return toSafeNumber(peerInfo.channelId);
+    }
+    return null;
+};
+
+const buildPeerUser = (userId) => ({ className: 'PeerUser', userId });
+const buildPeerChat = (chatId) => ({ className: 'PeerChat', chatId });
+
+const toDerivedMessage = (update) => {
+    const className = getClassName(update);
+    if (className === 'UpdateShortMessage') {
+        const userId = update.userId ?? update.user_id;
+        return {
+            className: 'Message',
+            id: update.id,
+            date: update.date,
+            out: update.out,
+            silent: update.silent,
+            // In UpdateShortMessage, userId is the peer and also the sender for incoming messages.
+            peerId: userId != null ? buildPeerUser(userId) : undefined,
+            fromId: userId != null ? buildPeerUser(userId) : undefined,
+            message: update.message,
+            entities: update.entities,
+            fwdFrom: update.fwdFrom,
+            viaBotId: update.viaBotId,
+            replyTo: update.replyTo,
+            ttlPeriod: update.ttlPeriod,
+            media: update.media
+        };
+    }
+
+    if (className === 'UpdateShortChatMessage') {
+        const chatId = update.chatId ?? update.chat_id;
+        const fromId = update.fromId ?? update.from_id;
+        return {
+            className: 'Message',
+            id: update.id,
+            date: update.date,
+            out: update.out,
+            silent: update.silent,
+            peerId: chatId != null ? buildPeerChat(chatId) : undefined,
+            fromId: fromId != null ? buildPeerUser(fromId) : undefined,
+            message: update.message,
+            entities: update.entities,
+            fwdFrom: update.fwdFrom,
+            viaBotId: update.viaBotId,
+            replyTo: update.replyTo,
+            ttlPeriod: update.ttlPeriod,
+            media: update.media
+        };
+    }
+
+    if (className === 'UpdateShortSentMessage') {
+        // This update doesn't include a peer; it's still a real MTProto message update.
+        // We emit it with a best-effort message shape so flows can still react.
+        return {
+            className: 'Message',
+            id: update.id,
+            date: update.date,
+            out: true,
+            silent: update.silent,
+            message: update.message,
+            entities: update.entities,
+            media: update.media
+        };
+    }
+
+    return null;
+};
+
+const extractMessageEvents = (rawUpdate) => {
+    // Raw MTProto updates can be nested (Updates / UpdatesCombined / UpdateShort).
+    // We must unwrap them here instead of relying on NewMessage(), which can miss
+    // valid message updates (e.g. channel posts, edits, anonymous admins).
+    const results = [];
+
+    const walk = (update) => {
+        if (!update || typeof update !== 'object') {
+            return;
+        }
+
+        const className = getClassName(update);
+
+        if (Array.isArray(update.updates)) {
+            for (const nested of update.updates) {
+                walk(nested);
+            }
+            return;
+        }
+
+        if (update.update) {
+            walk(update.update);
+            return;
+        }
+
+        if (className === 'UpdateNewMessage' ||
+            className === 'UpdateNewChannelMessage' ||
+            className === 'UpdateEditMessage' ||
+            className === 'UpdateEditChannelMessage') {
+            if (update.message) {
+                results.push({ update, message: update.message });
+            } else {
+                results.push({ update, message: null });
+            }
+            return;
+        }
+
+        const derived = toDerivedMessage(update);
+        if (derived) {
+            results.push({ update, message: derived });
+            return;
+        }
+    };
+
+    walk(rawUpdate);
+    return results;
+};
+
 module.exports = function (RED) {
   function Receiver(config) {
     RED.nodes.createNode(this, config);
@@ -8,26 +333,13 @@ 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
         : 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;
@@ -39,13 +351,13 @@ module.exports = function (RED) {
             }
             if (Array.isArray(size.sizes)) {
                 for (const nested of size.sizes) {
-                    const nestedValue = toNumber(nested);
+                    const nestedValue = toSafeNumber(nested);
                     if (nestedValue != null && nestedValue > max) {
                         max = nestedValue;
                     }
                 }
             }
-            const value = toNumber(size.size ?? size.length ?? size.bytes);
+            const value = toSafeNumber(size.size ?? size.length ?? size.bytes);
             if (value != null && value > max) {
                 max = value;
             }
@@ -59,7 +371,7 @@ module.exports = function (RED) {
         }
 
         if (media.document && media.document.size != null) {
-            const value = toNumber(media.document.size);
+            const value = toSafeNumber(media.document.size);
             if (value != null) {
                 return value;
             }
@@ -74,7 +386,7 @@ module.exports = function (RED) {
 
         if (media.webpage) {
             const { document, photo } = media.webpage;
-            const docSize = document && toNumber(document.size);
+            const docSize = document && toSafeNumber(document.size);
             if (docSize != null) {
                 return docSize;
             }
@@ -86,7 +398,7 @@ module.exports = function (RED) {
 
         const className = media.className || media._;
         if ((className === 'MessageMediaDocument' || className === 'MessageMediaPhoto') && media.size != null) {
-            const value = toNumber(media.size);
+            const value = toSafeNumber(media.size);
             if (value != null) {
                 return value;
             }
@@ -95,34 +407,94 @@ module.exports = function (RED) {
         return null;
     };
 
-    const event = new NewMessage();
-    const handler = (update) => {
+    const debugLog = (message) => {
+        if (node.debugEnabled) {
+            node.log(message);
+        }
+    };
+
+    const event = new Raw({});
+    const handler = (rawUpdate) => {
         const debug = node.debugEnabled;
         if (debug) {
-            node.log('receiver update: ' + util.inspect(update, { depth: null }));
+            node.log('receiver raw update: ' + util.inspect(rawUpdate, { depth: null }));
         }
-        const message = update && update.message;
-        if (!message) {
+
+        const extracted = extractMessageEvents(rawUpdate);
+        if (extracted.length === 0) {
+            // Raw emits *all* MTProto updates; many are not message-bearing updates (typing, reads, etc.).
+            // We do not output those by default, but we also do not silently hide that they occurred.
+            debugLog(`receiver ignoring non-message MTProto update: ${getClassName(rawUpdate) || 'unknown'}`);
             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}`);
+        for (const { update, message } of extracted) {
+            if (!message) {
+                debugLog(`receiver ignoring message update without message payload: ${getClassName(update) || 'unknown'}`);
+                continue;
+            }
+
+            const messageTypes = collectMessageTypes(message);
+            const isSilent = Boolean(message.silent || update.silent);
+
+            const peer = toPeerInfo(message.peerId || message.toId);
+
+            // Do NOT assume message.fromId.userId exists.
+            // fromId can be PeerUser / PeerChat / PeerChannel, can be missing (channel posts),
+            // and can represent anonymous admins. Prefer fromId when present; otherwise fall back
+            // to the chat peer for channel posts to avoid dropping valid messages.
+            const sender =
+                toPeerInfo(message.fromId) ||
+                (message.senderId != null ? toPeerInfo(buildPeerUser(message.senderId)) : null) ||
+                (message.post ? peer : null);
+
+            const senderType = sender ? sender.type : 'unknown';
+            const senderId =
+                senderType === 'user' ? toSafeNumber(sender.userId) :
+                senderType === 'chat' ? toSafeNumber(sender.chatId) :
+                senderType === 'channel' ? toSafeNumber(sender.channelId) :
+                null;
+
+            const chatId = peerChatId(peer);
+
+            if (ignoredMessageTypes.size > 0) {
+                const shouldIgnoreType = Array.from(messageTypes).some((type) => ignoredMessageTypes.has(type));
+                if (shouldIgnoreType) {
+                    debugLog(`receiver ignoring message due to ignoreMessageTypes; types=${Array.from(messageTypes).join(', ')}`);
+                    continue;
                 }
-                return;
             }
-        }
 
-        const senderId = message.fromId && message.fromId.userId;
-        if (senderId != null && ignore.includes(senderId.toString())) {
-            return;
-        }
+            if (maxFileSizeBytes != null) {
+                const mediaSize = extractMediaSize(message.media);
+                if (mediaSize != null && mediaSize > maxFileSizeBytes) {
+                    debugLog(`receiver ignoring message due to maxFileSizeMb; mediaSize=${mediaSize} limitBytes=${maxFileSizeBytes}`);
+                    continue;
+                }
+            }
+
+            // Preserve existing behavior: ignore list is a list of user IDs.
+            // Previously the node assumed message.fromId.userId always existed, which dropped valid updates.
+            // Now we only apply the ignore list when we can confidently identify a user sender.
+            if (senderType === 'user' && senderId != null && ignore.includes(String(senderId))) {
+                debugLog(`receiver ignoring message due to ignore list; userId=${senderId}`);
+                continue;
+            }
+
+            const out = {
+                payload: {
+                    update,
+                    message,
+                    peer,
+                    sender,
+                    senderType,
+                    senderId,
+                    chatId,
+                    isSilent,
+                    messageTypes: Array.from(messageTypes)
+                }
+            };
 
-        if (message.fromId != null && message.fromId.userId != null) {
-            const out = { payload: { update } };
             node.send(out);
             if (debug) {
                 node.log('receiver output: ' + util.inspect(out, { depth: null }));

package/package.json

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

package/test/receiver-debug.test.js

@@ -8,7 +8,7 @@ function load() {
     addEventHandler(fn, event) { addCalls.push({fn, event}); }
     removeEventHandler() {}
   }
-  class NewMessageStub {}
+  class RawStub {}
 
   let NodeCtor;
   const configNode = { client: new TelegramClientStub() };
@@ -26,7 +26,7 @@ function load() {
   };
 
   proxyquire('../nodes/receiver.js', {
-    'telegram/events': { NewMessage: NewMessageStub }
+    'telegram/events': { Raw: RawStub }
   })(RED);
 
   return { NodeCtor, addCalls, logs };
@@ -37,8 +37,11 @@ describe('Receiver node debug with BigInt', function() {
     const { NodeCtor, addCalls, logs } = load();
     const node = new NodeCtor({config:'c', ignore:'', debug:true});
     const handler = addCalls[0].fn;
-    assert.doesNotThrow(() => handler({ message: { fromId:{userId:1n} } }));
-    assert(logs.some(l => l.includes('receiver update')));
+    assert.doesNotThrow(() => handler({
+      className: 'UpdateNewMessage',
+      message: { fromId:{userId:1n}, peerId:{userId:1n}, message:'hi' }
+    }));
+    assert(logs.some(l => l.includes('receiver raw update')));
     assert(logs.some(l => l.includes('receiver output')));
   });
 });

package/test/receiver.test.js

@@ -8,7 +8,7 @@ function load() {
     addEventHandler(fn, event) { addCalls.push({fn, event}); }
     removeEventHandler(fn, event) { removeCalls.push({fn, event}); }
   }
-  class NewMessageStub {}
+  class RawStub {}
 
   let NodeCtor;
   const configNode = { client: new TelegramClientStub() };
@@ -24,7 +24,7 @@ function load() {
   };
 
   proxyquire('../nodes/receiver.js', {
-    'telegram/events': { NewMessage: NewMessageStub }
+    'telegram/events': { Raw: RawStub }
   })(RED);
 
   return { NodeCtor, addCalls, removeCalls };
@@ -44,11 +44,14 @@ 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;
 
-    handler({ message: { fromId: { userId: 123 }, media: { document: { size: 6 * 1024 * 1024 } } } });
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 123 }, media: { document: { size: 6 * 1024 * 1024 } } }
+    });
 
     assert.strictEqual(sent.length, 0);
   });
@@ -56,11 +59,44 @@ 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;
 
-    handler({ message: { fromId: { userId: 123 }, media: { document: { size: 3 * 1024 * 1024 } } } });
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ 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({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ 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({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 123 }, media: { document: { mimeType: 'video/mp4', attributes: [{ className: 'DocumentAttributeVideo' }] } } }
+    });
 
     assert.strictEqual(sent.length, 1);
   });