@bobfrankston/mailx-store 0.1.14 → 0.1.16

package/db.d.ts

@@ -252,6 +252,28 @@ export declare class MailxDB {
     getMessageBodyPath(accountId: string, uid: number): string;
     updateMessageFlags(accountId: string, uid: number, flags: string[]): void;
     updateMessageFolder(accountId: string, uid: number, targetFolderId: number): void;
+    /** Local-first move of a message between folders. Updates BOTH the
+     *  legacy `messages.folder_id` column AND the `message_folders`
+     *  membership row, so user-visible queries (which join through mf)
+     *  immediately reflect the move. The same uid is preserved on the
+     *  destination side — once the IMAP MOVE drains and reconcile runs,
+     *  the membership uid is rebound to whatever the server assigned in
+     *  the new folder (move-detect by Message-ID does this).
+     *
+     *  Returns true if the message was found and moved, false otherwise.
+     *  Pre-fix `updateMessageFolder` only touched the legacy column, so
+     *  user-visible folder lists (which join through `message_folders`)
+     *  stayed showing the old location until the next reconcile.
+     *  Symptom: drag-to-folder doesn't visually arrive, Ctrl+Z undelete
+     *  doesn't restore until sync. */
+    moveMessageLocal(accountId: string, uid: number, fromFolderId: number, toFolderId: number): boolean;
+    /** Find a pending sync action by its identifying fields. Used by the
+     *  undelete path to detect "is the to-trash MOVE still queued?" — if
+     *  yes, cancelling it (completeSyncAction) is enough to undelete; the
+     *  server never sees the move. */
+    findPendingSyncAction(accountId: string, action: string, uid: number, folderId: number, targetFolderId?: number): {
+        id: number;
+    } | null;
     updateBodyPath(accountId: string, uid: number, bodyPath: string): void;
     /** Get messages without cached bodies (for background prefetch) */
     getMessagesWithoutBody(accountId: string, limit?: number): {
@@ -436,7 +458,7 @@ export declare class MailxDB {
      *  contact can have multiple email addresses, each is its own row). */
     deleteContactByGoogleId(googleId: string): number;
     /** Full-text search across all messages. Supports qualifiers: from:, to:, subject: */
-    searchMessages(query: string, page?: number, pageSize?: number, accountId?: string, folderId?: number): PagedResult<MessageEnvelope>;
+    searchMessages(query: string, page?: number, pageSize?: number, accountId?: string, folderId?: number, includeTrashSpam?: boolean): PagedResult<MessageEnvelope>;
     /** Rebuild FTS index from existing messages */
     rebuildSearchIndex(): number;
     /** Queue a local action for later sync to IMAP */

package/db.js

@@ -488,12 +488,12 @@ export class MailxDB {
                 actual = this.db.prepare(`PRAGMA table_info(${table})`).all();
             }
             catch (e) {
-                throw new Error(`[mailx-store] schema check failed for "${table}": ${e.message}. Run 'mailx -rebuild' to rebuild the local store.`);
+                throw new Error(`[mailx-store] schema check failed for "${table}": ${e.message}. Run 'rmfmail -rebuild' to rebuild the local store.`);
             }
             const names = new Set(actual.map(r => r.name));
             const missing = cols.filter(c => !names.has(c));
             if (missing.length > 0) {
-                throw new Error(`[mailx-store] table "${table}" is missing columns [${missing.join(", ")}] — schema migration did not complete. Run 'mailx -rebuild' to rebuild the local store.`);
+                throw new Error(`[mailx-store] table "${table}" is missing columns [${missing.join(", ")}] — schema migration did not complete. Run 'rmfmail -rebuild' to rebuild the local store.`);
             }
         }
         this.runOneShotJunkContactPurge();
@@ -1321,24 +1321,44 @@ export class MailxDB {
         if (query.flaggedOnly) {
             where += " AND m.flags_json LIKE '%\\\\Flagged%'";
         }
-        const total = this.db.prepare(`SELECT COUNT(*) as cnt
-             FROM messages m
-             JOIN message_folders mf ON mf.message_row_id = m.id
-             WHERE ${where}`).get(...params).cnt;
+        // Same dedup rule as getUnifiedInbox: collapse rows that share a
+        // Message-ID. A list message reflected back to the user via two
+        // self-addresses arrives in INBOX as two rows with identical
+        // Message-IDs; Thunderbird/Outlook show one row, mailx was
+        // showing both. For folders where Message-IDs are naturally
+        // unique (Sent, Drafts) the GROUP BY is a no-op (each row in
+        // its own bucket).
+        const total = this.db.prepare(`SELECT COUNT(*) as cnt FROM (
+                SELECT 1
+                FROM messages m
+                JOIN message_folders mf ON mf.message_row_id = m.id
+                WHERE ${where}
+                GROUP BY CASE WHEN COALESCE(m.message_id, '') = '' THEN 'mid-empty:' || m.id ELSE m.message_id END
+            )`).get(...params).cnt;
         // pending = user has a queued local action against (account, uid).
         // uid here is the membership uid (mf.uid), not m.uid — sync_actions
         // were also keyed against the at-action-time uid, so this match
         // remains stable across server-side moves of the SAME message
         // (the action gets re-targeted to the new uid by the reconciler).
-        const rows = this.db.prepare(`SELECT m.*, mf.uid AS uid, mf.folder_id AS folder_id,
+        const rows = this.db.prepare(`WITH ranked AS (
+                SELECT m.id AS m_id, mf.uid AS mf_uid, mf.folder_id AS mf_folder_id,
+                    ROW_NUMBER() OVER (
+                        PARTITION BY CASE WHEN COALESCE(m.message_id, '') = '' THEN 'mid-empty:' || m.id ELSE m.message_id END
+                        ORDER BY m.date DESC, m.id DESC
+                    ) AS rn
+                FROM messages m
+                JOIN message_folders mf ON mf.message_row_id = m.id
+                WHERE ${where}
+            )
+            SELECT m.*, r.mf_uid AS uid, r.mf_folder_id AS folder_id,
                 EXISTS(
                     SELECT 1 FROM sync_actions sa
-                    WHERE sa.account_id = m.account_id AND sa.uid = mf.uid
+                    WHERE sa.account_id = m.account_id AND sa.uid = r.mf_uid
                 ) AS pending
-            FROM messages m
-            JOIN message_folders mf ON mf.message_row_id = m.id
-            WHERE ${where}
-            ORDER BY ${sortCol} ${sortDir} LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
+            FROM ranked r
+            JOIN messages m ON m.id = r.m_id
+            WHERE r.rn = 1
+            ORDER BY ${sortCol.replace("m.", "m.")} ${sortDir} LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
         const items = rows.map(r => ({
             id: r.id,
             accountId: r.account_id,
@@ -1372,19 +1392,42 @@ export class MailxDB {
             return { items: [], total: 0, page, pageSize };
         const placeholders = inboxRows.map(() => "?").join(",");
         const folderIds = inboxRows.map((r) => r.id);
-        const total = this.db.prepare(`SELECT COUNT(*) as cnt
-             FROM message_folders mf
-             WHERE mf.folder_id IN (${placeholders})`).get(...folderIds).cnt;
-        const rows = this.db.prepare(`SELECT m.*, mf.uid AS uid, mf.folder_id AS folder_id,
+        // Dedup by Message-ID. When a sender includes multiple of the
+        // user's own addresses on the recipient line (mailx@bob.ma +
+        // bobf2@bobf.frankston.com), the local mail server delivers ONE
+        // logical message into the INBOX as N rows — one per to-self
+        // address — all sharing the same Message-ID. Thunderbird/Outlook
+        // dedup these in the inbox view; mailx was showing every copy.
+        // The PARTITION BY collapses duplicates: keep the newest per
+        // Message-ID. Empty Message-IDs (rare; non-RFC senders) are
+        // grouped by row id so each gets its own bucket.
+        const total = this.db.prepare(`SELECT COUNT(*) as cnt FROM (
+                SELECT 1
+                FROM messages m
+                JOIN message_folders mf ON mf.message_row_id = m.id
+                WHERE mf.folder_id IN (${placeholders})
+                GROUP BY CASE WHEN COALESCE(m.message_id, '') = '' THEN 'mid-empty:' || m.id ELSE m.message_id END
+            )`).get(...folderIds).cnt;
+        const rows = this.db.prepare(`WITH ranked AS (
+                SELECT m.id AS m_id, mf.uid AS mf_uid, mf.folder_id AS mf_folder_id,
+                    ROW_NUMBER() OVER (
+                        PARTITION BY CASE WHEN COALESCE(m.message_id, '') = '' THEN 'mid-empty:' || m.id ELSE m.message_id END
+                        ORDER BY m.date DESC, m.id DESC
+                    ) AS rn
+                FROM messages m
+                JOIN message_folders mf ON mf.message_row_id = m.id
+                WHERE mf.folder_id IN (${placeholders})
+            )
+            SELECT m.*, r.mf_uid AS uid, r.mf_folder_id AS folder_id,
                 EXISTS(
                     SELECT 1 FROM sync_actions sa
-                    WHERE sa.account_id = m.account_id AND sa.uid = mf.uid
+                    WHERE sa.account_id = m.account_id AND sa.uid = r.mf_uid
                 ) AS pending,
                 (SELECT COUNT(DISTINCT account_id) FROM messages m2
-                 WHERE m2.message_id = m.message_id AND m.message_id != '') AS dupeCount
-            FROM messages m
-            JOIN message_folders mf ON mf.message_row_id = m.id
-            WHERE mf.folder_id IN (${placeholders})
+                 WHERE m2.message_id = m.message_id AND COALESCE(m.message_id, '') != '') AS dupeCount
+            FROM ranked r
+            JOIN messages m ON m.id = r.m_id
+            WHERE r.rn = 1
             ORDER BY m.date DESC LIMIT ? OFFSET ?`).all(...folderIds, pageSize, offset);
         const items = rows.map(r => ({
             id: r.id,
@@ -1496,10 +1539,77 @@ export class MailxDB {
         const existingTarget = this.db.prepare("SELECT id FROM messages WHERE account_id = ? AND folder_id = ? AND uid = ?").get(accountId, targetFolderId, uid);
         if (existingTarget) {
             this.db.prepare("DELETE FROM messages WHERE account_id = ? AND uid = ? AND folder_id != ?").run(accountId, uid, targetFolderId);
+            // Membership at the source slot also gone — caller didn't pass
+            // sourceFolderId so we can't surgically drop just that one;
+            // delete any mf row whose message_row_id no longer exists.
+            // Practical cases hit this rarely (only when the same uid
+            // already lived at the target).
             return;
         }
         this.db.prepare("UPDATE messages SET folder_id = ? WHERE account_id = ? AND uid = ?").run(targetFolderId, accountId, uid);
     }
+    /** Local-first move of a message between folders. Updates BOTH the
+     *  legacy `messages.folder_id` column AND the `message_folders`
+     *  membership row, so user-visible queries (which join through mf)
+     *  immediately reflect the move. The same uid is preserved on the
+     *  destination side — once the IMAP MOVE drains and reconcile runs,
+     *  the membership uid is rebound to whatever the server assigned in
+     *  the new folder (move-detect by Message-ID does this).
+     *
+     *  Returns true if the message was found and moved, false otherwise.
+     *  Pre-fix `updateMessageFolder` only touched the legacy column, so
+     *  user-visible folder lists (which join through `message_folders`)
+     *  stayed showing the old location until the next reconcile.
+     *  Symptom: drag-to-folder doesn't visually arrive, Ctrl+Z undelete
+     *  doesn't restore until sync. */
+    moveMessageLocal(accountId, uid, fromFolderId, toFolderId) {
+        const row = this.db.prepare(`SELECT m.id AS msgId, mf.id AS mfId
+             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`).get(accountId, uid, fromFolderId);
+        if (!row)
+            return false;
+        // If the destination already has a membership at the same uid for
+        // a DIFFERENT message, our move would conflict with UNIQUE(folder,
+        // uid). Drop the conflicting mf row first — the reconciler will
+        // re-insert if the server still claims that uid for the other
+        // message.
+        const existingAtTarget = this.db.prepare("SELECT message_row_id FROM message_folders WHERE folder_id = ? AND uid = ?").get(toFolderId, uid);
+        if (existingAtTarget && existingAtTarget.message_row_id !== row.msgId) {
+            this.db.prepare("DELETE FROM message_folders WHERE folder_id = ? AND uid = ?")
+                .run(toFolderId, uid);
+        }
+        else if (existingAtTarget && existingAtTarget.message_row_id === row.msgId) {
+            // Already in the destination — drop the source mf and update
+            // the legacy column. No-op move otherwise.
+            this.db.prepare("DELETE FROM message_folders WHERE id = ?").run(row.mfId);
+            this.db.prepare("UPDATE messages SET folder_id = ? WHERE id = ?")
+                .run(toFolderId, row.msgId);
+            return true;
+        }
+        this.db.prepare("UPDATE message_folders SET folder_id = ? WHERE id = ?").run(toFolderId, row.mfId);
+        this.db.prepare("UPDATE messages SET folder_id = ? WHERE id = ?").run(toFolderId, row.msgId);
+        return true;
+    }
+    /** Find a pending sync action by its identifying fields. Used by the
+     *  undelete path to detect "is the to-trash MOVE still queued?" — if
+     *  yes, cancelling it (completeSyncAction) is enough to undelete; the
+     *  server never sees the move. */
+    findPendingSyncAction(accountId, action, uid, folderId, targetFolderId) {
+        const sql = targetFolderId !== undefined
+            ? `SELECT id FROM sync_actions
+               WHERE account_id = ? AND action = ? AND uid = ? AND folder_id = ? AND target_folder_id = ?
+               LIMIT 1`
+            : `SELECT id FROM sync_actions
+               WHERE account_id = ? AND action = ? AND uid = ? AND folder_id = ?
+               LIMIT 1`;
+        const params = targetFolderId !== undefined
+            ? [accountId, action, uid, folderId, targetFolderId]
+            : [accountId, action, uid, folderId];
+        const r = this.db.prepare(sql).get(...params);
+        return r || null;
+    }
     updateBodyPath(accountId, uid, bodyPath) {
         this.db.prepare("UPDATE messages SET body_path = ? WHERE account_id = ? AND uid = ?").run(bodyPath, accountId, uid);
     }
@@ -2051,7 +2161,7 @@ export class MailxDB {
     }
     // ── Search ──
     /** Full-text search across all messages. Supports qualifiers: from:, to:, subject: */
-    searchMessages(query, page = 1, pageSize = 50, accountId, folderId) {
+    searchMessages(query, page = 1, pageSize = 50, accountId, folderId, includeTrashSpam = false) {
         query = (query || "").trim();
         // Parse qualifiers (C45: extended set — date:, has:, is:, folder:).
         let ftsQuery = "";
@@ -2179,11 +2289,22 @@ export class MailxDB {
                 scopeWhere = " AND m.account_id = ?";
                 scopeParams.push(accountId);
             }
+            // Global / account-wide search excludes trash + junk unless the
+            // user opted in. A user typing "invoice" in the search box almost
+            // never wants the deleted/spam copy that's already filtered out
+            // of every other view. When the user IS explicitly scoped to
+            // trash/junk via folderId, this guard is skipped.
+            if (!includeTrashSpam && !folderId) {
+                scopeWhere += " AND (f.special_use IS NULL OR f.special_use NOT IN ('trash','junk'))";
+            }
             if (extraWhere.length > 0) {
                 scopeWhere += " AND " + extraWhere.join(" AND ");
                 scopeParams.push(...extraParams);
             }
-            const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages m JOIN messages_fts fts ON m.id = fts.rowid WHERE messages_fts MATCH ?${scopeWhere}`).get(ftsQuery, ...scopeParams);
+            const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM messages m
+                 JOIN messages_fts fts ON m.id = fts.rowid
+                 LEFT JOIN folders f ON f.id = m.folder_id AND f.account_id = m.account_id
+                 WHERE messages_fts MATCH ?${scopeWhere}`).get(ftsQuery, ...scopeParams);
             const total = countRow?.cnt || 0;
             const rows = this.db.prepare(`SELECT m.*, f.name AS folder_name FROM messages m
                  JOIN messages_fts fts ON m.id = fts.rowid

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,7 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.10",
-    "@bobfrankston/mailx-settings": "^0.1.13"
+    "@bobfrankston/mailx-settings": "^0.1.14"
   },
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.10",
-      "@bobfrankston/mailx-settings": "^0.1.13"
+      "@bobfrankston/mailx-settings": "^0.1.14"
     }
   }
 }