imapflow 1.0.95 → 1.0.98

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+-   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
+
 -   1.0.95 - 2022-05-03
 
     -   Do not use FETCH BINARY, unless `binary` option is `true`

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,14 +328,19 @@ 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
-                    if (imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 && chr !== ']' && !(chr === '*' && this.currentNode.value === '\\')) {
-                        throw new Error('Unexpected char at position ' + (this.pos + i));
+                    if (
+                        imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 &&
+                        chr !== ']' &&
+                        !(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)}]`);
                     } 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;
@@ -357,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);
                     }
@@ -368,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;
@@ -379,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;
@@ -426,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);
@@ -474,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;
@@ -486,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;
@@ -513,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

@@ -623,7 +623,7 @@ class ImapFlow extends EventEmitter {
 
         // Make sure we have namespace set. This should also throw if Exchange actually failed authentication
         let nsResponse = await this.run('NAMESPACE');
-        if (nsResponse.error && nsResponse.status === 'BAD' && /User is authenticated but not connected/i.test(nsResponse.text)) {
+        if (nsResponse && nsResponse.error && nsResponse.status === 'BAD' && /User is authenticated but not connected/i.test(nsResponse.text)) {
             // Not a NAMESPACE failure but authentication failure, so report as
             this.authenticated = false;
             let err = new Error('Authentication failed');

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.95",
+    "version": "1.0.98",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -27,16 +27,16 @@
     },
     "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.10",
-        "@types/node": "17.0.31",
+        "@babel/preset-env": "7.18.2",
+        "@types/node": "17.0.36",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.14.0",
+        "eslint": "8.16.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "8.5.0",
-        "grunt": "1.5.2",
+        "grunt": "1.5.3",
         "grunt-cli": "1.4.3",
         "grunt-contrib-nodeunit": "4.0.0",
         "grunt-eslint": "24.0.0",
@@ -51,7 +51,7 @@
         "libmime": "5.1.0",
         "libqp": "1.1.0",
         "mailsplit": "5.3.2",
-        "nodemailer": "6.7.4",
+        "nodemailer": "6.7.5",
         "pino": "7.11.0",
         "socks": "2.6.2"
     }

package/test/imap-parser-test.js

@@ -905,3 +905,31 @@ module.exports['IMAP Parser: escaped quotes'] = test =>
     );
 
 module.exports['IMAP Parser: mimetorture'] = test => asyncWrapper(test, async test => test.deepEqual(await parser(mimetorture.input), mimetorture.output));
+
+module.exports['IMAP Parser, unicode select'] = test =>
+    asyncWrapper(test, async test =>
+        test.deepEqual((await parser('F OK [READ-WRITE] [Gmail]/Visi laiškai selected. (Success) [THROTTLED]')).attributes, [
+            {
+                type: 'ATOM',
+                value: '',
+                section: [{ type: 'ATOM', value: 'READ-WRITE' }]
+            },
+            { type: 'ATOM', value: '[Gmail]/Visi' },
+            { type: 'ATOM', value: 'laiškai' },
+            { type: 'ATOM', value: 'selected.' },
+            [{ type: 'ATOM', value: 'Success' }],
+            { 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" }
+        ])
+    );