@bobfrankston/mailx-store 0.1.76 → 0.1.78

package/db.js

@@ -3704,8 +3704,26 @@ export class MailxDB {
         const LIKE_CC = ["m.cc_json"];
         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 = [];
+        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")
@@ -3826,12 +3844,14 @@ export class MailxDB {
                 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) {
@@ -3893,6 +3913,20 @@ 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
         // operator at the edge of the MATCH string ("ab OR sprinkler" → the
@@ -3902,6 +3936,14 @@ export class MailxDB {
             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/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",