imapflow 1.0.155 → 1.0.157

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.0.157](https://github.com/postalsys/imapflow/compare/v1.0.156...v1.0.157) (2024-03-19)
+
+
+### Bug Fixes
+
+* **logs:** Log mailbox lock description ([ce87cf5](https://github.com/postalsys/imapflow/commit/ce87cf5a256ddc324624893a1c17992475fafeb3))
+
+## [1.0.156](https://github.com/postalsys/imapflow/compare/v1.0.155...v1.0.156) (2024-03-07)
+
+
+### Bug Fixes
+
+* micro-optimizations for parser ([3451ad2](https://github.com/postalsys/imapflow/commit/3451ad235532ca1a64a829f9f2f8e77bcef3a17d))
+
 ## [1.0.155](https://github.com/postalsys/imapflow/compare/v1.0.154...v1.0.155) (2024-03-06)
 
 

package/lib/handler/token-parser.js

@@ -4,6 +4,17 @@
 
 const imapFormalSyntax = require('./imap-formal-syntax');
 
+const STATE_ATOM = 0x001;
+const STATE_LITERAL = 0x002;
+const STATE_NORMAL = 0x003;
+const STATE_PARTIAL = 0x004;
+const STATE_SEQUENCE = 0x005;
+const STATE_STRING = 0x006;
+const STATE_TEXT = 0x007;
+
+const RE_DIGITS = /^\d+$/;
+const RE_SINGLE_DIGIT = /^\d$/;
+
 class TokenParser {
     constructor(parent, startPos, str, options) {
         this.str = (str || '').toString();
@@ -15,7 +26,7 @@ class TokenParser {
 
         this.currentNode.type = 'TREE';
 
-        this.state = 'NORMAL';
+        this.state = STATE_NORMAL;
     }
 
     async getAttributes() {
@@ -132,13 +143,13 @@ class TokenParser {
             chr = this.str.charAt(i);
 
             switch (this.state) {
-                case 'NORMAL':
+                case STATE_NORMAL:
                     switch (chr) {
                         // DQUOTE starts a new string
                         case '"':
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
                             this.currentNode.type = 'string';
-                            this.state = 'STRING';
+                            this.state = STATE_STRING;
                             this.currentNode.isClosed = false;
                             break;
 
@@ -186,11 +197,11 @@ class TokenParser {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'ATOM';
                                 this.currentNode.value = chr;
-                                this.state = 'ATOM';
+                                this.state = STATE_ATOM;
                             } else {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'PARTIAL';
-                                this.state = 'PARTIAL';
+                                this.state = STATE_PARTIAL;
                                 this.currentNode.isClosed = false;
                             }
                             break;
@@ -204,7 +215,7 @@ class TokenParser {
                                     this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                     this.currentNode.type = 'ATOM';
                                     this.currentNode.value = chr;
-                                    this.state = 'ATOM';
+                                    this.state = STATE_ATOM;
                                     break;
                                 }
 
@@ -223,7 +234,7 @@ class TokenParser {
                             this.currentNode.type = 'LITERAL';
                             this.currentNode.literalType = this.expectedLiteralType || 'literal';
                             this.expectedLiteralType = false;
-                            this.state = 'LITERAL';
+                            this.state = STATE_LITERAL;
                             this.currentNode.isClosed = false;
                             break;
 
@@ -233,7 +244,7 @@ class TokenParser {
                             this.currentNode.type = 'SEQUENCE';
                             this.currentNode.value = chr;
                             this.currentNode.isClosed = false;
-                            this.state = 'SEQUENCE';
+                            this.state = STATE_SEQUENCE;
                             break;
 
                         // normally a space should never occur
@@ -253,7 +264,7 @@ class TokenParser {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'SECTION';
                                 this.currentNode.isClosed = false;
-                                this.state = 'NORMAL';
+                                this.state = STATE_NORMAL;
 
                                 // RFC2221 defines a response code REFERRAL whose payload is an
                                 // RFC2192/RFC5092 imapurl that we will try to parse as an ATOM but
@@ -303,17 +314,17 @@ class TokenParser {
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
                             this.currentNode.type = 'ATOM';
                             this.currentNode.value = chr;
-                            this.state = 'ATOM';
+                            this.state = STATE_ATOM;
                             break;
                     }
                     break;
 
-                case 'ATOM':
+                case STATE_ATOM:
                     // space finishes an atom
                     if (chr === ' ') {
                         this.currentNode.endPos = this.pos + i - 1;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         break;
                     }
 
@@ -328,16 +339,16 @@ class TokenParser {
                         this.currentNode.isClosed = true;
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         checkSP();
 
                         break;
                     }
 
-                    if ((chr === ',' || chr === ':') && this.currentNode.value.match(/^\d+$/)) {
+                    if ((chr === ',' || chr === ':') && RE_DIGITS.test(this.currentNode.value)) {
                         this.currentNode.type = 'SEQUENCE';
                         this.currentNode.isClosed = true;
-                        this.state = 'SEQUENCE';
+                        this.state = STATE_SEQUENCE;
                     }
 
                     // [ starts a section group for this element
@@ -353,7 +364,7 @@ class TokenParser {
                         this.currentNode = this.createNode(this.currentNode.parentNode, this.pos + i);
                         this.currentNode.type = 'SECTION';
                         this.currentNode.isClosed = false;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         break;
                     }
 
@@ -386,13 +397,13 @@ class TokenParser {
                     this.currentNode.value += chr;
                     break;
 
-                case 'STRING':
+                case STATE_STRING:
                     // DQUOTE ends the string sequence
                     if (chr === '"') {
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode.isClosed = true;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
 
                         checkSP();
                         break;
@@ -413,9 +424,9 @@ class TokenParser {
                     this.currentNode.value += chr;
                     break;
 
-                case 'PARTIAL':
+                case STATE_PARTIAL:
                     if (chr === '>') {
-                        if (this.currentNode.value.substr(-1) === '.') {
+                        if (this.currentNode.value.at(-1) === '.') {
                             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 };
@@ -424,7 +435,7 @@ class TokenParser {
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode.isClosed = true;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         checkSP();
                         break;
                     }
@@ -453,7 +464,7 @@ class TokenParser {
                     this.currentNode.value += chr;
                     break;
 
-                case 'LITERAL':
+                case STATE_LITERAL:
                     if (this.currentNode.started) {
                         // only relevant if literals are not already parsed out from input
 
@@ -473,7 +484,7 @@ class TokenParser {
                             this.currentNode.value = this.currentNode.chBuffer.toString('binary');
                             this.currentNode.chBuffer = Buffer.alloc(0);
                             this.currentNode = this.currentNode.parentNode;
-                            this.state = 'NORMAL';
+                            this.state = STATE_NORMAL;
                             checkSP();
                         }
                         break;
@@ -510,7 +521,7 @@ class TokenParser {
                             this.currentNode.endPos = this.pos + i;
                             this.currentNode.isClosed = true;
                             this.currentNode = this.currentNode.parentNode;
-                            this.state = 'NORMAL';
+                            this.state = STATE_NORMAL;
                             checkSP();
                         } else if (this.options.literals) {
                             // use the next precached literal values
@@ -528,7 +539,7 @@ class TokenParser {
                             this.currentNode.started = false;
                             this.currentNode.isClosed = true;
                             this.currentNode = this.currentNode.parentNode;
-                            this.state = 'NORMAL';
+                            this.state = STATE_NORMAL;
                             checkSP();
                         } else {
                             this.currentNode.started = true;
@@ -554,17 +565,17 @@ class TokenParser {
                     this.currentNode.literalLength = (this.currentNode.literalLength || '') + chr;
                     break;
 
-                case 'SEQUENCE':
+                case STATE_SEQUENCE:
                     // space finishes the sequence set
                     if (chr === ' ') {
-                        if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
+                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
                             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) !== ':') {
+                        if (this.currentNode.value !== '*' && this.currentNode.value.at(-1) === '*' && this.currentNode.value.at(-2) !== ':') {
                             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 };
@@ -574,7 +585,7 @@ class TokenParser {
                         this.currentNode.isClosed = true;
                         this.currentNode.endPos = this.pos + i - 1;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
                         break;
                     } else if (this.currentNode.parentNode && chr === ']' && this.currentNode.parentNode.type === 'SECTION') {
                         this.currentNode.endPos = this.pos + i - 1;
@@ -583,47 +594,47 @@ class TokenParser {
                         this.currentNode.isClosed = true;
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.currentNode.parentNode;
-                        this.state = 'NORMAL';
+                        this.state = STATE_NORMAL;
 
                         checkSP();
                         break;
                     }
 
                     if (chr === ':') {
-                        if (!this.currentNode.value.substr(-1).match(/\d/) && this.currentNode.value.substr(-1) !== '*') {
+                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
                             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) {
+                        if ([',', ':'].indexOf(this.currentNode.value.at(-1)) < 0) {
                             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) !== '*') {
+                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
                             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) !== ':') {
+                        if (this.currentNode.value.at(-1) === '*' && this.currentNode.value.at(-2) !== ':') {
                             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/)) {
+                    } else if (!RE_SINGLE_DIGIT.test(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) === '*') {
+                    if (RE_SINGLE_DIGIT.test(chr) && this.currentNode.value.at(-1) === '*') {
                         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 };
@@ -633,7 +644,7 @@ class TokenParser {
                     this.currentNode.value += chr;
                     break;
 
-                case 'TEXT':
+                case STATE_TEXT:
                     this.currentNode.value += chr;
                     break;
             }

package/lib/imap-flow.js

@@ -1313,7 +1313,7 @@ class ImapFlow extends EventEmitter {
 
         await new Promise((resolve, reject) => {
             this.connectTimeout = setTimeout(() => {
-                let err = new Error('Failed to established connection in required time');
+                let err = new Error('Failed to establish connection in required time');
                 err.code = 'CONNECT_TIMEOUT';
                 err.details = {
                     connectionTimeout: this.options.connectionTimeout || CONNECT_TIMEOUT
@@ -2840,17 +2840,35 @@ class ImapFlow extends EventEmitter {
 
     async processLocks(force) {
         if (!force && this.processingLock) {
+            this.log.trace({
+                msg: 'Mailbox locking queued',
+                path: this.mailbox && this.mailbox.path,
+                pending: this.locks.length,
+                idling: this.idling
+            });
             return;
         }
+
         if (!this.locks.length) {
             this.processingLock = false;
+            this.log.trace({
+                msg: 'Mailbox locking queue processed',
+                idling: this.idling
+            });
             return;
         }
+
         this.processingLock = true;
 
         const release = () => {
             if (this.currentLockId) {
-                this.log.trace({ msg: 'Mailbox lock released', lockId: this.currentLockId, path: this.mailbox && this.mailbox.path });
+                this.log.trace({
+                    msg: 'Mailbox lock released',
+                    lockId: this.currentLockId,
+                    path: this.mailbox && this.mailbox.path,
+                    pending: this.locks.length,
+                    idling: this.idling
+                });
                 this.currentLockId = 0;
             }
             this.processLocks(true).catch(err => this.log.error({ err, cid: this.id }));
@@ -2859,7 +2877,7 @@ class ImapFlow extends EventEmitter {
         const { resolve, reject, path, options, lockId } = this.locks.shift();
 
         if (!this.usable || this.socket.destroyed) {
-            this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId });
+            this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId, idling: this.idling });
             // reject all
             let error = new Error('Connection not available');
             error.code = 'NoConnection';
@@ -2869,14 +2887,14 @@ class ImapFlow extends EventEmitter {
 
         if (this.mailbox && this.mailbox.path === path && !!this.mailbox.readOnly === !!options.readOnly) {
             // nothing to do here, already selected
-            this.log.trace({ msg: 'Mailbox lock acquired', path, lockId });
+            this.log.trace({ msg: 'Mailbox lock acquired', path, lockId, idling: this.idling });
             this.currentLockId = lockId;
             return resolve({ path, release });
         } else {
             try {
                 // Try to open. Throws if mailbox does not exists or can't open
                 await this.mailboxOpen(path, options);
-                this.log.trace({ msg: 'Lock acquired', path, lockId });
+                this.log.trace({ msg: 'Lock acquired', path, lockId, idling: this.idling, ...(options.description && { description: options.description }) });
                 this.currentLockId = lockId;
                 return resolve({ path, release });
             } catch (err) {
@@ -2891,7 +2909,7 @@ class ImapFlow extends EventEmitter {
                     }
                 }
 
-                this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId });
+                this.log.trace({ msg: 'Failed to acquire mailbox lock', path, lockId, idling: this.idling });
                 reject(err);
                 await this.processLocks(true);
             }
@@ -2925,7 +2943,7 @@ class ImapFlow extends EventEmitter {
         path = normalizePath(this, path);
 
         let lockId = ++this.lockCounter;
-        this.log.trace({ msg: 'Requesting lock', path, lockId });
+        this.log.trace({ msg: 'Requesting lock', path, lockId, ...(options.description && { description: options.description }) });
 
         return await new Promise((resolve, reject) => {
             this.locks.push({ resolve, reject, path, options, lockId });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.155",
+    "version": "1.0.157",
     "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.24",
+        "@types/node": "20.11.29",
         "eslint": "8.57.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "9.1.0",
@@ -52,7 +52,7 @@
         "libmime": "5.3.4",
         "libqp": "2.1.0",
         "mailsplit": "5.4.0",
-        "nodemailer": "6.9.11",
+        "nodemailer": "6.9.12",
         "pino": "8.19.0",
         "socks": "2.8.1"
     }