@bobfrankston/rmfmail 1.2.196 → 1.2.197

package/packages/mailx-store/db.ts

@@ -3946,8 +3946,23 @@ export class MailxDB {
         const LIKE_SUBJ = ["m.subject"];
         const LIKE_ANY = ["m.subject", "m.from_name", "m.from_address"];
 
+        // `NOT <item>` — exclusion, usable ANYWHERE including as the leading
+        // (or only) token. FTS5's own NOT is strictly binary (`a NOT b`), so
+        // a leading NOT was an FTS5 syntax error that the dangling-operator
+        // trim "fixed" by dropping the NOT — silently searching FOR the term
+        // the user asked to exclude (Bob 2026-07-30). Instead of leaning on
+        // FTS5's operator, every `NOT x` pair is lifted OUT of the MATCH and
+        // applied as a SQL-side exclusion (`m.id NOT IN (SELECT rowid …
+        // MATCH x)`), which also negates qualifier tokens (`NOT from:…`,
+        // `NOT is:read`) uniformly. Uppercase only, same as AND/OR — a
+        // lowercase "not" stays an ordinary search term.
+        const notFrags: string[] = [];
+        let negateNext = false;
         for (let pi = 0; pi < parts.length; pi++) {
             const part = parts[pi];
+            if (part === "NOT") { negateNext = true; continue; }
+            const wPre = extraWhere.length;
+            const fPre = frags.length;
             // A 1-2 char term next to a user-typed OR must be DROPPED, not
             // LIKE'd: LIKE clauses AND against the MATCH, so "ab OR sprinkler"
             // would intersect down to zero. Over-matching (just "sprinkler")
@@ -4029,12 +4044,14 @@ export class MailxDB {
                 const v = folderMatch[1].replace(/"/g, "");
                 extraWhere.push("LOWER(f.name) LIKE ?");
                 extraParams.push(`%${v.toLowerCase()}%`);
-            } else if (/^(AND|OR|NOT)$/.test(part)) {
+            } else if (/^(AND|OR)$/.test(part)) {
                 // FTS5 boolean operators — pass through verbatim (must be uppercase).
                 // Without this branch, `hoddie AND git` got wildcarded into
                 // `hoddie* AND* git*`, which FTS5 reads as three required terms
                 // (one of them being any word starting with "AND") — so a real
                 // match like "Peter Hoddie" + "github" returned zero hits.
+                // (NOT is handled above as an exclusion prefix, not passed
+                // through — FTS5's binary-only NOT can't stand at the front.)
                 frags.push({ s: part, op: true });
             } else if (isTri) {
                 // Unqualified, trigram dialect — quoted substring match. A
@@ -4087,6 +4104,18 @@ export class MailxDB {
                     }
                 }
             }
+            // Divert whatever this token contributed into the exclusion set.
+            // FTS frags move to notFrags (applied as a NOT IN subquery below);
+            // SQL-side qualifier clauses get wrapped in NOT(...) in place. An
+            // AND/OR right after NOT is nonsense input — the op frag stands
+            // and the stray NOT is dropped.
+            if (negateNext) {
+                if (!/^(AND|OR)$/.test(part)) {
+                    for (let w = wPre; w < extraWhere.length; w++) extraWhere[w] = `NOT (${extraWhere[w]})`;
+                    while (frags.length > fPre) notFrags.push(frags.pop()!.s);
+                }
+                negateNext = false;
+            }
         }
 
         // A term diverted to the LIKE fallback can strand a user-typed
@@ -4096,6 +4125,15 @@ export class MailxDB {
         while (frags.length && frags[0].op) frags.shift();
         while (frags.length && frags[frags.length - 1].op) frags.pop();
 
+        // NOT'd terms exclude via a subquery on the same FTS index: a message
+        // matching ANY excluded term is out. Works whether or not there are
+        // positive FTS terms — a pure `NOT foo` query takes the qualifier-only
+        // path below and returns everything except matches.
+        if (notFrags.length > 0) {
+            extraWhere.push("m.id NOT IN (SELECT rowid FROM messages_fts WHERE messages_fts MATCH ?)");
+            extraParams.push(notFrags.join(" OR "));
+        }
+
         // Join fragments. Two adjacent value fragments need an explicit `AND`
         // (implicit-AND after a `(...)` / `{...}:` group is an FTS5 syntax
         // error); a user operator fragment glues itself, so no insert around it.

package/packages/mailx-store/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",