imapflow 1.0.96 → 1.0.99

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+-   1.0.99 - 2022-06-05
+
+    -   Check if folder exists on failed status command
+
+-   1.0.98 - 2022-05-30
+
+    -   Fixed an issue with envelope parsing where literal values were returned as Buffers
+
+-   1.0.97 - 2022-05-29
+
+    -   Allow single quotes in atoms
+
 -   1.0.96 - 2022-05-18
 
     -   Allow non-standard characters in ATOM if it's the string after NO/OK/BAD response

package/lib/commands/list.js

@@ -4,7 +4,9 @@ const { decodePath, encodePath, normalizePath } = require('../tools.js');
 const { specialUse } = require('../special-use');
 
 // Lists mailboxes from server
-module.exports = async (connection, reference, mailbox) => {
+module.exports = async (connection, reference, mailbox, options) => {
+    options = options || {};
+
     let listCommand = connection.capabilities.has('XLIST') && !connection.capabilities.has('SPECIAL-USE') ? 'XLIST' : 'LIST';
 
     let response;
@@ -64,6 +66,10 @@ module.exports = async (connection, reference, mailbox) => {
         let normalizedReference = normalizePath(connection, reference || '');
         await runList(normalizedReference, normalizePath(connection, mailbox || '', true));
 
+        if (options.listOnly) {
+            return entries;
+        }
+
         if (normalizedReference && !entries.find(entry => entry.specialUse === '\\Inbox')) {
             // INBOX was most probably not included in the listing if namespace was used
             await runList('', 'INBOX');

package/lib/commands/status.js

@@ -126,6 +126,16 @@ module.exports = async (connection, path, query) => {
         response.next();
         return map;
     } catch (err) {
+        if (err.responseStatus === 'NO') {
+            let folders = await connection.run('LIST', '', path, { listOnly: true });
+            if (folders && !folders.length) {
+                let error = new Error(`Mailbox doesn't exist: ${path}`);
+                error.code = 'NotFound';
+                error.response = err;
+                throw error;
+            }
+        }
+
         connection.log.warn({ err, cid: connection.id });
         return false;
     }

package/lib/handler/imap-formal-syntax.js

@@ -109,7 +109,7 @@ module.exports = {
     },
 
     'quoted-specials'() {
-        let value = this.DQUOTE() + "'\\";
+        let value = this.DQUOTE() + '\\';
         this['quoted-specials'] = function () {
             return value;
         };

package/lib/handler/parser-instance.js

@@ -60,16 +60,16 @@ class ParserInstance {
         let match, element, errPos;
 
         if (this.remainder.match(/^\s/)) {
-            throw new Error('Unexpected whitespace at position ' + this.pos);
+            throw new Error(`Unexpected whitespace at position ${this.pos} [E1]`);
         }
 
         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));
+                throw new Error(`Unexpected char at position ${this.pos + errPos} [E2: ${JSON.stringify(element.charAt(errPos))}]`);
             }
         } else {
-            throw new Error('Unexpected end of input at position ' + this.pos);
+            throw new Error(`Unexpected end of input at position ${this.pos} [E3]`);
         }
 
         this.pos += match[0].length;
@@ -80,11 +80,11 @@ class ParserInstance {
 
     async getSpace() {
         if (!this.remainder.length) {
-            throw new Error('Unexpected end of input at position ' + this.pos);
+            throw new Error(`Unexpected end of input at position ${this.pos} [E4]`);
         }
 
         if (imapFormalSyntax.verify(this.remainder.charAt(0), imapFormalSyntax.SP()) >= 0) {
-            throw new Error('Unexpected char at position ' + this.pos);
+            throw new Error(`Unexpected char at position ${this.pos} [E5: ${JSON.stringify(this.remainder.charAt(0))}]`);
         }
 
         this.pos++;
@@ -93,11 +93,11 @@ class ParserInstance {
 
     async getAttributes() {
         if (!this.remainder.length) {
-            throw new Error('Unexpected end of input at position ' + this.pos);
+            throw new Error(`Unexpected end of input at position ${this.pos} [E6]`);
         }
 
         if (this.remainder.match(/^\s/)) {
-            throw new Error('Unexpected whitespace at position ' + this.pos);
+            throw new Error(`Unexpected whitespace at position ${this.pos} [E7]`);
         }
 
         const tokenParser = new TokenParser(this, this.pos, this.remainder, this.options);

package/lib/handler/token-parser.js

@@ -36,7 +36,7 @@ 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));
+                throw new Error(`Unexpected end of input at position ${this.pos + this.str.length - 1} [E6]`);
             }
 
             let type = (node.type || '').toString().toUpperCase();
@@ -149,7 +149,7 @@ class TokenParser {
                         // ) closes a list
                         case ')':
                             if (this.currentNode.type !== 'LIST') {
-                                throw new Error('Unexpected list terminator ) at position ' + (this.pos + i));
+                                throw new Error(`Unexpected list terminator ) at position ${this.pos + i} [E7]`);
                             }
 
                             this.currentNode.isClosed = true;
@@ -162,7 +162,7 @@ class TokenParser {
                         // ] closes section group
                         case ']':
                             if (this.currentNode.type !== 'SECTION') {
-                                throw new Error('Unexpected section terminator ] at position ' + (this.pos + i));
+                                throw new Error(`Unexpected section terminator ] at position ${this.pos + i} [E8]`);
                             }
                             this.currentNode.isClosed = true;
                             this.currentNode.endPos = this.pos + i;
@@ -189,7 +189,7 @@ class TokenParser {
                         case '~': {
                             let nextChr = this.str.charAt(i + 1);
                             if (nextChr !== '{') {
-                                throw new Error('Unexpected literal8 marker at position ' + (this.pos + i));
+                                throw new Error(`Unexpected literal8 marker at position ${this.pos + i} [E9]`);
                             }
                             this.expectedLiteralType = 'literal8';
                             break;
@@ -270,7 +270,7 @@ class TokenParser {
                             // Allow \ as the first char for atom to support system flags
                             // Allow % to support LIST '' %
                             if (imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 && chr !== '\\' && chr !== '%') {
-                                throw new Error('Unexpected char at position ' + (this.pos + i));
+                                throw new Error(`Unexpected char at position ${this.pos + i} [E10: ${JSON.stringify(chr)}]`);
                             }
 
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
@@ -317,7 +317,7 @@ 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);
+                            throw new Error(`Unexpected section start char [ at position ${this.pos} [E11]`);
                         }
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.createNode(this.currentNode.parentNode, this.pos + i);
@@ -328,7 +328,7 @@ class TokenParser {
                     }
 
                     if (chr === '<') {
-                        throw new Error('Unexpected start of partial at position ' + this.pos);
+                        throw new Error(`Unexpected start of partial at position ${this.pos} [E12]`);
                     }
 
                     // if the char is not ATOM compatible, throw. Allow \* as an exception
@@ -338,9 +338,9 @@ 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));
+                        throw new Error(`Unexpected char at position ${this.pos + i} [E13: ${JSON.stringify(chr)}]`);
                     } else if (this.currentNode.value === '\\*') {
-                        throw new Error('Unexpected char at position ' + (this.pos + i));
+                        throw new Error(`Unexpected char at position ${this.pos + i} [E14: ${JSON.stringify(chr)}]`);
                     }
 
                     this.currentNode.value += chr;
@@ -362,7 +362,7 @@ class TokenParser {
                     if (chr === '\\') {
                         i++;
                         if (i >= len) {
-                            throw new Error('Unexpected end of input at position ' + (this.pos + i));
+                            throw new Error(`Unexpected end of input at position ${this.pos + i} [E15]`);
                         }
                         chr = this.str.charAt(i);
                     }
@@ -373,7 +373,7 @@ class TokenParser {
                 case 'PARTIAL':
                     if (chr === '>') {
                         if (this.currentNode.value.substr(-1) === '.') {
-                            throw new Error('Unexpected end of partial at position ' + this.pos);
+                            throw new Error(`Unexpected end of partial at position ${this.pos} [E16]`);
                         }
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode.isClosed = true;
@@ -384,15 +384,15 @@ class TokenParser {
                     }
 
                     if (chr === '.' && (!this.currentNode.value.length || this.currentNode.value.match(/\./))) {
-                        throw new Error('Unexpected partial separator . at position ' + this.pos);
+                        throw new Error(`Unexpected partial separator . at position ${this.pos} [E17]`);
                     }
 
                     if (imapFormalSyntax.DIGIT().indexOf(chr) < 0 && chr !== '.') {
-                        throw new Error('Unexpected char at position ' + (this.pos + i));
+                        throw new Error(`Unexpected char at position ${this.pos + i} [E18: ${JSON.stringify(chr)}]`);
                     }
 
                     if (this.currentNode.value.match(/^0$|\.0$/) && chr !== '.') {
-                        throw new Error('Invalid partial at position ' + (this.pos + i));
+                        throw new Error(`Invalid partial at position ${this.pos + i} [E19: ${JSON.stringify(chr)}]`);
                     }
 
                     this.currentNode.value += chr;
@@ -431,14 +431,14 @@ class TokenParser {
 
                     if (chr === '}') {
                         if (!('literalLength' in this.currentNode)) {
-                            throw new Error('Unexpected literal prefix end char } at position ' + (this.pos + i));
+                            throw new Error(`Unexpected literal prefix end char } at position ${this.pos + i} [E20]`);
                         }
                         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));
+                            throw new Error(`Unexpected char at position ${this.pos + i} [E21: ${JSON.stringify(chr)}]`);
                         }
 
                         this.currentNode.literalLength = Number(this.currentNode.literalLength);
@@ -479,10 +479,10 @@ class TokenParser {
                         break;
                     }
                     if (imapFormalSyntax.DIGIT().indexOf(chr) < 0) {
-                        throw new Error('Unexpected char at position ' + (this.pos + i));
+                        throw new Error(`Unexpected char at position ${this.pos + i} [E22: ${JSON.stringify(chr)}]`);
                     }
                     if (this.currentNode.literalLength === '0') {
-                        throw new Error('Invalid literal at position ' + (this.pos + i));
+                        throw new Error(`Invalid literal at position ${this.pos + i} [E23]`);
                     }
                     this.currentNode.literalLength = (this.currentNode.literalLength || '') + chr;
                     break;
@@ -491,11 +491,11 @@ 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));
+                            throw new Error(`Unexpected whitespace at position ${this.pos + i} [E24]`);
                         }
 
                         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));
