emailengine-app 2.69.0 → 2.71.0

package/lib/email-client/outlook-client.js

@@ -910,23 +910,35 @@ class OutlookClient extends BaseClient {
 
         let folder;
         if (!force) {
-            try {
-                folder = await this.resolveFolder('\\Trash');
-
-                // If we're already in trash, force delete
-                if (!force && folder?.specialUse === '\\Trash') {
-                    force = true;
-                }
+            // Fetch the listing once for both folder resolutions
+            let mailboxListing = (await this.getCachedMailboxListing()) || (await this.getMailboxListing());
 
-                if (!force && !folder) {
-                    throw new Error('Trash folder was not found');
-                }
+            // If the source folder is already the Trash folder, delete permanently
+            let sourceFolder;
+            try {
+                sourceFolder = await this.resolveFolder(path, { mailboxListing });
             } catch (err) {
                 this.logger.error({
-                    msg: 'Failed to resolve folder for Trash',
+                    msg: 'Failed to resolve source folder',
+                    path,
                     err
                 });
             }
+
+            if (sourceFolder?.specialUse === '\\Trash') {
+                force = true;
+            } else {
+                folder = await this.resolveFolder('\\Trash', { mailboxListing });
+                if (!folder) {
+                    let error = new Error('Trash folder was not found');
+                    error.info = {
+                        response: 'Failed to resolve the Trash folder for the account'
+                    };
+                    error.code = 'TrashNotFound';
+                    error.statusCode = 404;
+                    throw error;
+                }
+            }
         }
 
         // Step 1. Resolve matching messages
@@ -1049,27 +1061,15 @@ class OutlookClient extends BaseClient {
     }
 
     /**
-     * Update message flags (Graph API only supports \Seen and \Flagged)
+     * Converts an IMAP-style flag update request into Graph API message properties.
+     * Only \Seen and \Flagged can be represented in the Graph API. Set precedence is
+     * handled by BaseClient#normalizeFlagUpdates.
+     * @param {Object} [flags] - Flag update request ({ add, delete, set })
+     * @returns {Object} Graph API PATCH properties ({ isRead, flag })
      */
-    async updateMessage(emailId, updates) {
-        await this.prepare();
-        updates = updates || {};
-
-        let addFlags = updates.flags?.add || [];
-        let deleteFlags = updates.flags?.delete || [];
-
-        // Handle flag set operations
-        if (updates.flags?.set) {
-            for (let flag of ['\\Seen', '\\Flagged']) {
-                if (updates.flags.set.includes(flag)) {
-                    addFlags.push(flag);
-                } else {
-                    deleteFlags.push(flag);
-                }
-            }
-        }
+    buildFlagUpdates(flags) {
+        let { add: addFlags, delete: deleteFlags } = this.normalizeFlagUpdates(flags, ['\\Seen', '\\Flagged']);
 
-        // Map IMAP flags to Graph API properties
         let flagUpdates = {};
 
         if (addFlags.includes('\\Seen')) {
@@ -1086,6 +1086,19 @@ class OutlookClient extends BaseClient {
             flagUpdates.flag = { flagStatus: 'notFlagged' };
         }
 
+        return flagUpdates;
+    }
+
+    /**
+     * Update message flags (Graph API only supports \Seen and \Flagged)
+     */
+    async updateMessage(emailId, updates) {
+        await this.prepare();
+        updates = updates || {};
+
+        // Map IMAP flags to Graph API properties
+        let flagUpdates = this.buildFlagUpdates(updates.flags);
+
         // Handle label (category) operations
         if (updates.labels) {
             let categories;
@@ -1178,36 +1191,8 @@ class OutlookClient extends BaseClient {
 
         updates = updates || {};
 
-        let addFlags = updates.flags?.add || [];
-        let deleteFlags = updates.flags?.delete || [];
-
-        // Handle flag set operations
-        if (updates.flags?.set) {
-            for (let flag of ['\\Seen', '\\Flagged']) {
-                if (updates.flags.set.includes(flag)) {
-                    addFlags.push(flag);
-                } else {
-                    deleteFlags.push(flag);
-                }
-            }
-        }
-
         // Map IMAP flags to Graph API properties
-        let flagUpdates = {};
-
-        if (addFlags.includes('\\Seen')) {
-            flagUpdates.isRead = true;
-        }
-        if (deleteFlags.includes('\\Seen')) {
-            flagUpdates.isRead = false;
-        }
-
-        if (addFlags.includes('\\Flagged')) {
-            flagUpdates.flag = { flagStatus: 'flagged' };
-        }
-        if (deleteFlags.includes('\\Flagged')) {
-            flagUpdates.flag = { flagStatus: 'notFlagged' };
-        }
+        let flagUpdates = this.buildFlagUpdates(updates.flags);
 
         // Step 1. Resolve matching messages
         let emailIds = search.emailIds || (await this.searchEmailIds(path, search));
@@ -1579,7 +1564,7 @@ class OutlookClient extends BaseClient {
 
         const contentResponse = {
             headers: {
-                'content-type': attachmentData.mimeType || 'application/octet-stream',
+                'content-type': attachmentData.contentType || 'application/octet-stream',
                 'content-disposition': 'attachment' + filenameParam
             },
             contentType: attachmentData.contentType,
@@ -3178,8 +3163,9 @@ class OutlookClient extends BaseClient {
 
         path = [].concat(path || []).join('/');
 
-        let cachedListing = await this.getCachedMailboxListing();
-        let mailboxListing = cachedListing || (await this.getMailboxListing());
+        // Callers that resolve multiple folders can pass a pre-fetched listing to avoid
+        // repeated cache reads or Graph API folder crawls
+        let mailboxListing = options.mailboxListing || (await this.getCachedMailboxListing()) || (await this.getMailboxListing());
 
         if (options.byId) {
             return mailboxListing.find(entry => entry.id === path);
@@ -3749,6 +3735,7 @@ class OutlookClient extends BaseClient {
             bcc: extended && messageData.bccRecipients?.length ? messageData.bccRecipients.map(entry => entry.emailAddress).filter(entry => entry) : undefined,
 
             messageId: messageData.internetMessageId,
+            inReplyTo: messageData.inReplyTo || undefined,
 
             headers: (extended && messageData.headers) || undefined,
 

package/lib/export.js

@@ -66,6 +66,50 @@ function createError(message, code, statusCode) {
     return err;
 }
 
+// Error classifiers used by the export worker to decide between retrying, skipping a single
+// message, or failing the whole export job.
+
+function isTransientError(err) {
+    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE', 'EHOSTUNREACH'].includes(err.code)) {
+        return true;
+    }
+    if (err.statusCode >= 500 && err.statusCode < 600) {
+        return true;
+    }
+    if (err.code === 'Timeout' || err.message?.includes('timeout')) {
+        return true;
+    }
+    return false;
+}
+
+// Account.assertMessageFound reports a missing message as a Boom 404 that carries the
+// machine-readable code and status only in err.output, while client/RPC errors set plain
+// err.code/err.statusCode - check both shapes
+function isSkippableError(err) {
+    let errCode = err.output?.payload?.code || err.code;
+    let statusCode = err.statusCode || err.output?.statusCode;
+    return errCode === 'MessageNotFound' || statusCode === 404 || err.message?.includes('Failed to generate message ID');
+}
+
+// Account.listMessages reports unknown folders as FolderNotFound (Boom error with the code in
+// the payload), the Gmail and Outlook backends throw NotFound directly. Outlook bulk delete can
+// also throw TrashNotFound, but the export worker never deletes messages, so it is not matched.
+function isFolderMissingError(err) {
+    let errCode = err.output?.payload?.code || err.code;
+    return ['FolderNotFound', 'NotFound'].includes(errCode);
+}
+
+// Per-message errors worth retrying during a batch export: rate limits, a dropped batch response
+// (Outlook reports these as EMISSING_RESPONSE), and the same transient network/5xx/timeout errors
+// isTransientError already covers. Used by the export worker's API-account batch fetch path so a
+// single transient blip does not fail an entire multi-message export.
+function isRetryableError(err) {
+    if (err.statusCode === 429 || ['rateLimitExceeded', 'userRateLimitExceeded', 'EMISSING_RESPONSE'].includes(err.code)) {
+        return true;
+    }
+    return isTransientError(err);
+}
+
 async function tryAddToActiveSet(account, exportId) {
     const maxConcurrent = (await settings.get('exportMaxConcurrent')) || DEFAULT_EXPORT_MAX_CONCURRENT;
     const maxGlobalConcurrent = (await settings.get('exportMaxGlobalConcurrent')) || DEFAULT_EXPORT_MAX_GLOBAL_CONCURRENT;
@@ -493,7 +537,7 @@ class Export {
                     continue;
                 }
 
-                if (data && (data.status === 'processing' || data.status === 'queued' || data.status === 'indexing' || data.status === 'cancelled')) {
+                if (data && (data.status === 'processing' || data.status === 'queued' || data.status === 'cancelled')) {
                     const job = await exportQueue.getJob(exportId).catch(() => null);
                     if (job) {
                         await job.remove().catch(() => {});
@@ -582,5 +626,9 @@ module.exports = {
     getExportQueueKey,
     getExportPath,
     getExportMaxAge,
+    isTransientError,
+    isSkippableError,
+    isFolderMissingError,
+    isRetryableError,
     DEFAULT_EXPORT_MAX_MESSAGE_SIZE
 };

package/lib/feature-flags.js

@@ -21,11 +21,11 @@ for (let key of Object.keys(process.env)) {
     if (/^EENGINE_FEATURE_/i.test(key)) {
         let feature = formatFeatureKey(key.substring('EENGINE_FEATURE_'.length));
         if (feature) {
-            let value = /^y|1|t/i.test((process.env[key] || '').toString().trim());
+            let value = /^(y|yes|true|t|1)$/i.test((process.env[key] || '').toString().trim());
             if (value) {
                 FEATURES.add(feature);
             } else {
-                FEATURES.remove(feature);
+                FEATURES.delete(feature);
             }
         }
     }
@@ -34,6 +34,12 @@ for (let key of Object.keys(process.env)) {
 module.exports = {
     enabled(key) {
         return FEATURES.has(formatFeatureKey(key));
+    },
+
+    // Sorted list of the currently enabled feature flag keys. Used by the license beacon
+    // to report which EENGINE_FEATURE_* flags are active on this instance.
+    listEnabled() {
+        return Array.from(FEATURES).sort();
     }
 };
 

package/lib/gateway.js

@@ -179,13 +179,8 @@ class Gateway {
             throw error;
         }
 
-        let state = false;
-        if (result[0][1] && result[0][1].gateway) {
-            // existing user
-            state = 'existing';
-        } else {
-            state = 'new';
-        }
+        // HGET returns the previous value if the gateway entry already existed
+        let state = result[0][1] ? 'existing' : 'new';
 
         return { gateway: this.gateway, state };
     }
@@ -243,7 +238,7 @@ class Gateway {
         let result = await this.redis.multi().del(this.getGatewayKey()).srem(`${REDIS_PREFIX}gateways`, this.gateway).exec();
         if (!result) {
             return {
-                account: this.account,
+                gateway: this.gateway,
                 deleted: false
             };
         }
@@ -256,7 +251,7 @@ class Gateway {
 
         if (!result[0] || !result[0][1]) {
             return {
-                account: this.account,
+                gateway: this.gateway,
                 deleted: false
             };
         }

package/lib/get-raw-email.js

@@ -229,15 +229,15 @@ async function processMessage(data, licenseInfo) {
         }
 
         if (data.headers) {
-            for (let key of Object.keys(headers)) {
+            for (let key of Object.keys(data.headers)) {
                 let casedKey = key.replace(/^.|-./g, c => c.toUpperCase());
-                switch (key) {
+                switch (key.toLowerCase()) {
                     case 'in-reply-to':
                     case 'references':
-                        headers.update(casedKey, headers[key]);
+                        headers.update(casedKey, data.headers[key]);
                         break;
                     default:
-                        headers.add(casedKey, headers[key]);
+                        headers.add(casedKey, data.headers[key]);
                         break;
                 }
             }
@@ -266,7 +266,7 @@ async function processMessage(data, licenseInfo) {
     });
 
     let trackClicks = typeof data.trackClicks === 'boolean' ? data.trackClicks : trackingEnabled;
-    let trackOpens = typeof data.trackOpens === 'boolean' ? data.trackClicks : trackingEnabled;
+    let trackOpens = typeof data.trackOpens === 'boolean' ? data.trackOpens : trackingEnabled;
 
     return {
         raw: message,

package/lib/imapproxy/imap-core/lib/imap-connection.js

@@ -860,7 +860,6 @@ class IMAPConnection extends EventEmitter {
         if (existsResponse && !changed) {
             // send cached EXISTS response
             this.writeStream.write(existsResponse);
-            existsResponse = false;
         }
 
         if (changed) {