imapflow 1.2.1 → 1.2.3

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "1.2.1"
+    ".": "1.2.3"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.2.3](https://github.com/postalsys/imapflow/compare/v1.2.2...v1.2.3) (2025-12-22)
+
+
+### Bug Fixes
+
+* Add logging for silently swallowed download errors ([b9f1012](https://github.com/postalsys/imapflow/commit/b9f101249236f55c48a68fd6f320d550055dd4e4))
+
+## [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)
 
 

package/lib/imap-flow.js

@@ -1730,18 +1730,39 @@ class ImapFlow extends EventEmitter {
                 }
             }
 
-            // Defer rejections to next tick to allow event handlers to be properly set up
-            // This helps prevent unhandled rejections when connection closes unexpectedly
+            // 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) {
-                        const error = new Error('Connection not available');
-                        error.code = 'NoConnection';
-                        if (byeReason) {
-                            error.reason = byeReason;
+                        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));
                         }
-                        request.reject(error);
                     }
                 });
             }
@@ -3079,6 +3100,15 @@ class ImapFlow extends EventEmitter {
                             .catch(err => {
                                 if (!fetchAborted && stream && !stream.destroyed) {
                                     stream.emit('error', err);
+                                } else {
+                                    // Log when error cannot be emitted to stream
+                                    this.log.warn({
+                                        msg: 'Download error after stream closed',
+                                        err,
+                                        fetchAborted,
+                                        streamDestroyed: stream?.destroyed,
+                                        cid: this.id
+                                    });
                                 }
                             })
                             .finally(() => {
@@ -3093,6 +3123,15 @@ class ImapFlow extends EventEmitter {
                     .catch(err => {
                         if (!fetchAborted && stream && !stream.destroyed) {
                             stream.emit('error', err);
+                        } else {
+                            // Log when error cannot be emitted to stream
+                            this.log.warn({
+                                msg: 'Download error after stream closed',
+                                err,
+                                fetchAborted,
+                                streamDestroyed: stream?.destroyed,
+                                cid: this.id
+                            });
                         }
                     })
                     .finally(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.2.1",
+    "version": "1.2.3",
     "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();
+    });
+};