imapflow 1.0.153 → 1.0.155

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.0.155](https://github.com/postalsys/imapflow/compare/v1.0.154...v1.0.155) (2024-03-06)
+
+
+### Bug Fixes
+
+* **exchange:** handle special error response from exchange ([3ed4198](https://github.com/postalsys/imapflow/commit/3ed4198c1b5504ab0b46926fec179c682988b2e3))
+
+## [1.0.154](https://github.com/postalsys/imapflow/compare/v1.0.153...v1.0.154) (2024-03-05)
+
+
+### Bug Fixes
+
+* **FETCH:** throw on failing FETCH ([12f9a45](https://github.com/postalsys/imapflow/commit/12f9a45530c6f3a2f35ba2968819011eea9c32b2))
+
 ## [1.0.153](https://github.com/postalsys/imapflow/compare/v1.0.152...v1.0.153) (2024-02-29)
 
 

package/lib/commands/fetch.js

@@ -203,7 +203,7 @@ module.exports = async (connection, range, query, options) => {
             }
 
             connection.log.warn({ err, cid: connection.id });
-            return false;
+            throw err;
         }
     }
 };

package/lib/handler/imap-parser.js

@@ -24,29 +24,37 @@ module.exports = async (command, options) => {
     const parser = new ParserInstance(command, options);
     const response = {};
 
-    response.tag = await parser.getTag();
-    await parser.getSpace();
-    response.command = await parser.getCommand();
+    try {
+        response.tag = await parser.getTag();
 
-    if (nullBytesRemoved) {
-        response.nullBytesRemoved = nullBytesRemoved;
-    }
-
-    if (['UID', 'AUTHENTICATE'].indexOf((response.command || '').toUpperCase()) >= 0) {
         await parser.getSpace();
-        response.command += ' ' + (await parser.getElement(imapFormalSyntax.command()));
-    }
+        response.command = await parser.getCommand();
 
-    if (parser.remainder.trim().length) {
-        await parser.getSpace();
-        response.attributes = await parser.getAttributes();
-    }
+        if (nullBytesRemoved) {
+            response.nullBytesRemoved = nullBytesRemoved;
+        }
 
-    if (parser.humanReadable) {
-        response.attributes = (response.attributes || []).concat({
-            type: 'TEXT',
-            value: parser.humanReadable
-        });
+        if (['UID', 'AUTHENTICATE'].indexOf((response.command || '').toUpperCase()) >= 0) {
+            await parser.getSpace();
+            response.command += ' ' + (await parser.getElement(imapFormalSyntax.command()));
+        }
+
+        if (parser.remainder.trim().length) {
+            await parser.getSpace();
+            response.attributes = await parser.getAttributes();
+        }
+
+        if (parser.humanReadable) {
+            response.attributes = (response.attributes || []).concat({
+                type: 'TEXT',
+                value: parser.humanReadable
+            });
+        }
+    } catch (err) {
+        if (err.code === 'ParserErrorExchange' && err.parserContext && err.parserContext.value) {
+            return err.parserContext.value;
+        }
+        throw err;
     }
 
     return response;

package/lib/handler/parser-instance.js

@@ -73,16 +73,42 @@ class ParserInstance {
         let match, element, errPos;
 
         if (this.remainder.match(/^\s/)) {
-            throw new Error(`Unexpected whitespace at position ${this.pos} [E1]`);
+            let error = new Error(`Unexpected whitespace at position ${this.pos} [E1]`);
+            error.code = 'ParserError1';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         if ((match = this.remainder.match(/^\s*[^\s]+(?=\s|$)/))) {
             element = match[0];
             if ((errPos = imapFormalSyntax.verify(element, syntax)) >= 0) {
-                throw new Error(`Unexpected char at position ${this.pos + errPos} [E2: ${JSON.stringify(element.charAt(errPos))}]`);
+                if (this.tag === 'Server' && element === 'Unavailable.') {
+                    // Exchange error
+                    let error = new Error(`Server returned an error: ${this.input}`);
+                    error.code = 'ParserErrorExchange';
+                    error.parserContext = {
+                        input: this.input,
+                        element,
+                        pos: this.pos,
+                        value: {
+                            tag: '*',
+                            command: 'BAD',
+                            attributes: [{ type: 'TEXT', value: this.input }]
+                        }
+                    };
+                    throw error;
+                }
+
+                let error = new Error(`Unexpected char at position ${this.pos + errPos} [E2: ${JSON.stringify(element.charAt(errPos))}]`);
+                error.code = 'ParserError2';
+                error.parserContext = { input: this.input, element, pos: this.pos };
+                throw error;
             }
         } else {
-            throw new Error(`Unexpected end of input at position ${this.pos} [E3]`);
+            let error = new Error(`Unexpected end of input at position ${this.pos} [E3]`);
+            error.code = 'ParserError3';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         this.pos += match[0].length;
@@ -93,11 +119,17 @@ class ParserInstance {
 
     async getSpace() {
         if (!this.remainder.length) {
-            throw new Error(`Unexpected end of input at position ${this.pos} [E4]`);
+            let error = new Error(`Unexpected end of input at position ${this.pos} [E4]`);
+            error.code = 'ParserError4';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         if (imapFormalSyntax.verify(this.remainder.charAt(0), imapFormalSyntax.SP()) >= 0) {
-            throw new Error(`Unexpected char at position ${this.pos} [E5: ${JSON.stringify(this.remainder.charAt(0))}]`);
+            let error = new Error(`Unexpected char at position ${this.pos} [E5: ${JSON.stringify(this.remainder.charAt(0))}]`);
+            error.code = 'ParserError5';
+            error.parserContext = { input: this.input, element: this.remainder, pos: this.pos };
+            throw error;
         }
 
         this.pos++;
@@ -106,11 +138,17 @@ class ParserInstance {
 
     async getAttributes() {
         if (!this.remainder.length) {
-            throw new Error(`Unexpected end of input at position ${this.pos} [E6]`);
+            let error = new Error(`Unexpected end of input at position ${this.pos} [E6]`);
+            error.code = 'ParserError6';
+            error.parserContext = { input: this.input, pos: this.pos };
+            throw error;
         }
 
         if (this.remainder.match(/^\s/)) {
-            throw new Error(`Unexpected whitespace at position ${this.pos} [E7]`);
+            let error = new Error(`Unexpected whitespace at position ${this.pos} [E7]`);
+            error.code = 'ParserError7';
+            error.parserContext = { input: this.input, element: this.remainder, pos: this.pos };
+            throw error;
         }
 
         const tokenParser = new TokenParser(this, this.pos, this.remainder, this.options);

package/lib/handler/token-parser.js

@@ -36,7 +36,10 @@ class TokenParser {
 
             // If the node was never closed, throw it
             if (!node.isClosed) {
-                throw new Error(`Unexpected end of input at position ${this.pos + this.str.length - 1} [E6]`);
+                let error = new Error(`Unexpected end of input at position ${this.pos + this.str.length - 1} [E9]`);
+                error.code = 'ParserError9';
+                error.parserContext = { input: this.str, pos: this.pos + this.str.length - 1 };
+                throw error;
             }
 
             let type = (node.type || '').toString().toUpperCase();
@@ -149,7 +152,10 @@ class TokenParser {
                         // ) closes a list
                         case ')':
                             if (this.currentNode.type !== 'LIST') {
-                                throw new Error(`Unexpected list terminator ) at position ${this.pos + i} [E7]`);
+                                let error = new Error(`Unexpected list terminator ) at position ${this.pos + i} [E10]`);
+                                error.code = 'ParserError10';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
 
                             this.currentNode.isClosed = true;
@@ -162,7 +168,10 @@ class TokenParser {
                         // ] closes section group
                         case ']':
                             if (this.currentNode.type !== 'SECTION') {
-                                throw new Error(`Unexpected section terminator ] at position ${this.pos + i} [E8]`);
+                                let error = new Error(`Unexpected section terminator ] at position ${this.pos + i} [E11]`);
+                                error.code = 'ParserError11';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
                             this.currentNode.isClosed = true;
                             this.currentNode.endPos = this.pos + i;
@@ -199,7 +208,10 @@ class TokenParser {
                                     break;
                                 }
 
-                                throw new Error(`Unexpected literal8 marker at position ${this.pos + i} [E9]`);
+                                let error = new Error(`Unexpected literal8 marker at position ${this.pos + i} [E12]`);
+                                error.code = 'ParserError12';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
                             this.expectedLiteralType = 'literal8';
                             break;
@@ -282,7 +294,10 @@ class TokenParser {
                             // Allow % to support LIST '' %
                             // Allow 8bit characters (presumably unicode)
                             if (imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 && chr !== '\\' && chr !== '%' && chr.charCodeAt(0) < 0x80) {
-                                throw new Error(`Unexpected char at position ${this.pos + i} [E10: ${JSON.stringify(chr)}]`);
+                                let error = new Error(`Unexpected char at position ${this.pos + i} [E13: ${JSON.stringify(chr)}]`);
+                                error.code = 'ParserError13';
+                                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                                throw error;
                             }
 
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
@@ -329,7 +344,10 @@ class TokenParser {
                     if (chr === '[') {
                         // allowed only for selected elements
                         if (['BODY', 'BODY.PEEK', 'BINARY', 'BINARY.PEEK'].indexOf(this.currentNode.value.toUpperCase()) < 0) {
-                            throw new Error(`Unexpected section start char [ at position ${this.pos} [E11]`);
+                            let error = new Error(`Unexpected section start char [ at position ${this.pos + i} [E14]`);
+                            error.code = 'ParserError14';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.createNode(this.currentNode.parentNode, this.pos + i);
@@ -340,7 +358,10 @@ class TokenParser {
                     }
 
                     if (chr === '<') {
-                        throw new Error(`Unexpected start of partial at position ${this.pos} [E12]`);
+                        let error = new Error(`Unexpected start of partial at position ${this.pos + i} [E15]`);
+                        error.code = 'ParserError15';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     // if the char is not ATOM compatible, throw. Allow \* as an exception
@@ -351,9 +372,15 @@ class TokenParser {
                         !(chr === '*' && this.currentNode.value === '\\') &&
                         (!this.parent || !this.parent.command || !['NO', 'BAD', 'OK'].includes(this.parent.command))
                     ) {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E13: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E16: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError16';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     } else if (this.currentNode.value === '\\*') {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E14: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E17: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError17';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     this.currentNode.value += chr;
@@ -375,7 +402,10 @@ class TokenParser {
                     if (chr === '\\') {
                         i++;
                         if (i >= len) {
-                            throw new Error(`Unexpected end of input at position ${this.pos + i} [E15]`);
+                            let error = new Error(`Unexpected end of input at position ${this.pos + i} [E18]`);
+                            error.code = 'ParserError18';
+                            error.parserContext = { input: this.str, pos: this.pos + i };
+                            throw error;
                         }
                         chr = this.str.charAt(i);
                     }
@@ -386,7 +416,10 @@ class TokenParser {
                 case 'PARTIAL':
                     if (chr === '>') {
                         if (this.currentNode.value.substr(-1) === '.') {
-                            throw new Error(`Unexpected end of partial at position ${this.pos} [E16]`);
+                            let error = new Error(`Unexpected end of partial at position ${this.pos + 1} [E19]`);
+                            error.code = 'ParserError19';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode.isClosed = true;
@@ -397,15 +430,24 @@ class TokenParser {
                     }
 
                     if (chr === '.' && (!this.currentNode.value.length || this.currentNode.value.match(/\./))) {
-                        throw new Error(`Unexpected partial separator . at position ${this.pos} [E17]`);
+                        let error = new Error(`Unexpected partial separator . at position ${this.pos + 1} [E20]`);
+                        error.code = 'ParserError20';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     if (imapFormalSyntax.DIGIT().indexOf(chr) < 0 && chr !== '.') {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E18: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E21: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError21';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     if (this.currentNode.value.match(/^0$|\.0$/) && chr !== '.') {
-                        throw new Error(`Invalid partial at position ${this.pos + i} [E19: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Invalid partial at position ${this.pos + i} [E22: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError22';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     this.currentNode.value += chr;
@@ -444,14 +486,20 @@ class TokenParser {
 
                     if (chr === '}') {
                         if (!('literalLength' in this.currentNode)) {
-                            throw new Error(`Unexpected literal prefix end char } at position ${this.pos + i} [E20]`);
+                            let error = new Error(`Unexpected literal prefix end char } at position ${this.pos + i} [E23]`);
+                            error.code = 'ParserError23';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         if (this.str.charAt(i + 1) === '\n') {
                             i++;
                         } else if (this.str.charAt(i + 1) === '\r' && this.str.charAt(i + 2) === '\n') {
                             i += 2;
                         } else {
-                            throw new Error(`Unexpected char at position ${this.pos + i} [E21: ${JSON.stringify(chr)}]`);
+                            let error = new Error(`Unexpected char at position ${this.pos + i} [E24: ${JSON.stringify(chr)}]`);
+                            error.code = 'ParserError24';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
 
                         this.currentNode.literalLength = Number(this.currentNode.literalLength);
@@ -492,10 +540,16 @@ class TokenParser {
                         break;
                     }
                     if (imapFormalSyntax.DIGIT().indexOf(chr) < 0) {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E22: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E25: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError25';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
                     if (this.currentNode.literalLength === '0') {
-                        throw new Error(`Invalid literal at position ${this.pos + i} [E23]`);
+                        let error = new Error(`Invalid literal at position ${this.pos + i} [E26]`);
+                        error.code = 'ParserError26';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
                     this.currentNode.literalLength = (this.currentNode.literalLength || '') + chr;
                     break;
@@ -504,11 +558,17 @@ class TokenParser {
                     // space finishes the sequence set
                     if (chr === ' ') {
                         if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
-                            throw new Error(`Unexpected whitespace at position ${this.pos + i} [E24]`);
+                            let error = new Error(`Unexpected whitespace at position ${this.pos + i} [E27]`);
+                            error.code = 'ParserError27';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
 
                         if (this.currentNode.value !== '*' && this.currentNode.value.substr(-1) === '*' && this.currentNode.value.substr(-2, 1) !== ':') {
-                            throw new Error(`Unexpected whitespace at position ${this.pos + i} [E25]`);
+                            let error = new Error(`Unexpected whitespace at position ${this.pos + i} [E28]`);
+                            error.code = 'ParserError28';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
 
                         this.currentNode.isClosed = true;
@@ -531,25 +591,43 @@ class TokenParser {
 
                     if (chr === ':') {
                         if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
-                            throw new Error(`Unexpected range separator : at position ${this.pos + i} [E26]`);
+                            let error = new Error(`Unexpected range separator : at position ${this.pos + i} [E29]`);
+                            error.code = 'ParserError29';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                     } else if (chr === '*') {
                         if ([',', ':'].indexOf(this.currentNode.value.substr(-1)) < 0) {
-                            throw new Error(`Unexpected range wildcard at position ${this.pos + i} [E27]`);
+                            let error = new Error(`Unexpected range wildcard at position ${this.pos + i} [E30]`);
+                            error.code = 'ParserError30';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                     } else if (chr === ',') {
                         if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
-                            throw new Error(`Unexpected sequence separator , at position ${this.pos + i} [E28]`);
+                            let error = new Error(`Unexpected sequence separator , at position ${this.pos + i} [E31]`);
+                            error.code = 'ParserError31';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                         if (this.currentNode.value.substr(-1) === '*' && this.currentNode.value.substr(-2, 1) !== ':') {
-                            throw new Error(`Unexpected sequence separator , at position ${this.pos + i} [E29]`);
+                            let error = new Error(`Unexpected sequence separator , at position ${this.pos + i} [E32]`);
+                            error.code = 'ParserError32';
+                            error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                            throw error;
                         }
                     } else if (!chr.match(/\d/)) {
-                        throw new Error(`Unexpected char at position ${this.pos + i} [E30: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected char at position ${this.pos + i} [E33: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError33';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     if (chr.match(/\d/) && this.currentNode.value.substr(-1) === '*') {
-                        throw new Error(`Unexpected number at position ${this.pos + i} [E31: ${JSON.stringify(chr)}]`);
+                        let error = new Error(`Unexpected number at position ${this.pos + i} [E34: ${JSON.stringify(chr)}]`);
+                        error.code = 'ParserError34';
+                        error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                        throw error;
                     }
 
                     this.currentNode.value += chr;

package/lib/imap-flow.js

@@ -2254,93 +2254,94 @@ class ImapFlow extends EventEmitter {
      */
     async *fetch(range, query, options) {
         options = options || {};
-        try {
-            if (!this.mailbox) {
-                // no mailbox selected, nothing to do
-                return;
-            }
 
-            range = await this.resolveRange(range, options);
-            if (!range) {
-                return false;
-            }
+        if (!this.mailbox) {
+            // no mailbox selected, nothing to do
+            return;
+        }
 
-            let finished = false;
-            let push = false;
-            let rowQueue = [];
-            let getNext = () =>
-                new Promise((resolve, reject) => {
-                    let check = () => {
-                        if (rowQueue.length) {
-                            let entry = rowQueue.shift();
-                            if (entry.err) {
-                                return reject(entry.err);
-                            } else {
-                                return resolve(entry.value);
-                            }
-                        }
-                        if (finished) {
-                            return resolve(null);
-                        }
+        range = await this.resolveRange(range, options);
+        if (!range) {
+            return false;
+        }
 
-                        // wait until data is pushed to queue and try again
-                        push = () => {
-                            push = false;
-                            check();
-                        };
-                    };
-                    check();
-                });
+        let finished = false;
+        let push = false;
+        let rowQueue = [];
 
-            this.run('FETCH', range, query, {
-                uid: !!options.uid,
-                binary: options.binary,
-                changedSince: options.changedSince,
-                onUntaggedFetch: (untagged, next) => {
-                    rowQueue.push({
-                        value: {
-                            response: untagged,
-                            next
+        let getNext = () =>
+            new Promise((resolve, reject) => {
+                let check = () => {
+                    if (rowQueue.length) {
+                        let entry = rowQueue.shift();
+                        if (entry.err) {
+                            return reject(entry.err);
+                        } else {
+                            return resolve(entry.value);
                         }
-                    });
-                    if (typeof push === 'function') {
-                        push();
                     }
-                }
-            })
-                .then(() => {
-                    finished = true;
-                    if (typeof push === 'function') {
-                        push();
+
+                    if (finished) {
+                        return resolve(null);
                     }
-                })
-                .catch(err => {
-                    rowQueue.push({ err });
-                });
 
-            let res;
-            while ((res = await getNext())) {
-                if (this.isClosed || this.socket.destroyed) {
-                    let error = new Error('Connection closed');
-                    error.code = 'EConnectionClosed';
-                    throw error;
-                }
+                    // wait until data is pushed to queue and try again
+                    push = () => {
+                        push = false;
+                        check();
+                    };
+                };
+                check();
+            });
 
-                if (res !== null) {
-                    yield res.response;
-                    res.next();
+        this.run('FETCH', range, query, {
+            uid: !!options.uid,
+            binary: options.binary,
+            changedSince: options.changedSince,
+            onUntaggedFetch: (untagged, next) => {
+                rowQueue.push({
+                    value: {
+                        response: untagged,
+                        next
+                    }
+                });
+                if (typeof push === 'function') {
+                    push();
                 }
             }
+        })
+            .then(() => {
+                finished = true;
+                if (typeof push === 'function') {
+                    push();
+                }
+            })
+            .catch(err => {
+                rowQueue.push({ err });
+                if (typeof push === 'function') {
+                    push();
+                }
+            });
 
-            if (!finished) {
-                // FETCH never finished!
-                let error = new Error('FETCH did not finish');
-                error.code = 'ENotFinished';
+        let res;
+        while ((res = await getNext())) {
+            if (this.isClosed || this.socket.destroyed) {
+                let error = new Error('Connection closed');
+                error.code = 'EConnectionClosed';
                 throw error;
             }
-        } catch (err) {
-            setImmediate(() => this.close());
-            throw err;
+
+            if (res !== null) {
+                yield res.response;
+                res.next();
+            }
+        }
+
+        if (!finished) {
+            // FETCH never finished!
+            let error = new Error('FETCH did not finish');
+            error.code = 'ENotFinished';
+            throw error;
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.153",
+    "version": "1.0.155",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -32,7 +32,7 @@
         "@babel/eslint-plugin": "7.23.5",
         "@babel/plugin-syntax-class-properties": "7.12.13",
         "@babel/preset-env": "7.24.0",
-        "@types/node": "20.11.22",
+        "@types/node": "20.11.24",
         "eslint": "8.57.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "9.1.0",

package/test/imap-parser-test.js

@@ -978,6 +978,14 @@ module.exports['IMAP Parser, NO with a dot'] = test =>
         test.deepEqual(parsed.attributes, [{ type: 'TEXT', value: 'Server Unavailable. 15' }]);
     });
 
+module.exports['IMAP Parser, no tag or response (Exchange)'] = test =>
+    asyncWrapper(test, async test => {
+        let parsed = await parser('Server Unavailable. 15');
+        console.log(parsed);
+        test.equal(parsed.command, 'BAD');
+        test.deepEqual(parsed.attributes, [{ type: 'TEXT', value: 'Server Unavailable. 15' }]);
+    });
+
 module.exports['IMAP Parser, BAD with throttling'] = test =>
     asyncWrapper(test, async test => {
         let parsed = await parser('X BAD Request is throttled. Suggested Backoff Time: 92415 milliseconds');