@bobfrankston/rmfmail 1.2.4 → 1.2.5

package/packages/mailx-imap/index.js

@@ -408,6 +408,152 @@ export class ImapManager extends EventEmitter {
     async createPublicClient(accountId) {
         return this.createClient(accountId);
     }
+    // ── Server-side folder operations ──────────────────────────────────────
+    // These run the IMAP folder mutation AND the local folder-table write here
+    // (on whatever thread ImapManager lives — the sync worker), so the service
+    // never needs a live IMAP client object across the worker boundary. The
+    // service keeps the surrounding UX (path computation, error messaging); it
+    // calls these for the actual server+folder-row work. Returns are primitive
+    // so they cross the bus cleanly.
+    /** Create `fullPath` on the server, upsert the local folder row, re-sync
+     *  the folder list, and report whether the folder actually exists after. */
+    async createFolderViaServer(accountId, fullPath, name, delimiter) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            await client.createmailbox(fullPath);
+            this.db.upsertFolder(accountId, fullPath, name, null, delimiter);
+            await this.syncFolders(accountId, client);
+            return this.db.getFolders(accountId).some(f => f.path === fullPath);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Rename `oldPath` → `newPath` on the server and re-sync folders. */
+    async renameFolderViaServer(accountId, oldPath, newPath) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            if (client.renameMailbox)
+                await client.renameMailbox(oldPath, newPath);
+            else
+                await client.withConnection(async () => { await client.client.mailboxRename(oldPath, newPath); });
+            await this.syncFolders(accountId, client);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Delete `path` on the server (tolerating already-gone). Local folder-row
+     *  removal stays with the caller (it knows the folderId). */
+    async deleteFolderViaServer(accountId, path) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            try {
+                if (client.deleteMailbox)
+                    await client.deleteMailbox(path);
+                else
+                    await client.withConnection(async () => { await client.client.mailboxDelete(path); });
+            }
+            catch (e) {
+                const msg = String(e?.message || e || "").toLowerCase();
+                if (!/nonexistent|does not exist|no such|not found|404/i.test(msg))
+                    throw e;
+                console.log(`  [folder] ${accountId} delete "${path}": server says already gone`);
+            }
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Expunge every message in `path` on the server. */
+    async emptyFolderViaServer(accountId, path) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            const uids = await client.getUids(path);
+            for (const uid of uids)
+                await client.deleteMessageByUid(path, uid);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    /** Move a folder into Trash by IMAP RENAME, falling back to spilling its
+     *  messages into Trash root + deleting the empty folder when the server
+     *  forbids nesting under Trash. Self-contained on the worker. */
+    async moveFolderToTrashViaServer(accountId, folderId, folderPath, targetPath, trashId, trashPath, delim) {
+        const client = await this.createPublicClient(accountId);
+        try {
+            try {
+                if (client.renameMailbox)
+                    await client.renameMailbox(folderPath, targetPath);
+                else
+                    await client.withConnection(async () => { await client.client.mailboxRename(folderPath, targetPath); });
+                console.log(`  [folder] ${accountId} moved "${folderPath}" → "${targetPath}"`);
+            }
+            catch (e) {
+                const msg = String(e?.message || e || "").toLowerCase();
+                if (!/noinferiors|hierarchy|invalid (mailbox )?name|cannot rename|inferiors/i.test(msg))
+                    throw e;
+                console.log(`  [folder] ${accountId} cannot RENAME under Trash; spilling messages`);
+                await this.spillFolderToTrashServer(accountId, folderId, folderPath, trashId, trashPath, delim, client);
+            }
+            await this.syncFolders(accountId, client);
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* */ }
+        }
+    }
+    async spillFolderToTrashServer(accountId, folderId, folderPath, trashId, trashPath, delim, client) {
+        // Children first so the parent ends up empty.
+        const childPrefix = folderPath + delim;
+        const children = this.db.getFolders(accountId).filter(f => f.path.startsWith(childPrefix));
+        for (const child of children) {
+            await this.spillFolderToTrashServer(accountId, child.id, child.path, trashId, trashPath, delim, client);
+        }
+        // Move each message to Trash on the server, then mirror locally.
+        const uids = await client.getUids(folderPath).catch(() => []);
+        for (const uid of uids) {
+            try {
+                if (client.moveMessage)
+                    await client.moveMessage(folderPath, trashPath, uid);
+                else {
+                    await client.copyMessage(folderPath, trashPath, uid);
+                    await client.deleteMessageByUid(folderPath, uid);
+                }
+                this.store.trashMessage(accountId, uid, folderId, trashId);
+            }
+            catch (e) {
+                console.error(`  [folder] spill uid ${uid}: ${e?.message || e}`);
+            }
+        }
+        try {
+            if (client.deleteMailbox)
+                await client.deleteMailbox(folderPath);
+            else
+                await client.withConnection(async () => { await client.client.mailboxDelete(folderPath); });
+        }
+        catch (e) {
+            const m = String(e?.message || e || "").toLowerCase();
+            if (!/nonexistent|does not exist|no such/.test(m))
+                throw e;
+        }
+        this.db.deleteFolder(folderId);
+    }
     // Legacy fallback disabled — was doubling connections without helping.
     // To re-enable: uncomment legacyFallbacks logic in createClient and _syncAll.
     // private legacyFallbacks = new Set<string>();