@bobfrankston/mailx-store 0.1.74 → 0.1.78

package/db.d.ts

@@ -274,8 +274,12 @@ export declare class MailxDB {
      *  During the additive migration we ALSO have to handle the legacy
      *  case where the row's folder_id matches but no message_folders row
      *  was migrated for it (race during initial population, etc.) — we
-     *  fall back to the messages.folder_id check to clean up consistently. */
-    dropFolderMembership(accountId: string, folderId: number, uid: number, folderPath?: string): boolean;
+     *  fall back to the messages.folder_id check to clean up consistently.
+     *
+     *  `reason`/`source` override the audit text — deleteMessage routes user
+     *  deletes through here, and "reconcile: server missing this UID" would
+     *  be a lie in that audit trail. */
+    dropFolderMembership(accountId: string, folderId: number, uid: number, folderPath?: string, reason?: string, source?: string): boolean;
     upsertMessage(msg: {
         accountId: string;
         folderId: number;

package/db.js

@@ -1675,8 +1675,12 @@ export class MailxDB {
      *  During the additive migration we ALSO have to handle the legacy
      *  case where the row's folder_id matches but no message_folders row
      *  was migrated for it (race during initial population, etc.) — we
-     *  fall back to the messages.folder_id check to clean up consistently. */
-    dropFolderMembership(accountId, folderId, uid, folderPath) {
+     *  fall back to the messages.folder_id check to clean up consistently.
+     *
+     *  `reason`/`source` override the audit text — deleteMessage routes user
+     *  deletes through here, and "reconcile: server missing this UID" would
+     *  be a lie in that audit trail. */
+    dropFolderMembership(accountId, folderId, uid, folderPath, reason, source) {
         // First find the messages row this membership pointed at.
         const mf = this.db.prepare("SELECT message_row_id FROM message_folders WHERE folder_id = ? AND uid = ?").get(folderId, uid);
         let rowId = null;
@@ -1711,8 +1715,8 @@ export class MailxDB {
             this.audit({
                 kind: "delete-membership",
                 accountId, folderId, uid,
-                reason: `reconcile dropped folder membership; ${remaining.cnt} other location(s) remain`,
-                source: `dropFolderMembership (${folderPath || ""})`,
+                reason: reason || `reconcile dropped folder membership; ${remaining.cnt} other location(s) remain`,
+                source: source || `dropFolderMembership (${folderPath || ""})`,
             });
             return true;
         }
@@ -1726,8 +1730,8 @@ export class MailxDB {
                 accountId, folderId, uid,
                 messageId: env.message_id || undefined,
                 subject: env.subject || undefined,
-                reason: "reconcile: server missing this UID after grace, no other folder memberships",
-                source: `dropFolderMembership (${folderPath || ""})`,
+                reason: reason || "reconcile: server missing this UID after grace, no other folder memberships",
+                source: source || `dropFolderMembership (${folderPath || ""})`,
             });
             console.log(`  [reconcile-delete] ${accountId} ${folderPath || folderId}/${uid} msgid=${env.message_id || "?"} (no other memberships) — body ${env.body_path || "(none)"}`);
         }
@@ -2310,13 +2314,19 @@ export class MailxDB {
      *  hitting the message in `_Spam` (correct) and hitting nothing
      *  because the legacy messages.folder_id still points at INBOX. */
     getMessageByUid(accountId, uid, folderId) {
+        // Alias mf.folder_id over m.folder_id too — the envelope must carry
+        // the identity of the membership that MATCHED, not the legacy primary
+        // location, or a caller doing delete/move/flag with the returned
+        // folderId operates on a different folder than the one it looked up
+        // (the two drift: local moves keep the original uid, re-binds update
+        // one table but not the other).
         const sql = folderId != null
-            ? `SELECT m.*, mf.uid AS uid
+            ? `SELECT m.*, mf.uid AS uid, mf.folder_id AS folder_id
                FROM messages m
                JOIN message_folders mf ON mf.message_row_id = m.id
                WHERE m.account_id = ? AND mf.uid = ? AND mf.folder_id = ?
                LIMIT 1`
-            : `SELECT m.*, mf.uid AS uid
+            : `SELECT m.*, mf.uid AS uid, mf.folder_id AS folder_id
                FROM messages m
                JOIN message_folders mf ON mf.message_row_id = m.id
                WHERE m.account_id = ? AND mf.uid = ?
@@ -2884,14 +2894,31 @@ export class MailxDB {
      *  Reason is propagated into the audit_log so the DB carries an
      *  authoritative trail of every removal. */
     deleteMessage(accountId, folderId, uid, reason, source) {
-        // Get message_id + subject before deleting so the audit row carries
-        // enough context to identify what was removed.
-        const msg = folderId != null
-            ? this.db.prepare("SELECT folder_id, message_id, subject FROM messages WHERE account_id = ? AND folder_id = ? AND uid = ?").get(accountId, folderId, uid)
-            : this.db.prepare("SELECT folder_id, message_id, subject FROM messages WHERE account_id = ? AND uid = ?").get(accountId, uid);
-        const r = folderId != null
-            ? this.db.prepare("DELETE FROM messages WHERE account_id = ? AND folder_id = ? AND uid = ?").run(accountId, folderId, uid)
-            : this.db.prepare("DELETE FROM messages WHERE account_id = ? AND uid = ?").run(accountId, uid);
+        if (folderId != null) {
+            // Resolve through message_folders — the SAME identity that
+            // getMessageByUid and every list query use. The legacy
+            // messages.folder_id/uid columns can drift from the membership
+            // rows (local moves keep the original uid, server re-binds update
+            // one table but not the other), and a delete keyed only on the
+            // legacy columns silently matches ZERO rows on a drifted message:
+            // the membership keeps it visible in the UI and it becomes
+            // undeletable forever (Eleanor 2026-07-29: ElkinWs uid 125482 in
+            // Trash "refuses to delete" — every attempt no-op'd here while
+            // the sync action reported success). dropFolderMembership drops
+            // the membership, orphan-cleans the messages row, and falls back
+            // to the legacy columns for pre-migration rows.
+            const cleaned = this.dropFolderMembership(accountId, folderId, uid, undefined, reason || "deleteMessage (no reason)", source || "db.deleteMessage");
+            if (!cleaned) {
+                // A delete that deletes nothing is the "refuses to delete"
+                // symptom — never let it pass silently.
+                console.error(`  [delete-miss] ${accountId} folder=${folderId} uid=${uid}: no membership or legacy row matched — nothing deleted (source=${source || "db.deleteMessage"})`);
+            }
+            this.recalcFolderCounts(folderId);
+            return;
+        }
+        // No folderId (legacy callers): fall back to the messages-table key.
+        const msg = this.db.prepare("SELECT id, folder_id, message_id, subject FROM messages WHERE account_id = ? AND uid = ?").get(accountId, uid);
+        const r = this.db.prepare("DELETE FROM messages WHERE account_id = ? AND uid = ?").run(accountId, uid);
         if (r.changes && msg) {
             this.audit({
                 kind: "delete-msg",
@@ -2904,6 +2931,9 @@ export class MailxDB {
                 source: source || "db.deleteMessage",
             });
         }
+        else if (!r.changes) {
+            console.error(`  [delete-miss] ${accountId} uid=${uid} (no folderId): no messages row matched — nothing deleted (source=${source || "db.deleteMessage"})`);
+        }
         // Refresh folder counts
         if (msg)
             this.recalcFolderCounts(msg.folder_id);
@@ -3674,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")
@@ -3796,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) {
@@ -3863,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
@@ -3872,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.74",
+  "version": "0.1.78",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",