+                            throw new Error(`Unexpected whitespace at position ${this.pos + i} [E25]`);
                         }
 
                         this.currentNode.isClosed = true;
@@ -518,25 +518,25 @@ 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));
+                            throw new Error(`Unexpected range separator : at position ${this.pos + i} [E26]`);
                         }
                     } else if (chr === '*') {
                         if ([',', ':'].indexOf(this.currentNode.value.substr(-1)) < 0) {
-                            throw new Error('Unexpected range wildcard at position ' + (this.pos + i));
+                            throw new Error(`Unexpected range wildcard at position ${this.pos + i} [E27]`);
                         }
                     } 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));
+                            throw new Error(`Unexpected sequence separator , at position ${this.pos + i} [E28]`);
                         }
                         if (this.currentNode.value.substr(-1) === '*' && this.currentNode.value.substr(-2, 1) !== ':') {
-                            throw new Error('Unexpected sequence separator , at position ' + (this.pos + i));
+                            throw new Error(`Unexpected sequence separator , at position ${this.pos + i} [E29]`);
                         }
                     } else if (!chr.match(/\d/)) {
-                        throw new Error('Unexpected char at position ' + (this.pos + i));
+                        throw new Error(`Unexpected char at position ${this.pos + i} [E30: ${JSON.stringify(chr)}]`);
                     }
 
                     if (chr.match(/\d/) && this.currentNode.value.substr(-1) === '*') {
-                        throw new Error('Unexpected number at position ' + (this.pos + i));
+                        throw new Error(`Unexpected number at position ${this.pos + i} [E31: ${JSON.stringify(chr)}]`);
                     }
 
                     this.currentNode.value += chr;

