@bobfrankston/mailx-store 0.1.15 → 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): {

package/db.js

@@ -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);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-store",
-  "version": "0.1.15",
+  "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"
     }
   }
 }