imapflow 1.2.9 → 1.2.10

package/.release-please-manifest.json

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

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.2.10](https://github.com/postalsys/imapflow/compare/v1.2.9...v1.2.10) (2026-02-19)
+
+
+### Bug Fixes
+
+* add null guards in compress() to prevent crash on TLS teardown ([84cd3ff](https://github.com/postalsys/imapflow/commit/84cd3ff8815d8ba37a37c1e7a09c244e80b61948))
+
 ## [1.2.9](https://github.com/postalsys/imapflow/compare/v1.2.8...v1.2.9) (2026-02-06)
 
 

package/README.md

@@ -1,109 +1,87 @@
 # ImapFlow
 
-ImapFlow is a modern and easy-to-use IMAP client library for Node.js.
+Modern and easy-to-use IMAP client library for Node.js.
 
-> [!NOTE]
-> Managing an IMAP connection is cool, but if you are only looking for an easy way to integrate email accounts, then ImapFlow was built for [EmailEngine Email API](https://emailengine.app/). It's a self-hosted software that converts all IMAP accounts to easy-to-use REST interfaces.
-
-The focus for ImapFlow is to provide easy to use API over IMAP. Using ImapFlow does not expect knowledge about specific IMAP details. A general understanding is good enough.
-
-IMAP extensions are handled in the background, so, for example, you can always request `labels` value from a `fetch()` call, but if the IMAP server does not support `X-GM-EXT-1` extension, then `labels` value is not included in the response.
+[![npm](https://img.shields.io/npm/v/imapflow)](https://www.npmjs.com/package/imapflow)
+[![license](https://img.shields.io/npm/l/imapflow)](https://github.com/postalsys/imapflow/blob/master/LICENSE)
 
-## Source
+ImapFlow provides a clean, promise-based API for working with IMAP, so you don't need in-depth knowledge of the protocol. IMAP extensions are detected and handled automatically. You write the same code regardless of server capabilities, and ImapFlow adapts behind the scenes.
 
-Source code is available from [Github](https://github.com/postalsys/imapflow).
+## Features
 
-## Usage
+- **Async/await API** - all methods return Promises
+- **Automatic IMAP extension handling** - CONDSTORE, QRESYNC, IDLE, COMPRESS, and [more](https://imapflow.com/docs/)
+- **Message streaming** - async iterators for efficient processing
+- **Mailbox locking** - built-in locking mechanism for safe concurrent access
+- **TypeScript support** - type definitions included
+- **Proxy support** - SOCKS and HTTP CONNECT proxies
+- **Gmail support** - labels, raw search via X-GM-EXT-1
 
-First install the module from npm:
+## Installation
 
-```
+```bash
 npm install imapflow
 ```
 
-next import the ImapFlow class into your script:
+## Quick Example
 
 ```js
 const { ImapFlow } = require('imapflow');
-```
-
-### Promises
 
-All ImapFlow methods use Promises, so you need to wait using `await` or wait for the `then()` method to fire until you get the response.
-
-```js
-const { ImapFlow } = require('imapflow');
 const client = new ImapFlow({
-    host: 'ethereal.email',
+    host: 'imap.example.com',
     port: 993,
     secure: true,
     auth: {
-        user: 'garland.mcclure71@ethereal.email',
-        pass: 'mW6e4wWWnEd3H4hT5B'
+        user: 'user@example.com',
+        pass: 'password'
     }
 });
 
 const main = async () => {
-    // Wait until client connects and authorizes
     await client.connect();
 
-    // Select and lock a mailbox. Throws if mailbox does not exist
     let lock = await client.getMailboxLock('INBOX');
     try {
-        // fetch latest message source
-        // client.mailbox includes information about currently selected mailbox
-        // "exists" value is also the largest sequence number available in the mailbox
+        // fetch latest message
         let message = await client.fetchOne(client.mailbox.exists, { source: true });
         console.log(message.source.toString());
 
         // list subjects for all messages
-        // uid value is always included in FETCH response, envelope strings are in unicode.
         for await (let message of client.fetch('1:*', { envelope: true })) {
             console.log(`${message.uid}: ${message.envelope.subject}`);
         }
     } finally {
-        // Make sure lock is released, otherwise next `getMailboxLock()` never returns
+        // always release the lock
         lock.release();
     }
 
-    // log out and close connection
     await client.logout();
 };
 
-main().catch(err => console.error(err));
+main().catch(console.error);
 ```
 
-### Admin Impersonation / Delegation (SASL PLAIN with authzid)
+See the [Quick Start guide](https://imapflow.com/docs/getting-started/quick-start) for more examples, including Gmail, Outlook, and Yahoo configuration.
 
-ImapFlow supports admin impersonation for mail systems like Zimbra that allow administrators to access user mailboxes. This is done using the SASL PLAIN mechanism with an authorization identity (`authzid`).
-
-```js
-const { ImapFlow } = require('imapflow');
-const client = new ImapFlow({
-    host: 'mail.example.com',
-    port: 993,
-    secure: true,
-    auth: {
-        user: 'admin@example.com', // Admin credentials (authentication identity)
-        pass: 'adminpassword',
-        authzid: 'user@example.com', // User to impersonate (authorization identity)
-        loginMethod: 'AUTH=PLAIN' // Must use PLAIN mechanism for authzid
-    }
-});
+## Documentation
 
-// Connection will authenticate as admin but authorize as the specified user
-await client.connect();
-// Now operating on user@example.com's mailbox as admin
-```
+Full documentation is available at **[imapflow.com](https://imapflow.com/docs/)**.
 
-**Note:** The `authzid` parameter only works with the `AUTH=PLAIN` mechanism. The server must support admin delegation/impersonation for this to work.
+- [Installation](https://imapflow.com/docs/getting-started/installation) - requirements and setup
+- [Quick Start](https://imapflow.com/docs/getting-started/quick-start) - your first ImapFlow application
+- [Basic Usage](https://imapflow.com/docs/guides/basic-usage) - core concepts and patterns
+- [Configuration](https://imapflow.com/docs/guides/configuration) - connection options and settings
+- [Fetching Messages](https://imapflow.com/docs/guides/fetching-messages) - reading email data
+- [Searching](https://imapflow.com/docs/guides/searching) - finding messages with search queries
+- [Mailbox Management](https://imapflow.com/docs/guides/mailbox-management) - creating, renaming, and deleting mailboxes
+- [API Reference](https://imapflow.com/docs/api/imapflow-client) - complete method and event documentation
 
-## Documentation
-
-[API reference](https://imapflow.com/docs/api/imapflow-client).
+> [!NOTE]
+> If you are looking for a complete email integration solution, ImapFlow was built for [EmailEngine](https://emailengine.app/), a self-hosted email gateway that provides REST API access to IMAP and SMTP accounts.
 
 ## License
 
-© 2020-2025 Postal Systems OÜ
+Copyright (c) 2020-2025 Postal Systems OU
 
-Licensed under **MIT-license**
+Licensed under the MIT license.

package/eslint.config.js

@@ -1,38 +1,40 @@
 'use strict';
 
-const { FlatCompat } = require('@eslint/eslintrc');
 const js = require('@eslint/js');
-
-const compat = new FlatCompat({
-    baseDirectory: __dirname,
-    recommendedConfig: js.configs.recommended
-});
+const globals = require('globals');
+const prettierConfig = require('eslint-config-prettier/flat');
+const nodemailerConfig = require('eslint-config-nodemailer');
 
 module.exports = [
     {
         ignores: ['node_modules/**', 'examples/**', 'docs/**']
     },
-    ...compat.extends('nodemailer', 'prettier'),
+    js.configs.recommended,
     {
         languageOptions: {
-            ecmaVersion: 2020,
+            ecmaVersion: 2022,
             sourceType: 'script',
-            globals: {
-                BigInt: 'readonly'
-            },
-            parser: require('@babel/eslint-parser'),
             parserOptions: {
-                requireConfigFile: false
+                ecmaFeatures: {
+                    globalReturn: true
+                }
+            },
+            globals: {
+                ...globals.node,
+                ...globals.es2021,
+                it: 'readonly',
+                describe: 'readonly',
+                beforeEach: 'readonly',
+                afterEach: 'readonly'
             }
         },
-        plugins: {
-            '@babel': require('@babel/eslint-plugin')
-        },
         rules: {
+            ...nodemailerConfig.rules,
             'no-await-in-loop': 0,
             'require-atomic-updates': 0
         }
     },
+    prettierConfig,
     {
         files: ['eslint.config.js', '.prettierrc.js', '.ncurc.js'],
         rules: {

package/lib/imap-flow.js

@@ -1018,7 +1018,7 @@ class ImapFlow extends EventEmitter {
                 processedChunks = 0;
 
                 let chunk;
-                while ((chunk = this.writeSocket.read()) !== null) {
+                while (this.writeSocket && (chunk = this.writeSocket.read()) !== null) {
                     if (this._deflate && this._deflate.write(chunk) === false) {
                         return this._deflate.once('drain', readNext);
                     }
@@ -1027,6 +1027,9 @@ class ImapFlow extends EventEmitter {
                     processedChunks++;
                     if (processedChunks % 100 === 0) {
                         await new Promise(resolve => setImmediate(resolve));
+                        if (!this.writeSocket) {
+                            break;
+                        }
                     }
                 }
 
@@ -1042,17 +1045,21 @@ class ImapFlow extends EventEmitter {
         };
 
         this.writeSocket.on('readable', () => {
-            if (!reading) {
+            if (!reading && this.writeSocket) {
                 readNext();
             }
         });
         this.writeSocket.on('error', err => {
-            this.socket.emit('error', err);
+            if (this.socket) {
+                this.socket.emit('error', err);
+            }
         });
 
         this._deflate.pipe(this.socket);
         this._deflate.on('error', err => {
-            this.socket.emit('error', err);
+            if (this.socket) {
+                this.socket.emit('error', err);
+            }
         });
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.2.9",
+    "version": "1.2.10",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",
@@ -27,13 +27,8 @@
     },
     "homepage": "https://imapflow.com/",
     "devDependencies": {
-        "@babel/eslint-parser": "7.28.6",
-        "@babel/eslint-plugin": "7.27.1",
-        "@babel/plugin-syntax-class-properties": "7.12.13",
-        "@babel/preset-env": "7.29.0",
-        "@eslint/eslintrc": "3.3.3",
         "@eslint/js": "9.39.2",
-        "@types/node": "25.2.1",
+        "@types/node": "25.3.0",
         "c8": "10.1.3",
         "eslint": "9.39.2",
         "eslint-config-nodemailer": "1.2.0",
@@ -41,7 +36,7 @@
         "grunt": "1.6.1",
         "grunt-cli": "1.5.0",
         "grunt-contrib-nodeunit": "5.0.0",
-        "grunt-eslint": "24.3.0",
+        "grunt-eslint": "26.0.0",
         "prettier": "3.8.1",
         "proxyquire": "^2.1.3",
         "typescript": "5.9.3"
@@ -53,8 +48,8 @@
         "libbase64": "1.3.0",
         "libmime": "5.3.7",
         "libqp": "2.1.1",
-        "nodemailer": "8.0.0",
-        "pino": "10.3.0",
+        "nodemailer": "8.0.1",
+        "pino": "10.3.1",
         "socks": "2.8.7"
     }
 }

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

@@ -1464,3 +1464,108 @@ module.exports['Connection Edge: connect throws if called twice'] = async test =
 
     test.done();
 };
+
+// Helper to create a mock client with compression enabled
+async function setupCompressedClient() {
+    let client = new ImapFlow({
+        host: 'imap.example.com',
+        port: 993,
+        auth: { user: 'test', pass: 'test' }
+    });
+
+    let mockSocket = new EventEmitter();
+    mockSocket.pipe = dest => dest;
+    mockSocket.unpipe = () => {};
+    mockSocket.destroy = () => {};
+    mockSocket.destroyed = false;
+    client.socket = mockSocket;
+    client.streamer = new EventEmitter();
+
+    client.run = async command => {
+        if (command === 'COMPRESS') {
+            return true;
+        }
+    };
+
+    await client.compress();
+    return { client, mockSocket };
+}
+
+module.exports['Connection Edge: compress writeSocket error forwarded to socket when live'] = async test => {
+    let { client, mockSocket } = await setupCompressedClient();
+
+    let errorReceived = false;
+    mockSocket.on('error', err => {
+        errorReceived = true;
+        test.equal(err.message, 'writeSocket error');
+    });
+
+    client.writeSocket.emit('error', new Error('writeSocket error'));
+
+    test.ok(errorReceived, 'Error should be forwarded to socket');
+    test.done();
+};
+
+module.exports['Connection Edge: compress _deflate error forwarded to socket when live'] = async test => {
+    let { client, mockSocket } = await setupCompressedClient();
+
+    let errorReceived = false;
+    mockSocket.on('error', err => {
+        errorReceived = true;
+        test.equal(err.message, 'deflate error');
+    });
+
+    client._deflate.emit('error', new Error('deflate error'));
+
+    test.ok(errorReceived, 'Error should be forwarded to socket');
+    test.done();
+};
+
+module.exports['Connection Edge: compress readable after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    // Save reference before close() nulls it
+    let writeSocket = client.writeSocket;
+
+    client.close();
+
+    // Emit readable on the saved reference after close has nulled this.writeSocket
+    // This should not throw (guards at lines 1048 and 1021)
+    test.doesNotThrow(() => {
+        writeSocket.emit('readable');
+    });
+
+    test.done();
+};
+
+module.exports['Connection Edge: compress writeSocket error after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    let writeSocket = client.writeSocket;
+
+    client.close();
+
+    // Emit error on saved writeSocket after close has nulled this.socket
+    // This should not throw (guard at lines 1053-1055)
+    test.doesNotThrow(() => {
+        writeSocket.emit('error', new Error('late writeSocket error'));
+    });
+
+    test.done();
+};
+
+module.exports['Connection Edge: compress _deflate error after close does not crash'] = async test => {
+    let { client } = await setupCompressedClient();
+
+    let deflate = client._deflate;
+
+    client.close();
+
+    // Emit error on saved _deflate after close has nulled this.socket
+    // This should not throw (guard at lines 1060-1062)
+    test.doesNotThrow(() => {
+        deflate.emit('error', new Error('late deflate error'));
+    });
+
+    test.done();
+};

package/.babelrc

@@ -1,6 +0,0 @@
-{
-    "presets": ["@babel/env"],
-    "plugins": [
-        "@babel/plugin-syntax-class-properties"
-    ]
-}

package/.eslintrc

@@ -1,16 +0,0 @@
-{
-    "rules": {
-        "no-await-in-loop": 0,
-        "require-atomic-updates": 0
-    },
-    "globals": {
-        "BigInt": true
-    },
-    "extends": ["nodemailer", "prettier"],
-    "parser": "@babel/eslint-parser",
-    "parserOptions": {
-        "ecmaVersion": 2020,
-        "sourceType": "script"
-    },
-    "plugins": ["@babel"]
-}