@bobfrankston/mailx-imap 0.1.32 → 0.1.34

package/index.d.ts

@@ -398,7 +398,18 @@ export declare class ImapManager extends EventEmitter {
     moveMessage(accountId: string, uid: number, fromFolderId: number, toFolderId: number): Promise<void>;
     /** Move message across accounts using iflow's moveMessageToServer */
     moveMessageCrossAccount(fromAccountId: string, uid: number, fromFolderId: number, toAccountId: string, toFolderId: number): Promise<void>;
-    /** Undelete — move from Trash back to original folder */
+    /** Undelete — move from Trash back to original folder. Local-first:
+     *  the row was moved (not deleted) on trash, so we just move it back
+     *  in the local DB and reconcile the IMAP queue. Two cases:
+     *    (a) the to-trash MOVE is still pending — cancel it; the server
+     *        never saw the delete, so no counter-action is needed.
+     *    (b) the to-trash MOVE drained — the message is now in Trash on
+     *        the server with a new uid. Queue a counter-move from
+     *        trash → original. The IMAP processor's fetchByUid in trash
+     *        will use the local membership uid (which the reconciler
+     *        rebound to the server's new trash uid via Message-ID match).
+     *        If reconcile hasn't run yet (unlikely race), action retries
+     *        until it does. */
     undeleteMessage(accountId: string, uid: number, originalFolderId: number): Promise<void>;
     /** Update flags — local-first, queues IMAP sync */
     updateFlagsLocal(accountId: string, uid: number, folderId: number, flags: string[]): Promise<void>;

package/index.js

@@ -943,6 +943,9 @@ export class ImapManager extends EventEmitter {
         const parsed = await simpleParser(source);
         // Coerce mailparser AddressObject(s) into the flat `{name, address}[]`
         // shape storeMessages's downstream toEmailAddresses expects.
+        // RFC 2047 encoded-word decoding (incl. inside quoted-strings) is
+        // handled uniformly in db.upsertMessage, not per-callsite — see
+        // `decodeHeaderWords` there.
         const flat = (a) => {
             if (!a)
                 return [];
@@ -2696,12 +2699,24 @@ export class ImapManager extends EventEmitter {
         if (messages.length === 0)
             return;
         const trash = this.findFolder(accountId, "trash");
-        // Local first — remove all from DB immediately
+        // Local first — move to trash folder locally so the row stays
+        // visible in Trash and Ctrl+Z can restore it. Body file stays in
+        // its original folder dir; the next sync rebinds path on
+        // membership uid change. Old behavior was `db.deleteMessage` +
+        // `unlinkBodyFile` which made undelete impossible (no row to
+        // restore, no body to read). For folders that ARE the trash
+        // already, fall through to hard delete (the action will EXPUNGE
+        // and reconciliation cleans up).
         for (const msg of messages) {
-            this.unlinkBodyFile(accountId, msg.uid, msg.folderId).catch(() => { });
-            this.db.deleteMessage(accountId, msg.uid, "user-initiated delete (bulk)", "mailx-imap deleteMessages");
+            if (trash && trash.id !== msg.folderId) {
+                this.db.moveMessageLocal(accountId, msg.uid, msg.folderId, trash.id);
+            }
+            else {
+                this.unlinkBodyFile(accountId, msg.uid, msg.folderId).catch(() => { });
+                this.db.deleteMessage(accountId, msg.uid, "user-initiated trash (already in trash → expunge)", "mailx-imap trashMessages");
+            }
         }
-        console.log(`  Deleted ${messages.length} messages locally`);
+        console.log(`  Trashed ${messages.length} messages locally (moved to trash folder, body files retained)`);
         // Queue IMAP actions
         for (const msg of messages) {
             if (trash && trash.id !== msg.folderId) {
@@ -2750,9 +2765,17 @@ export class ImapManager extends EventEmitter {
     /** Move a message to Trash (delete) — local-first, queues IMAP sync */
     async trashMessage(accountId, folderId, uid) {
         const trash = this.findFolder(accountId, "trash");
-        // Local first — remove from DB immediately
-        this.unlinkBodyFile(accountId, uid, folderId).catch(() => { });
-        this.db.deleteMessage(accountId, uid, "user-initiated trash", "mailx-imap trashMessage");
+        // Local first — move to trash folder so the row stays visible in
+        // Trash and Ctrl+Z can restore. Body file retained for undelete.
+        // If we're already in trash (or no trash configured), fall through
+        // to hard delete + EXPUNGE.
+        if (trash && trash.id !== folderId) {
+            this.db.moveMessageLocal(accountId, uid, folderId, trash.id);
+        }
+        else {
+            this.unlinkBodyFile(accountId, uid, folderId).catch(() => { });
+            this.db.deleteMessage(accountId, uid, "user-initiated trash (already in trash → expunge)", "mailx-imap trashMessage");
+        }
         // Queue IMAP action + log the resolution so "I deleted a message and
         // now it's in neither trash nor deleted" is diagnosable from the log.
         if (trash && trash.id !== folderId) {
@@ -2764,6 +2787,12 @@ export class ImapManager extends EventEmitter {
             this.db.queueSyncAction(accountId, "delete", uid, folderId);
             console.log(`  [trash] ${accountId} UID ${uid}: queued EXPUNGE in folder ${folderId} (already in trash or no trash configured)`);
         }
+        // Folder counts moved — refresh both source and trash so the
+        // tree badges update immediately, not at the next sync.
+        this.db.recalcFolderCounts(folderId);
+        if (trash && trash.id !== folderId)
+            this.db.recalcFolderCounts(trash.id);
+        this.emit("folderCountsChanged", accountId, {});
         // Debounced sync — batches multiple deletes into one IMAP session
         this.debounceSyncActions(accountId);
     }
@@ -2799,12 +2828,40 @@ export class ImapManager extends EventEmitter {
             });
         });
     }
-    /** Undelete — move from Trash back to original folder */
+    /** Undelete — move from Trash back to original folder. Local-first:
+     *  the row was moved (not deleted) on trash, so we just move it back
+     *  in the local DB and reconcile the IMAP queue. Two cases:
+     *    (a) the to-trash MOVE is still pending — cancel it; the server
+     *        never saw the delete, so no counter-action is needed.
+     *    (b) the to-trash MOVE drained — the message is now in Trash on
+     *        the server with a new uid. Queue a counter-move from
+     *        trash → original. The IMAP processor's fetchByUid in trash
+     *        will use the local membership uid (which the reconciler
+     *        rebound to the server's new trash uid via Message-ID match).
+     *        If reconcile hasn't run yet (unlikely race), action retries
+     *        until it does. */
     async undeleteMessage(accountId, uid, originalFolderId) {
         const trash = this.findFolder(accountId, "trash");
         if (!trash)
             throw new Error("No Trash folder found");
-        await this.moveMessage(accountId, uid, trash.id, originalFolderId);
+        // Move locally back to the original folder.
+        const moved = this.db.moveMessageLocal(accountId, uid, trash.id, originalFolderId);
+        if (!moved) {
+            console.log(`  [undelete] ${accountId} UID ${uid}: no row in trash — nothing to restore locally (sync may have already pruned)`);
+        }
+        // (a) cancel still-pending to-trash action.
+        const pending = this.db.findPendingSyncAction(accountId, "move", uid, originalFolderId, trash.id);
+        if (pending) {
+            this.db.completeSyncAction(pending.id);
+            console.log(`  [undelete] ${accountId} UID ${uid}: cancelled pending MOVE to trash (server never saw delete)`);
+            this.emit("folderCountsChanged", accountId, {});
+            return;
+        }
+        // (b) queue counter-move from trash → original.
+        this.db.queueSyncAction(accountId, "move", uid, trash.id, { targetFolderId: originalFolderId });
+        console.log(`  [undelete] ${accountId} UID ${uid}: queued counter-MOVE trash → folder ${originalFolderId}`);
+        this.debounceSyncActions(accountId);
+        this.emit("folderCountsChanged", accountId, {});
     }
     /** Update flags — local-first, queues IMAP sync */
     async updateFlagsLocal(accountId, uid, folderId, flags) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
@@ -10,8 +10,8 @@
   "license": "ISC",
   "dependencies": {
     "@bobfrankston/mailx-types": "^0.1.10",
-    "@bobfrankston/mailx-settings": "^0.1.13",
-    "@bobfrankston/mailx-store": "^0.1.15",
+    "@bobfrankston/mailx-settings": "^0.1.14",
+    "@bobfrankston/mailx-store": "^0.1.16",
     "@bobfrankston/iflow-direct": "^0.1.39",
     "@bobfrankston/tcp-transport": "^0.1.6",
     "@bobfrankston/smtp-direct": "^0.1.8",
@@ -38,8 +38,8 @@
   ".transformedSnapshot": {
     "dependencies": {
       "@bobfrankston/mailx-types": "^0.1.10",
-      "@bobfrankston/mailx-settings": "^0.1.13",
-      "@bobfrankston/mailx-store": "^0.1.15",
+      "@bobfrankston/mailx-settings": "^0.1.14",
+      "@bobfrankston/mailx-store": "^0.1.16",
       "@bobfrankston/iflow-direct": "^0.1.39",
       "@bobfrankston/tcp-transport": "^0.1.6",
       "@bobfrankston/smtp-direct": "^0.1.8",