imapflow 1.0.72 → 1.0.76

package/.eslintrc

@@ -10,7 +10,8 @@
     "extends": ["nodemailer", "prettier"],
     "parser": "@babel/eslint-parser",
     "parserOptions": {
-        "ecmaVersion": 2018
+        "ecmaVersion": 2018,
+        "sourceType": "script"
     },
     "plugins": ["@babel"]
 }

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+-   1.0.75 - 2021-10-15
+
+    -   Fixed an exception with failing IDLE (ramiroaisen #60)
+    -   Do not use 1 and 1.MIME for single node messages, fallback to TEXT and HEADERS
+
 -   1.0.71 - 2021-09-28
 
     -   IDLE precheck changes

package/lib/commands/append.js

@@ -86,7 +86,8 @@ module.exports = async (connection, destination, content, flags, idate) => {
                         EXISTS: async untagged => {
                             map.seq = Number(untagged.command);
                         }
-                    }
+                    },
+                    comment: 'Sequence not found from APPEND output'
                 });
                 response.next();
             } catch (err) {

package/lib/commands/idle.js

@@ -13,61 +13,99 @@ module.exports = async connection => {
         let response;
 
         let preCheckWaitQueue = [];
-
         try {
             connection.idling = true;
 
-            let preCheckProcessing = false;
+            //let idleSent = false;
+            let doneRequested = false;
+            let doneSent = false;
+            let canEnd = false;
+
+            let preCheck = () => {
+                doneRequested = true;
+                if (canEnd && !doneSent) {
+                    connection.log.debug({
+                        src: 'c',
+                        msg: `DONE`,
+                        comment: `breaking IDLE`,
+                        lockId: connection.currentLockId,
+                        path: connection.mailbox && connection.mailbox.path
+                    });
+                    connection.write('DONE');
+                    doneSent = true;
+
+                    connection.idling = false;
+                    connection.preCheck = false; // unset itself
+
+                    while (preCheckWaitQueue.length) {
+                        let { resolve } = preCheckWaitQueue.shift();
+                        resolve();
+                    }
+                }
+            };
+
             connection.preCheck = () => {
-                let processor = new Promise((resolve, reject) => {
+                let handler = new Promise((resolve, reject) => {
                     preCheckWaitQueue.push({ resolve, reject });
                 });
 
-                if (!preCheckProcessing) {
-                    preCheckProcessing = true;
-                    // small delay to make sure we do not call preCheck before command is actually executed
-                    setImmediate(() => {
-                        if (connection.idling) {
-                            connection.log.debug({ src: 'c', msg: `DONE`, comment: `breaking IDLE` });
-                            connection.write('DONE');
-                            connection.idling = false;
-                        }
-                        connection.preCheck = false; // unset itself
-                        while (preCheckWaitQueue.length) {
-                            console.log('RESOLVING IDLE');
-                            let entry = preCheckWaitQueue.shift();
-                            entry.resolve();
-                        }
-                    });
-                }
+                connection.log.trace({
+                    msg: 'Requesting IDLE break',
+                    lockId: connection.currentLockId,
+                    path: connection.mailbox && connection.mailbox.path,
+                    queued: preCheckWaitQueue.length,
+                    doneRequested,
+                    canEnd,
+                    doneSent
+                });
+
+                preCheck();
 
-                return processor;
+                return handler;
             };
 
             response = await connection.exec('IDLE', false, {
                 onPlusTag: async () => {
                     connection.log.debug({ msg: `Initiated IDLE, waiting for server input` });
+                    canEnd = true;
+                    if (doneRequested) {
+                        preCheck();
+                    }
+                },
+                onSend: () => {
+                    //idleSent = true;
                 }
             });
 
             // unset before response.next()
-            connection.preCheck = false;
-            while (preCheckWaitQueue.length) {
-                let entry = preCheckWaitQueue.shift();
-                let err = new Error('Already processed');
-                entry.reject(err);
+            if (typeof connection.preCheck === 'function') {
+                connection.log.trace({
+                    msg: 'Clearing pre-check function',
+                    lockId: connection.currentLockId,
+                    path: connection.mailbox && connection.mailbox.path,
+                    queued: preCheckWaitQueue.length,
+                    doneRequested,
+                    canEnd,
+                    doneSent
+                });
+                connection.preCheck = false;
+                while (preCheckWaitQueue.length) {
+                    let { resolve } = preCheckWaitQueue.shift();
+                    resolve();
+                }
             }
 
             response.next();
             return;
         } catch (err) {
             connection.preCheck = false;
-            while (preCheckWaitQueue.length) {
-                let entry = preCheckWaitQueue.shift();
-                entry.reject(err);
-            }
+            connection.idling = false;
 
             connection.log.warn({ err, cid: connection.id });
+            while (preCheckWaitQueue.length) {
+                let { reject } = preCheckWaitQueue.shift();
+                reject(err);
+            }
             return false;
         }
     }
@@ -85,7 +123,7 @@ module.exports = async connection => {
         };
 
         let idleCheck = async () => {
-            let response = await connection.exec('NOOP');
+            let response = await connection.exec('NOOP', false, { comment: 'IDLE not supported' });
             response.next();
         };
 

package/lib/commands/noop.js

@@ -3,7 +3,7 @@
 // Sends a NO-OP command
 module.exports = async connection => {
     try {
-        let response = await connection.exec('NOOP');
+        let response = await connection.exec('NOOP', false, { comment: 'Requested by command' });
         response.next();
         return true;
     } catch (err) {

package/lib/imap-flow.js

@@ -331,8 +331,14 @@ class ImapFlow extends EventEmitter {
             isLogging: true
         });
 
-        this.log.debug({ src: 's', msg: logCompiled.toString(), cid: this.id });
+        let options = data.options || {};
+
+        this.log.debug({ src: 's', msg: logCompiled.toString(), cid: this.id, comment: options.comment });
         this.write(Buffer.from(this.commandParts.shift()));
+
+        if (typeof options.onSend === 'function') {
+            options.onSend();
+        }
     }
 
     async trySend() {
@@ -344,7 +350,8 @@ class ImapFlow extends EventEmitter {
         await this.send({
             tag: this.currentRequest.tag,
             command: this.currentRequest.command,
-            attributes: this.currentRequest.attributes
+            attributes: this.currentRequest.attributes,
+            options: this.currentRequest.options
         });
     }
 
@@ -1024,7 +1031,7 @@ class ImapFlow extends EventEmitter {
      * await client.connect();
      */
     async connect() {
-        let connector = this.options.secure ? tls : net;
+        let connector = this.secureConnection ? tls : net;
 
         let opts = Object.assign(
             {
@@ -2018,7 +2025,13 @@ class ImapFlow extends EventEmitter {
             return {};
         }
 
-        options = options || {};
+        options = Object.assign(
+            {
+                chunkSize: 64 * 1024,
+                maxBytes: Infinity
+            },
+            options || {}
+        );
 
         let hasMore = true;
         let processed = 0;
@@ -2028,6 +2041,28 @@ class ImapFlow extends EventEmitter {
 
         let uid = false;
 
+        if (part === '1') {
+            // First part has special conditions for single node emails as
+            // the mime parts for root node are not 1 and 1.MIME but TEXT and HEADERS
+            let response = await this.fetchOne(range, { uid: true, bodyStructure: true }, options);
+
+            if (!response) {
+                return { response: false, chunk: false };
+            }
+
+            if (!uid && response.uid) {
+                uid = response.uid;
+                // force UID from now on even if first range was a sequence number
+                range = uid;
+                options.uid = true;
+            }
+
+            if (!response.bodyStructure.childNodes) {
+                // single text message
+                part = 'TEXT';
+            }
+        }
+
         let getNextPart = async query => {
             query = query || {};
 
@@ -2045,10 +2080,15 @@ class ImapFlow extends EventEmitter {
                     query.bodyParts = [];
                 }
 
-                if (query.size && /^[\d.]+$/.test(part)) {
-                    // fetch meta as well
-                    mimeKey = part + '.mime';
-                    query.bodyParts.push(mimeKey);
+                if (query.size) {
+                    if (/^[\d.]+$/.test(part)) {
+                        // fetch meta as well
+                        mimeKey = part + '.mime';
+                        query.bodyParts.push(mimeKey);
+                    } else if (part === 'text') {
+                        mimeKey = 'header';
+                        query.bodyParts.push(mimeKey);
+                    }
                 }
 
                 query.bodyParts.push({
@@ -2085,15 +2125,10 @@ class ImapFlow extends EventEmitter {
             }
 
             if (query.bodyParts) {
-                result.mime = response.bodyParts.get(mimeKey);
-
-                if (part === '1' && !result.mime) {
-                    // Outlook does not support requesting 1.MIME for text/* messages, so we issue an additional command
-                    let mimeResponse = await this.fetchOne(range, { bodyParts: ['header'] }, options);
-                    if (!mimeResponse) {
-                        return { response: false, chunk: false };
-                    }
-                    result.mime = mimeResponse.headers;
+                if (mimeKey === 'header') {
+                    result.mime = response.headers;
+                } else {
+                    result.mime = response.bodyParts.get(mimeKey);
                 }
             }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.72",
+    "version": "1.0.76",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -26,19 +26,19 @@
     },
     "homepage": "https://imapflow.com/",
     "devDependencies": {
-        "@babel/eslint-parser": "^7.15.7",
-        "@babel/eslint-plugin": "^7.14.5",
-        "@babel/plugin-syntax-class-properties": "^7.12.13",
-        "@babel/preset-env": "^7.15.6",
-        "@types/node": "16.10.1",
+        "@babel/eslint-parser": "7.15.8",
+        "@babel/eslint-plugin": "7.14.5",
+        "@babel/plugin-syntax-class-properties": "7.12.13",
+        "@babel/preset-env": "7.15.8",
+        "@types/node": "16.11.1",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "7.32.0",
+        "eslint": "8.0.1",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "8.3.0",
         "grunt": "1.4.1",
         "grunt-cli": "1.4.3",
-        "grunt-contrib-nodeunit": "3.0.0",
-        "grunt-eslint": "23.0.0",
+        "grunt-contrib-nodeunit": "4.0.0",
+        "grunt-eslint": "24.0.0",
         "jsdoc": "3.6.7",
         "tsd-jsdoc": "2.5.0"
     },
@@ -48,7 +48,7 @@
         "libbase64": "1.2.1",
         "libmime": "5.0.0",
         "libqp": "1.1.0",
-        "mailsplit": "5.2.0",
-        "pino": "6.13.3"
+        "mailsplit": "5.3.1",
+        "pino": "7.0.2"
     }
 }