imapflow 1.2.15 → 1.2.16

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "1.2.15"
+    ".": "1.2.16"
 }

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.2.16](https://github.com/postalsys/imapflow/compare/v1.2.15...v1.2.16) (2026-03-19)
+
+
+### Bug Fixes
+
+* parenthesize compound OR/NOT search conditions (RFC 3501) ([347f668](https://github.com/postalsys/imapflow/commit/347f66827ea089acab88aa78485752d84b7b7f3d)), closes [#106](https://github.com/postalsys/imapflow/issues/106)
+
 ## [1.2.15](https://github.com/postalsys/imapflow/compare/v1.2.14...v1.2.15) (2026-03-16)
 
 

package/lib/search-compiler.js

@@ -142,6 +142,17 @@ module.exports.searchCompiler = (connection, query) => {
      * @param {Object} params - Query parameters to process
      */
     const walk = params => {
+        // Walks a query object and wraps the resulting attributes in a
+        // sub-array so the IMAP compiler emits parentheses around them.
+        // Used when a single search-key is required (NOT, OR operands)
+        // but the condition has multiple keys (RFC 3501 Section 6.4.4).
+        let walkGrouped = obj => {
+            let startIdx = attributes.length;
+            walk(obj);
+            let subAttrs = attributes.splice(startIdx);
+            attributes.push(subAttrs);
+        };
+
         Object.keys(params || {}).forEach(term => {
             switch (term.toUpperCase()) {
                 // Custom sequence range support (non-standard)
@@ -318,8 +329,11 @@ module.exports.searchCompiler = (connection, query) => {
                 case 'NOT':
                     if (params[term] && typeof params[term] === 'object') {
                         attributes.push({ type: 'ATOM', value: 'NOT' });
-                        // Recursively process NOT conditions
-                        walk(params[term]);
+                        if (Object.keys(params[term]).length > 1) {
+                            walkGrouped(params[term]);
+                        } else {
+                            walk(params[term]);
+                        }
                     }
                     break;
 
@@ -388,7 +402,6 @@ module.exports.searchCompiler = (connection, query) => {
                          */
                         let walkOrTree = entry => {
                             if (Array.isArray(entry)) {
-                                // Only add OR for multiple items
                                 if (entry.length > 1) {
                                     attributes.push({ type: 'ATOM', value: 'OR' });
                                 }
@@ -396,7 +409,11 @@ module.exports.searchCompiler = (connection, query) => {
                                 return;
                             }
                             if (entry && typeof entry === 'object') {
-                                walk(entry);
+                                if (Object.keys(entry).length > 1) {
+                                    walkGrouped(entry);
+                                } else {
+                                    walk(entry);
+                                }
                             }
                         };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.2.15",
+    "version": "1.2.16",
     "description": "IMAP Client for Node",
     "main": "lib/imap-flow.js",
     "types": "lib/imap-flow.d.ts",
@@ -48,7 +48,7 @@
         "libbase64": "1.3.0",
         "libmime": "5.3.7",
         "libqp": "2.1.1",
-        "nodemailer": "8.0.2",
+        "nodemailer": "8.0.3",
         "pino": "10.3.1",
         "socks": "2.8.7"
     }

package/test/search-compiler-test.js

@@ -15,9 +15,19 @@ let createMockConnection = (options = {}) => ({
     mailbox: options.mailbox || createMockMailbox()
 });
 
-// Helper to find attribute by value
-let findAttr = (attrs, value) => attrs.find(a => a.value === value);
-let hasAttr = (attrs, value) => attrs.some(a => a.value === value);
+// Helper to find attribute by value (recurses into sub-arrays for parenthesized groups)
+let findAttr = (attrs, value) => {
+    for (let a of attrs) {
+        if (Array.isArray(a)) {
+            let found = findAttr(a, value);
+            if (found) return found;
+        } else if (a.value === value) {
+            return a;
+        }
+    }
+    return undefined;
+};
+let hasAttr = (attrs, value) => !!findAttr(attrs, value);
 
 // ============================================
 // Basic functionality tests
@@ -659,6 +669,10 @@ module.exports['Search Compiler: NOT with nested conditions'] = test => {
     test.ok(hasAttr(compiled, 'NOT'));
     test.ok(hasAttr(compiled, 'SEEN'));
     test.ok(hasAttr(compiled, 'FROM'));
+    // Compound NOT conditions should be wrapped in a sub-array (parenthesized)
+    // so the server treats them as a single search-key
+    test.equal(compiled[0].value, 'NOT');
+    test.ok(Array.isArray(compiled[1]), 'compound NOT should be parenthesized');
     test.done();
 };
 
@@ -899,6 +913,70 @@ module.exports['Search Compiler: OR with 5 conditions produces 4 OR atoms'] = te
     test.done();
 };
 
+module.exports['Search Compiler: OR with compound conditions wraps in parentheses'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, {
+        or: [
+            { to: 'a@example.com', from: 'b@example.com' },
+            { to: 'c@example.com', from: 'd@example.com' }
+        ]
+    });
+
+    // OR should be present
+    test.equal(compiled[0].value, 'OR');
+    // Each compound condition should be a sub-array (parenthesized)
+    test.ok(Array.isArray(compiled[1]), 'first compound operand should be parenthesized');
+    test.ok(Array.isArray(compiled[2]), 'second compound operand should be parenthesized');
+    // Check contents of parenthesized groups
+    test.ok(hasAttr(compiled[1], 'TO'), 'first group should have TO');
+    test.ok(hasAttr(compiled[1], 'FROM'), 'first group should have FROM');
+    test.ok(hasAttr(compiled[2], 'TO'), 'second group should have TO');
+    test.ok(hasAttr(compiled[2], 'FROM'), 'second group should have FROM');
+    test.done();
+};
+
+module.exports['Search Compiler: OR with single-key conditions stays flat'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, {
+        or: [{ from: 'a@example.com' }, { from: 'b@example.com' }]
+    });
+
+    // Single-key conditions should not be wrapped in sub-arrays
+    test.equal(compiled[0].value, 'OR');
+    test.ok(!Array.isArray(compiled[1]), 'single-key operand should not be parenthesized');
+    test.equal(compiled[1].value, 'FROM');
+    test.done();
+};
+
+module.exports['Search Compiler: OR with 5 compound conditions from issue #106'] = test => {
+    let connection = createMockConnection();
+    let compiled = searchCompiler(connection, {
+        or: [
+            { to: 'myemail@domain.com', from: '@anotherdomain.com' },
+            { to: 'myemail@domain.com', from: '@aseconddomain.com' },
+            { to: 'myemail@domain.com', from: '@athirddomain.fr' },
+            { to: 'anotheremail@domain.com', from: '@anotherdomain.fr' },
+            { to: 'anotheremail@domain.com', from: '@aseconddomain.com' }
+        ]
+    });
+
+    // 5 conditions need 4 OR atoms
+    let orCount = compiled.filter(a => a.value === 'OR').length;
+    test.equal(orCount, 4, 'should have exactly 4 OR atoms for 5 conditions');
+
+    // All compound conditions should be parenthesized (sub-arrays)
+    let subArrays = compiled.filter(a => Array.isArray(a));
+    test.equal(subArrays.length, 5, 'should have 5 parenthesized groups');
+
+    // Each group should contain both TO and FROM
+    subArrays.forEach((group, i) => {
+        test.ok(hasAttr(group, 'TO'), 'group ' + i + ' should have TO');
+        test.ok(hasAttr(group, 'FROM'), 'group ' + i + ' should have FROM');
+    });
+
+    test.done();
+};
+
 // ============================================
 // Unicode CHARSET in HEADER searches
 // ============================================