imapflow 1.2.0 → 1.2.2

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "1.2.0"
+    ".": "1.2.2"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.2.2](https://github.com/postalsys/imapflow/compare/v1.2.1...v1.2.2) (2025-12-22)
+
+
+### Bug Fixes
+
+* Reject pending mailbox locks on connection close ([d20f060](https://github.com/postalsys/imapflow/commit/d20f060faafe5bf4740bdb067008d1d8e7b31592))
+
+## [1.2.1](https://github.com/postalsys/imapflow/compare/v1.2.0...v1.2.1) (2025-12-17)
+
+
+### Bug Fixes
+
+* Defer promise rejections on connection close to prevent unhandled rejections ([e53d9a8](https://github.com/postalsys/imapflow/commit/e53d9a8e0028197a5ff3c7cda342e0c11b64f228))
+
 ## [1.2.0](https://github.com/postalsys/imapflow/compare/v1.1.1...v1.2.0) (2025-12-11)
 
 

package/lib/imap-flow.js

@@ -1252,7 +1252,17 @@ class ImapFlow extends EventEmitter {
             });
     }
 
-    async serverBye() {
+    async serverBye(parsed) {
+        // Extract BYE reason from response for better error messages
+        let reason =
+            parsed &&
+            parsed.attributes &&
+            parsed.attributes
+                .filter(val => val.type === 'TEXT')
+                .map(val => val.value.trim())
+                .join(' ');
+
+        this.byeReason = reason || 'Server closed connection';
         this.untaggedHandlers.BYE = null;
         this.state = this.states.LOGOUT;
     }
@@ -1695,14 +1705,15 @@ class ImapFlow extends EventEmitter {
                 this.preCheck().catch(err => this.log.warn({ err, cid: this.id }));
             }
 
+            // Collect all pending requests to reject
+            let pendingRequests = [];
+
             // reject command that is currently processed
             if (this.currentRequest && this.requestTagMap.has(this.currentRequest.tag)) {
                 let request = this.requestTagMap.get(this.currentRequest.tag);
                 if (request) {
                     this.requestTagMap.delete(request.tag);
-                    const error = new Error('Connection not available');
-                    error.code = 'NoConnection';
-                    request.reject(error);
+                    pendingRequests.push(request);
                 }
                 this.currentRequest = false;
             }
@@ -1714,13 +1725,48 @@ class ImapFlow extends EventEmitter {
                     let request = this.requestTagMap.get(req.tag);
                     if (request) {
                         this.requestTagMap.delete(request.tag);
-                        const error = new Error('Connection not available');
-                        error.code = 'NoConnection';
-                        request.reject(error);
+                        pendingRequests.push(request);
                     }
                 }
             }
 
+            // Helper to create connection error
+            const createNoConnectionError = byeReason => {
+                const error = new Error('Connection not available');
+                error.code = 'NoConnection';
+                if (byeReason) {
+                    error.reason = byeReason;
+                }
+                return error;
+            };
+
+            // Reject pending requests via setImmediate to ensure caller's promise chain
+            // is fully set up before rejection (prevents unhandled promise rejections)
+            if (pendingRequests.length) {
+                let byeReason = this.byeReason;
+                setImmediate(() => {
+                    for (let request of pendingRequests) {
+                        request.reject(createNoConnectionError(byeReason));
+                    }
+                });
+            }
+
+            // Clear current lock - holder will see errors when they try operations
+            this.currentLock = false;
+
+            // Reject pending mailbox locks via setImmediate for consistency
+            if (this.locks && this.locks.length) {
+                let byeReason = this.byeReason;
+                let pendingLocks = this.locks.splice(0); // Take all locks and clear the array
+                setImmediate(() => {
+                    for (let lock of pendingLocks) {
+                        if (typeof lock.reject === 'function') {
+                            lock.reject(createNoConnectionError(byeReason));
+                        }
+                    }
+                });
+            }
+
             // cleanup compression streams if they exist
             if (this._inflate) {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.2.0",
+    "version": "1.2.2",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",

package/test/connection-edge-cases-test.js

@@ -700,3 +700,249 @@ module.exports['Connection Edge: Event handlers attached before piping'] = test
 
     test.done();
 };
+
+module.exports['Connection Edge: Pending locks rejected on close'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // Initialize locks array with pending locks
+    let rejectedErrors = [];
+    client.locks = [
+        {
+            path: 'INBOX',
+            lockId: 'lock1',
+            resolve: () => {},
+            reject: err => rejectedErrors.push(err)
+        },
+        {
+            path: 'Sent',
+            lockId: 'lock2',
+            resolve: () => {},
+            reject: err => rejectedErrors.push(err)
+        }
+    ];
+
+    // Mock socket to allow close() to run
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    // Call close
+    client.close();
+
+    // Rejections happen via setImmediate, so check after next tick
+    setImmediate(() => {
+        test.equal(rejectedErrors.length, 2, 'All pending locks should be rejected');
+        test.equal(rejectedErrors[0].code, 'NoConnection', 'Error should have NoConnection code');
+        test.equal(rejectedErrors[1].code, 'NoConnection', 'Error should have NoConnection code');
+        test.equal(client.locks.length, 0, 'Locks array should be cleared');
+        test.done();
+    });
+};
+
+module.exports['Connection Edge: Lock rejection includes byeReason'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // Set byeReason before close
+    client.byeReason = 'Server shutting down';
+
+    let rejectedError = null;
+    client.locks = [
+        {
+            path: 'INBOX',
+            lockId: 'lock1',
+            resolve: () => {},
+            reject: err => {
+                rejectedError = err;
+            }
+        }
+    ];
+
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    client.close();
+
+    setImmediate(() => {
+        test.ok(rejectedError, 'Lock should be rejected');
+        test.equal(rejectedError.code, 'NoConnection');
+        test.equal(rejectedError.reason, 'Server shutting down', 'byeReason should be included');
+        test.done();
+    });
+};
+
+module.exports['Connection Edge: currentLock cleared on close'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // Simulate an active lock
+    client.currentLock = {
+        path: 'INBOX',
+        lockId: 'active-lock',
+        release: () => {}
+    };
+    client.locks = [];
+
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    client.close();
+
+    test.equal(client.currentLock, false, 'currentLock should be cleared');
+    test.done();
+};
+
+module.exports['Connection Edge: Lock rejection handles missing reject function'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    // Create lock with missing reject function (edge case)
+    let validRejected = false;
+    client.locks = [
+        {
+            path: 'INBOX',
+            lockId: 'lock1',
+            resolve: () => {}
+            // No reject function
+        },
+        {
+            path: 'Sent',
+            lockId: 'lock2',
+            resolve: () => {},
+            reject: () => {
+                validRejected = true;
+            }
+        }
+    ];
+
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    // Should not throw
+    test.doesNotThrow(() => {
+        client.close();
+    }, 'Should handle missing reject function gracefully');
+
+    setImmediate(() => {
+        test.ok(validRejected, 'Valid lock should still be rejected');
+        test.equal(client.locks.length, 0, 'Locks array should be cleared');
+        test.done();
+    });
+};
+
+module.exports['Connection Edge: Close with empty locks array'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    client.locks = [];
+    client.currentLock = false;
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    // Should not throw with empty locks
+    test.doesNotThrow(() => {
+        client.close();
+    }, 'Should handle empty locks array');
+
+    test.equal(client.currentLock, false);
+    test.done();
+};
+
+module.exports['Connection Edge: Lock rejection is deferred via setImmediate'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    let rejectionTime = null;
+    let closeTime = null;
+
+    client.locks = [
+        {
+            path: 'INBOX',
+            lockId: 'lock1',
+            resolve: () => {},
+            reject: () => {
+                rejectionTime = Date.now();
+            }
+        }
+    ];
+
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    client.close();
+    closeTime = Date.now();
+
+    // Rejection should not have happened yet (synchronously)
+    test.equal(rejectionTime, null, 'Rejection should be deferred');
+
+    setImmediate(() => {
+        test.ok(rejectionTime !== null, 'Rejection should happen after setImmediate');
+        test.ok(rejectionTime >= closeTime, 'Rejection should happen after close()');
+        test.done();
+    });
+};
+
+module.exports['Connection Edge: Pending requests and locks both rejected on close'] = test => {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    let requestRejected = false;
+    let lockRejected = false;
+
+    // Add pending request - must be in requestQueue and requestTagMap
+    let request = {
+        tag: 'A001',
+        reject: err => {
+            requestRejected = true;
+            test.equal(err.code, 'NoConnection');
+        }
+    };
+    client.requestTagMap = new Map();
+    client.requestTagMap.set('A001', request);
+    client.requestQueue = [request];
+
+    // Add pending lock
+    client.locks = [
+        {
+            path: 'INBOX',
+            lockId: 'lock1',
+            resolve: () => {},
+            reject: err => {
+                lockRejected = true;
+                test.equal(err.code, 'NoConnection');
+            }
+        }
+    ];
+
+    client.socket = { destroyed: false, destroy: () => {} };
+    client.usable = true;
+
+    client.close();
+
+    setImmediate(() => {
+        test.ok(requestRejected, 'Pending request should be rejected');
+        test.ok(lockRejected, 'Pending lock should be rejected');
+        test.done();
+    });
+};