imapflow 1.2.10 → 1.2.12

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "1.2.10"
+    ".": "1.2.12"
 }

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.2.12](https://github.com/postalsys/imapflow/compare/v1.2.11...v1.2.12) (2026-03-05)
+
+
+### Bug Fixes
+
+* prevent unhandled NoConnection rejection in IDLE recovery ([e177372](https://github.com/postalsys/imapflow/commit/e17737296b6b2de9ba25392b79542cf6d7d45826))
+
+## [1.2.11](https://github.com/postalsys/imapflow/compare/v1.2.10...v1.2.11) (2026-03-03)
+
+
+### Bug Fixes
+
+* release backpressure in fetch() generator on early break/throw ([d42a377](https://github.com/postalsys/imapflow/commit/d42a377f8102f44fc76d8fa9a268bbf2526a7fa8)), closes [#338](https://github.com/postalsys/imapflow/issues/338)
+
 ## [1.2.10](https://github.com/postalsys/imapflow/compare/v1.2.9...v1.2.10) (2026-02-19)
 
 

package/lib/imap-flow.js

@@ -856,7 +856,12 @@ class ImapFlow extends EventEmitter {
                     // Attempt to recover IDLE connections
                     this.run('NOOP')
                         .then(() => this.idle())
-                        .catch(this._socketError); // Natural circuit breaker
+                        .catch(err => {
+                            this.log.warn({ msg: 'IDLE recovery failed after timeout', err, cid: this.id });
+                            if (!this.isClosed) {
+                                this.close();
+                            }
+                        });
                 } else {
                     // Close immediately for non-IDLE operations
                     this.log.debug({ msg: 'Socket timeout', cid: this.id });
@@ -2718,6 +2723,7 @@ class ImapFlow extends EventEmitter {
         // two: when the consumer is waiting and the queue is empty, `push` is set to
         // a function that wakes up the consumer when new data arrives.
         let finished = false;
+        let aborted = false;
         let push = false;
         let rowQueue = [];
 
@@ -2755,6 +2761,10 @@ class ImapFlow extends EventEmitter {
             binary: options.binary,
             changedSince: options.changedSince,
             onUntaggedFetch: (untagged, next) => {
+                if (aborted) {
+                    next();
+                    return;
+                }
                 rowQueue.push({
                     value: {
                         response: untagged,
@@ -2779,26 +2789,36 @@ class ImapFlow extends EventEmitter {
                 }
             });
 
-        let res;
-        while ((res = await getNext())) {
-            if (this.isClosed || !this.socket || this.socket.destroyed) {
-                let error = new Error('Connection closed');
-                error.code = 'EConnectionClosed';
-                throw error;
-            }
+        let lastRes = null;
+        try {
+            let res;
+            while ((res = await getNext())) {
+                lastRes = res;
+
+                if (this.isClosed || !this.socket || this.socket.destroyed) {
+                    let error = new Error('Connection closed');
+                    error.code = 'EConnectionClosed';
+                    throw error;
+                }
 
-            if (res !== null) {
                 yield res.response;
                 // Signal the FETCH handler to process the next untagged response
                 res.next();
+                lastRes = null;
+            }
+        } finally {
+            aborted = true;
+            // Release backpressure for the item that was yielded but whose
+            // next() was not yet called (happens on break/return/throw)
+            if (lastRes && typeof lastRes.next === 'function') {
+                lastRes.next();
+            }
+            while (rowQueue.length) {
+                let entry = rowQueue.shift();
+                if (entry.value && typeof entry.value.next === 'function') {
+                    entry.value.next();
+                }
             }
-        }
-
-        if (!finished) {
-            // FETCH never finished!
-            let error = new Error('FETCH did not finish');
-            error.code = 'ENotFinished';
-            throw error;
         }
     }
 

package/lib/tools.js

@@ -206,11 +206,7 @@ const tools = {
                 if (cur) {
                     node = cur;
                 } else {
-                    // not yet set
-                    cur = {
-                        name: parent,
-                        folders: []
-                    };
+                    // not yet set, will be created by the caller
                 }
             }
 
@@ -901,7 +897,6 @@ const tools = {
                 if (node[i]) {
                     curNode.location = ((node[i] || {}).value || '').toString();
                 }
-                i++;
             }
 
             return curNode;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.2.10",
+    "version": "1.2.12",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",
@@ -27,10 +27,10 @@
     },
     "homepage": "https://imapflow.com/",
     "devDependencies": {
-        "@eslint/js": "9.39.2",
-        "@types/node": "25.3.0",
-        "c8": "10.1.3",
-        "eslint": "9.39.2",
+        "@eslint/js": "10.0.1",
+        "@types/node": "25.3.3",
+        "c8": "11.0.0",
+        "eslint": "10.0.2",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "10.1.8",
         "grunt": "1.6.1",

package/test/bodystructure-test.js

@@ -234,237 +234,6 @@ module.exports['Process correct TEXT with line count'] = test => {
         null
     ];
 
-    attribute = [
-        [
-            [
-                {
-                    type: 'STRING',
-                    value: 'text'
-                },
-                {
-                    type: 'STRING',
-                    value: 'plain'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'charset'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'UTF-8'
-                    }
-                ],
-                null,
-                null,
-                {
-                    type: 'STRING',
-                    value: '7bit'
-                },
-                {
-                    type: 'ATOM',
-                    value: '23'
-                },
-                {
-                    type: 'ATOM',
-                    value: '1'
-                },
-                null,
-                null,
-                null,
-                null
-            ],
-            [
-                {
-                    type: 'STRING',
-                    value: 'text'
-                },
-                {
-                    type: 'STRING',
-                    value: 'html'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'charset'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'UTF-8'
-                    }
-                ],
-                null,
-                null,
-                {
-                    type: 'STRING',
-                    value: '7bit'
-                },
-                {
-                    type: 'ATOM',
-                    value: '49'
-                },
-                {
-                    type: 'ATOM',
-                    value: '1'
-                },
-                null,
-                null,
-                null,
-                null
-            ],
-            {
-                type: 'STRING',
-                value: 'alternative'
-            },
-            [
-                {
-                    type: 'STRING',
-                    value: 'boundary'
-                },
-                {
-                    type: 'STRING',
-                    value: '000000000000b56402062b1fba83'
-                }
-            ],
-            null,
-            null,
-            null
-        ],
-        [
-            {
-                type: 'STRING',
-                value: 'text'
-            },
-            {
-                type: 'STRING',
-                value: 'plain'
-            },
-            [
-                {
-                    type: 'STRING',
-                    value: 'charset'
-                },
-                {
-                    type: 'STRING',
-                    value: 'US-ASCII'
-                },
-                {
-                    type: 'STRING',
-                    value: 'name'
-                },
-                {
-                    type: 'STRING',
-                    value: 'log_imap_missing_attachments.txt'
-                }
-            ],
-            {
-                type: 'STRING',
-                value: '<f_m5mnf91y1>'
-            },
-            null,
-            {
-                type: 'STRING',
-                value: 'base64'
-            },
-            {
-                type: 'ATOM',
-                value: '33954'
-            },
-            {
-                type: 'ATOM',
-                value: '435'
-            },
-            null,
-            [
-                {
-                    type: 'STRING',
-                    value: 'attachment'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'filename'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'log_imap_missing_attachments.txt'
-                    }
-                ]
-            ],
-            null,
-            null
-        ],
-        [
-            {
-                type: 'STRING',
-                value: 'image'
-            },
-            {
-                type: 'STRING',
-                value: 'jpeg'
-            },
-            [
-                {
-                    type: 'STRING',
-                    value: 'name'
-                },
-                {
-                    type: 'STRING',
-                    value: 'img2.jpeg'
-                }
-            ],
-            {
-                type: 'STRING',
-                value: '<f_m5mnf4c70>'
-            },
-            null,
-            {
-                type: 'STRING',
-                value: 'base64'
-            },
-            {
-                type: 'ATOM',
-                value: '3776960'
-            },
-            null,
-            [
-                {
-                    type: 'STRING',
-                    value: 'attachment'
-                },
-                [
-                    {
-                        type: 'STRING',
-                        value: 'filename'
-                    },
-                    {
-                        type: 'STRING',
-                        value: 'img2.jpeg'
-                    }
-                ]
-            ],
-            null,
-            null
-        ],
-        {
-            type: 'STRING',
-            value: 'mixed'
-        },
-        [
-            {
-                type: 'STRING',
-                value: 'boundary'
-            },
-            {
-                type: 'STRING',
-                value: '000000000000b56402062b1fba85'
-            }
-        ],
-        null,
-        null,
-        null
-    ];
-
     let bodyStruct = parseBodystructure(attribute);
 
     test.deepEqual(bodyStruct, {

package/test/fetch-generator-test.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const { ImapFlow } = require('../lib/imap-flow');
+
+// Helper: create a minimal mock context with the fetch() generator bound to it.
+// The `run` override controls how untagged FETCH responses are delivered.
+const createFetchContext = runOverride => ({
+    mailbox: { path: 'INBOX', exists: 10 },
+    isClosed: false,
+    socket: { destroyed: false },
+    resolveRange: async range => range,
+    run: runOverride
+});
+
+// Helper: invoke the fetch generator on a mock context
+function callFetch(ctx, range, query, options) {
+    return ImapFlow.prototype.fetch.call(ctx, range, query, options);
+}
+
+// Helper: create a mock `run` that delivers `count` untagged FETCH responses,
+// each with a `next` callback for backpressure. Returns a tracking object.
+function createMockRun(count) {
+    const tracker = {
+        nextCalls: [], // records which message indices had next() called
+        onUntaggedFetch: null,
+        runResolved: false
+    };
+
+    const run = async (_cmd, _range, _query, opts) => {
+        tracker.onUntaggedFetch = opts.onUntaggedFetch;
+
+        for (let i = 0; i < count; i++) {
+            await new Promise(resolve => {
+                opts.onUntaggedFetch({ seq: i + 1, uid: 100 + i }, () => {
+                    tracker.nextCalls.push(i);
+                    resolve();
+                });
+            });
+        }
+        tracker.runResolved = true;
+    };
+
+    return { tracker, run };
+}
+
+// ---------------------------------------------------------------------------
+// Test: early break releases backpressure
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: early break releases backpressure'] = async test => {
+    const { tracker, run } = createMockRun(5);
+    const ctx = createFetchContext(run);
+
+    const gen = callFetch(ctx, '1:5', { uid: true });
+    // Consume only the first message and break
+    for await (let msg of gen) {
+        test.ok(msg.seq === 1, 'should receive the first message');
+        break;
+    }
+
+    // Allow microtasks to flush (the finally block runs synchronously with
+    // generator return, but the remaining run() deliveries are async)
+    await new Promise(r => setTimeout(r, 50));
+
+    // The first message had next() called by the yield loop (res.next()).
+    // Remaining queued/future messages should have next() called by the
+    // finally block or the aborted guard.
+    test.equal(tracker.nextCalls.length, 5, 'all 5 messages should have next() called');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: subsequent operations work after early exit
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: connection usable after early break'] = async test => {
+    let runCallCount = 0;
+
+    const run = async (_cmd, _range, _query, opts) => {
+        runCallCount++;
+        // Deliver 3 messages
+        for (let i = 0; i < 3; i++) {
+            await new Promise(resolve => {
+                opts.onUntaggedFetch({ seq: i + 1, uid: 200 + i }, () => resolve());
+            });
+        }
+    };
+
+    const ctx = createFetchContext(run);
+
+    // First fetch: break early
+    const gen1 = callFetch(ctx, '1:3', { uid: true });
+    for await (let msg of gen1) {
+        test.ok(msg.seq === 1);
+        break;
+    }
+
+    await new Promise(r => setTimeout(r, 50));
+
+    // Second fetch: should work (run gets called again)
+    const gen2 = callFetch(ctx, '1:3', { uid: true });
+    let secondFetchMessages = [];
+    for await (let msg of gen2) {
+        secondFetchMessages.push(msg);
+    }
+
+    test.ok(runCallCount === 2, 'run was called for both fetch operations');
+    test.ok(secondFetchMessages.length === 3, 'second fetch received all 3 messages');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: normal full iteration works correctly
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: normal full iteration receives all messages'] = async test => {
+    const { tracker, run } = createMockRun(4);
+    const ctx = createFetchContext(run);
+
+    let messages = [];
+    for await (let msg of callFetch(ctx, '1:4', { uid: true })) {
+        messages.push(msg);
+    }
+
+    test.equal(messages.length, 4, 'should receive all 4 messages');
+    test.equal(messages[0].seq, 1);
+    test.equal(messages[3].seq, 4);
+    test.equal(tracker.nextCalls.length, 4, 'all next() callbacks were called');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: error thrown in loop body releases backpressure
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: error in loop body releases backpressure'] = async test => {
+    const { tracker, run } = createMockRun(5);
+    const ctx = createFetchContext(run);
+
+    const gen = callFetch(ctx, '1:5', { uid: true });
+
+    let caught = false;
+    try {
+        for await (let msg of gen) {
+            if (msg.seq === 2) {
+                throw new Error('intentional test error');
+            }
+        }
+    } catch (err) {
+        caught = true;
+        test.equal(err.message, 'intentional test error');
+    }
+
+    await new Promise(r => setTimeout(r, 50));
+
+    test.ok(caught, 'error was caught');
+    // Messages 0 and 1 had next() called by the yield loop. The rest should
+    // be drained by the finally block or the aborted guard.
+    test.equal(tracker.nextCalls.length, 5, 'all 5 messages should have next() called');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: zero messages from server
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: zero messages yields nothing'] = async test => {
+    const { tracker, run } = createMockRun(0);
+    const ctx = createFetchContext(run);
+
+    let messages = [];
+    for await (let msg of callFetch(ctx, '1:*', { uid: true })) {
+        messages.push(msg);
+    }
+
+    test.equal(messages.length, 0, 'no messages should be yielded');
+    test.equal(tracker.nextCalls.length, 0, 'no next() calls needed');
+    test.ok(tracker.runResolved, 'run should have resolved');
+    test.done();
+};
+
+// ---------------------------------------------------------------------------
+// Test: connection closed during iteration throws and releases backpressure
+// ---------------------------------------------------------------------------
+module.exports['fetch generator: connection closed mid-iteration throws and cleans up'] = async test => {
+    const tracker = {
+        nextCalls: []
+    };
+
+    const run = async (_cmd, _range, _query, opts) => {
+        for (let i = 0; i < 3; i++) {
+            await new Promise(resolve => {
+                opts.onUntaggedFetch({ seq: i + 1, uid: 300 + i }, () => {
+                    tracker.nextCalls.push(i);
+                    resolve();
+                });
+            });
+        }
+    };
+
+    const ctx = createFetchContext(run);
+
+    let caught = false;
+    try {
+        for await (let msg of callFetch(ctx, '1:3', { uid: true })) {
+            if (msg.seq === 1) {
+                // Simulate connection closing after first message
+                ctx.isClosed = true;
+            }
+        }
+    } catch (err) {
+        caught = true;
+        test.equal(err.code, 'EConnectionClosed', 'should throw EConnectionClosed');
+    }
+
+    await new Promise(r => setTimeout(r, 50));
+
+    test.ok(caught, 'error was caught');
+    test.equal(tracker.nextCalls.length, 3, 'all next() callbacks should be called for cleanup');
+    test.done();
+};