package/lib/imap-flow.js

@@ -2501,6 +2501,17 @@ class ImapFlow extends EventEmitter {
                 this.currentLockId = lockId;
                 return resolve({ path, release });
             } catch (err) {
+                if (err.responseStatus === 'NO') {
+                    try {
+                        let folders = await this.run('LIST', '', path, { listOnly: true });
+                        if (!folders || !folders.length) {
+                            err.mailboxMissing = true;
+                        }
+                    } catch (E) {
+                        this.log.trace({ msg: 'Failed to verify failed mailbox', path, err: E });
+                    }
+                }
+
                 this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId });
                 reject(err);
                 await this.processLocks(true);
@@ -2531,6 +2542,7 @@ class ImapFlow extends EventEmitter {
      */
     async getMailboxLock(path, options) {
         options = options || {};
+
         path = normalizePath(this, path);
 
         let lockId = ++this.lockCounter;

package/lib/tools.js

@@ -350,25 +350,38 @@ module.exports = {
     },
 
     parseEnvelope(entry) {
+        let getStrValue = obj => {
+            if (!obj) {
+                return false;
+            }
+            if (typeof obj.value === 'string') {
+                return obj.value;
+            }
+            if (Buffer.isBuffer(obj.value)) {
+                return obj.value.toString();
+            }
+            return obj.value;
+        };
+
         let processAddresses = function (list) {
                 return [].concat(list || []).map(addr => ({
-                    name: libmime.decodeWords((addr[0] && addr[0].value) || ''),
-                    address: ((addr[2] && addr[2].value) || '') + '@' + ((addr[3] && addr[3].value) || '')
+                    name: libmime.decodeWords(getStrValue(addr[0]) || ''),
+                    address: (getStrValue(addr[2]) || '') + '@' + (getStrValue(addr[3]) || '')
                 }));
             },
             envelope = {};
 
         if (entry[0] && entry[0].value) {
-            let date = new Date(entry[0].value);
+            let date = new Date(getStrValue(entry[0]));
             if (date.toString() === 'Invalid Date') {
-                envelope.date = entry[0].value;
+                envelope.date = getStrValue(entry[0]);
             } else {
                 envelope.date = date;
             }
         }
 
         if (entry[1] && entry[1].value) {
-            envelope.subject = libmime.decodeWords(entry[1] && entry[1].value);
+            envelope.subject = libmime.decodeWords(getStrValue(entry[1]));
         }
 
         if (entry[2] && entry[2].length) {
@@ -396,11 +409,11 @@ module.exports = {
         }
 
         if (entry[8] && entry[8].value) {
-            envelope.inReplyTo = entry[8].value;
+            envelope.inReplyTo = (getStrValue(entry[8]) || '').toString().trim();
         }
 
         if (entry[9] && entry[9].value) {
-            envelope.messageId = entry[9].value;
+            envelope.messageId = (getStrValue(entry[9]) || '').toString().trim();
         }
 
         return envelope;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.96",
+    "version": "1.0.99",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -27,13 +27,13 @@
     },
     "homepage": "https://imapflow.com/",
     "devDependencies": {
-        "@babel/eslint-parser": "7.17.0",
+        "@babel/eslint-parser": "7.18.2",
         "@babel/eslint-plugin": "7.17.7",
         "@babel/plugin-syntax-class-properties": "7.12.13",
-        "@babel/preset-env": "7.17.12",
-        "@types/node": "17.0.34",
+        "@babel/preset-env": "7.18.2",
+        "@types/node": "17.0.40",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.15.0",
+        "eslint": "8.17.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "8.5.0",
         "grunt": "1.5.3",
@@ -52,7 +52,7 @@
         "libqp": "1.1.0",
         "mailsplit": "5.3.2",
         "nodemailer": "6.7.5",
-        "pino": "7.11.0",
+        "pino": "8.0.0",
         "socks": "2.6.2"
     }
 }

package/test/imap-parser-test.js

@@ -921,3 +921,15 @@ module.exports['IMAP Parser, unicode select'] = test =>
             { type: 'ATOM', value: '[THROTTLED]' }
         ])
     );
+
+module.exports['IMAP Parser, single quote in atom'] = test =>
+    asyncWrapper(test, async test =>
+        test.deepEqual((await parser('* LIST (HasNoChildren UnMarked) "/" \'a')).attributes, [
+            [
+                { type: 'ATOM', value: 'HasNoChildren' },
+                { type: 'ATOM', value: 'UnMarked' }
+            ],
+            { type: 'STRING', value: '/' },
+            { type: 'ATOM', value: "'a" }
+        ])
+    );