emailengine-app 2.69.0 → 2.70.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,39 @@ 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);
+}
+
 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 +526,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 +615,8 @@ module.exports = {
     getExportQueueKey,
     getExportPath,
     getExportMaxAge,
+    isTransientError,
+    isSkippableError,
+    isFolderMissingError,
     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);
             }
         }
     }

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) {

package/lib/logger.js

@@ -19,22 +19,13 @@ let logger = pino({
         log(object) {
             if (object.err && ['TypeError', 'RangeError'].includes(object.err.name)) {
                 if (logger.notifyError) {
-                    logger.notifyError(object.err, event => {
-                        if (object.account) {
-                            event.setUser(object.account);
+                    let meta = {};
+                    for (let key of ['msg', 'path', 'cid']) {
+                        if (object[key]) {
+                            meta[key] = object[key];
                         }
-                        let meta = {};
-                        let hasMeta = false;
-                        for (let key of ['msg', 'path', 'cid']) {
-                            if (object[key]) {
-                                meta[key] = object[key];
-                                hasMeta = true;
-                            }
-                        }
-                        if (hasMeta) {
-                            event.addMetadata('ee', meta);
-                        }
-                    });
+                    }
+                    logger.notifyError(object.err, { user: object.account, meta });
                 }
             }
             return object;
@@ -49,6 +40,22 @@ if (threadId) {
     logger = logger.child({ tid: threadId });
 }
 
+// An error that reaches the global handlers leaves the process in an unknown state,
+// so the process must always exit. If error tracking is enabled, report the error
+// first and allow a short flush window for the delivery.
+function fatalShutdown(code, err) {
+    if (logger.notifyError) {
+        logger.notifyError(err);
+    }
+
+    let exit = () => process.exit(code);
+    if (logger.flushNotifications) {
+        logger.flushNotifications().then(exit, exit);
+    } else {
+        setTimeout(exit, 10);
+    }
+}
+
 process.on('uncaughtException', err => {
     logger.fatal({
         msg: 'uncaughtException',
@@ -56,9 +63,7 @@ process.on('uncaughtException', err => {
         err
     });
 
-    if (!logger.notifyError) {
-        setTimeout(() => process.exit(1), 10);
-    }
+    fatalShutdown(1, err);
 });
 
 process.on('unhandledRejection', err => {
@@ -68,9 +73,7 @@ process.on('unhandledRejection', err => {
         err
     });
 
-    if (!logger.notifyError) {
-        setTimeout(() => process.exit(2), 10);
-    }
+    fatalShutdown(2, err);
 });
 
 module.exports = logger;

package/lib/metrics-collector.js

@@ -91,8 +91,6 @@ class MetricsCollector {
      * Collect metrics in background (sequential to avoid CPU spikes)
      */
     async collectInBackground() {
-        const startTime = Date.now();
-
         // Start with main thread info
         let threadsInfo = [
             Object.assign(

package/lib/oauth2-apps.js

@@ -339,10 +339,6 @@ class OAuth2AppsHandler {
             apps: []
         };
 
-        if (idList.length <= startPos) {
-            return response;
-        }
-
         //let keys = idList.slice(startPos, startPos + pageSize);
         let keys = idList;
 
@@ -406,6 +402,8 @@ class OAuth2AppsHandler {
             });
         }
 
+        // Recount after undecodable entries were skipped and query filters were applied
+        response.total = response.apps.length;
         response.pages = Math.ceil(response.apps.length / pageSize);
         response.apps = response.apps.slice(startPos, startPos + pageSize);
 
@@ -747,6 +745,17 @@ class OAuth2AppsHandler {
 
     async update(id, data, opts) {
         opts = opts || {};
+
+        // `tenant` is a UI-style alias for an Outlook directory tenant ID. Only honor it when
+        // the caller explicitly selected it via authority='tenant' (the UI form convention) -
+        // a stray tenant value alone must not overwrite the stored authority.
+        if (data && typeof data === 'object' && 'tenant' in data) {
+            if (data.tenant && data.authority === 'tenant') {
+                data.authority = data.tenant;
+            }
+            delete data.tenant;
+        }
+
         if (LEGACY_KEYS.includes(id)) {
             // legacy
             return await this.updateLegacyApp(id, data);

package/lib/outbox.js

@@ -3,6 +3,28 @@
 const { submitQueue, redis } = require('./db');
 const { REDIS_PREFIX } = require('../lib/consts');
 
+function formatQueueEntry(job) {
+    let scheduled = job.timestamp + (Number(job.opts.delay) || 0);
+
+    let backoffDelay = Number(job.opts.backoff && job.opts.backoff.delay) || 0;
+    // attemptsMade already includes the failed attempt, so the retry delay is 2^(attemptsMade-1) * base
+    let nextAttempt = job.attemptsMade ? Math.round(job.processedOn + Math.pow(2, job.attemptsMade - 1) * backoffDelay) : scheduled;
+
+    if (job.opts.attempts <= job.attemptsMade) {
+        nextAttempt = false;
+    }
+
+    return Object.assign(job.data, {
+        created: new Date(Number(job.data.created || job.timestamp)).toISOString(),
+        //status: job.name,
+        progress: job.progress,
+        attemptsMade: job.attemptsMade,
+        attempts: job.opts.attempts,
+        scheduled: new Date(scheduled).toISOString(),
+        nextAttempt: nextAttempt ? new Date(nextAttempt).toISOString() : false
+    });
+}
+
 async function list(options) {
     options = options || {};
     let page = Number(options.page) || 0;
@@ -23,26 +45,7 @@ async function list(options) {
         try {
             let job = await submitQueue.getJob(jobId);
             if (job) {
-                let scheduled = job.timestamp + (Number(job.opts.delay) || 0);
-
-                let backoffDelay = Number(job.opts.backoff && job.opts.backoff.delay) || 0;
-                let nextAttempt = job.attemptsMade ? Math.round(job.processedOn + Math.pow(2, job.attemptsMade) * backoffDelay) : scheduled;
-
-                if (job.opts.attempts <= job.attemptsMade) {
-                    nextAttempt = false;
-                }
-
-                messages.push(
-                    Object.assign(job.data, {
-                        created: new Date(Number(job.created || job.timestamp)).toISOString(),
-                        //status: job.name,
-                        progress: job.progress,
-                        attemptsMade: job.attemptsMade,
-                        attempts: job.opts.attempts,
-                        scheduled: new Date(scheduled).toISOString(),
-                        nextAttempt: nextAttempt ? new Date(nextAttempt).toISOString() : false
-                    })
-                );
+                messages.push(formatQueueEntry(job));
             }
         } catch (err) {
             logger.error({ msg: 'Failed to retrieve message info from outbox', jobId, err });
@@ -105,15 +108,6 @@ async function get(options) {
         return false;
     }
 
-    let scheduled = job.timestamp + (Number(job.opts.delay) || 0);
-
-    let backoffDelay = Number(job.opts.backoff && job.opts.backoff.delay) || 0;
-    let nextAttempt = job.attemptsMade ? Math.round(job.processedOn + Math.pow(2, job.attemptsMade) * backoffDelay) : scheduled;
-
-    if (job.opts.attempts <= job.attemptsMade) {
-        nextAttempt = false;
-    }
-
     try {
         let queueEntryBuf = await redis.hgetBuffer(`${REDIS_PREFIX}iaq:${job.data.account}`, job.data.queueId);
         if (!queueEntryBuf) {
@@ -124,17 +118,7 @@ async function get(options) {
         throw err;
     }
 
-    let response = Object.assign(job.data, {
-        created: new Date(Number(job.created || job.timestamp)).toISOString(),
-        //status: job.name,
-        progress: job.progress,
-        attemptsMade: job.attemptsMade,
-        attempts: job.opts.attempts,
-        scheduled: new Date(scheduled).toISOString(),
-        nextAttempt: nextAttempt ? new Date(nextAttempt).toISOString() : false
-    });
-
-    return response;
+    return formatQueueEntry(job);
 }
 
 module.exports = { list, del, get };

package/lib/redis-operations.js

@@ -228,7 +228,7 @@ class RedisTransaction {
      * @returns {Promise<Array>} Array of values from successful commands
      */
     async execOrThrow() {
-        const { results, values, error } = await this.exec();
+        const { values, error } = await this.exec();
 
         if (error) {
             throw error;