emailengine-app 2.61.1 → 2.61.3

package/lib/email-client/imap/mailbox.js

@@ -1,22 +1,11 @@
 'use strict';
 
 const crypto = require('crypto');
-const {
-    serialize,
-    unserialize,
-    compareExisting,
-    normalizePath,
-    download,
-    filterEmptyObjectValues,
-    validUidValidity,
-    calculateFetchBackoff,
-    readEnvValue
-} = require('../../tools');
+const { serialize, unserialize, compareExisting, normalizePath, download, filterEmptyObjectValues, validUidValidity } = require('../../tools');
 const msgpack = require('msgpack5')();
 const he = require('he');
 const libmime = require('libmime');
 const settings = require('../../settings');
-const config = require('@zone-eu/wild-config');
 const { bounceDetect } = require('../../bounce-detect');
 const { arfDetect } = require('../../arf-detect');
 const appendList = require('../../append-list');
@@ -41,41 +30,18 @@ const {
     REDIS_PREFIX,
     MAX_INLINE_ATTACHMENT_SIZE,
     MAX_ALLOWED_DOWNLOAD_SIZE,
-    DEFAULT_FETCH_BATCH_SIZE,
     MAILBOX_HASH
 } = require('../../consts');
 
-// Configurable batch size for fetching messages (default: 250)
-const FETCH_BATCH_SIZE = Number(readEnvValue('EENGINE_FETCH_BATCH_SIZE') || config.service.fetchBatchSize) || DEFAULT_FETCH_BATCH_SIZE;
-
-// Do not check for flag updates using full sync more often than this value (30 minutes)
-const FULL_SYNC_DELAY = 30 * 60 * 1000;
-
-/**
- * Calculates the next range of sequence numbers to fetch based on the last fetched range
- * @param {Number} totalMessages - Total number of messages in the mailbox
- * @param {String} lastRange - Last fetched range in format "start:end" or "start:*"
- * @returns {String|false} Next range to fetch or false if no more messages
- */
-function getFetchRange(totalMessages, lastRange) {
-    let lastEndMarker = lastRange ? lastRange.split(':').pop() : false;
-    if (lastEndMarker === '*') {
-        // Already fetched to the end
-        return false;
-    }
-    let lastSeq = lastRange ? Number(lastEndMarker) : 0;
-    let startSeq = lastSeq + 1;
-    if (startSeq > totalMessages) {
-        // No more messages to fetch
-        return false;
-    }
-    let endMarker = startSeq + FETCH_BATCH_SIZE - 1;
-    if (endMarker >= totalMessages) {
-        // Use * to fetch to the end
-        endMarker = '*';
-    }
-    return `${startSeq}:${endMarker}`;
-}
+const {
+    SyncOperations,
+    hasUidValidityChanged,
+    hasNoModseqChanges,
+    canUseCondstorePartialSync,
+    canUseSimplePartialSync,
+    canSkipSync,
+    FULL_SYNC_DELAY
+} = require('./sync-operations');
 
 /**
  * Represents a single IMAP mailbox/folder and handles all operations on it
@@ -115,6 +81,9 @@ class Mailbox {
 
         this.synced = false; // Whether initial sync is complete
         this.syncing = false; // Whether currently syncing
+
+        // Sync operations handler
+        this.syncOps = new SyncOperations(this);
     }
 
     /**
@@ -1828,646 +1797,19 @@ class Mailbox {
 
     /**
      * Performs full synchronization based on indexer type
+     * Delegates to SyncOperations
      */
     async fullSync() {
-        const imapIndexer = this.imapIndexer;
-
-        this.logger.trace({ msg: 'Running full sync', imapIndexer });
-
-        switch (imapIndexer) {
-            case 'fast':
-                return this.runFastSync();
-            case 'full':
-            default:
-                return this.runFullSync();
-        }
+        return this.syncOps.fullSync();
     }
 
     /**
      * Performs partial synchronization based on indexer type
+     * Delegates to SyncOperations
      * @param {Object} storedStatus - Current stored mailbox status
      */
     async partialSync(storedStatus) {
-        const imapIndexer = this.imapIndexer;
-
-        this.logger.trace({ msg: 'Running partial sync', imapIndexer });
-
-        switch (imapIndexer) {
-            case 'fast':
-                return this.runFastSync(storedStatus);
-            case 'full':
-            default:
-                return this.runPartialSync(storedStatus);
-        }
-    }
-
-    /**
-     * Fast sync mode - only tracks new messages, doesn't maintain full message list
-     * More efficient for large mailboxes where we only care about new messages
-     * @param {Object} storedStatus - Current stored mailbox status
-     */
-    async runFastSync(storedStatus) {
-        storedStatus = storedStatus || (await this.getStoredStatus());
-        let mailboxStatus = this.getMailboxStatus();
-
-        let lock = await this.getMailboxLock(null, { description: 'Fast sync' });
-        this.connection.syncing = true;
-        this.syncing = true;
-        try {
-            if (!this.connection.imapClient) {
-                throw new Error('IMAP connection not available');
-            }
-
-            let knownUidNext = typeof storedStatus.uidNext === 'number' ? storedStatus.uidNext || 1 : 1;
-
-            if (knownUidNext && mailboxStatus.messages) {
-                // detected new emails
-                let fields = { uid: true, flags: true, modseq: true, emailId: true, labels: true, internalDate: true };
-
-                let imapClient = this.connection.imapClient;
-
-                // If we have not yet scanned this folder, then start by finding the earliest matching email
-                if (typeof storedStatus.uidNext !== 'number' && this.connection.notifyFrom && this.connection.notifyFrom < new Date()) {
-                    // Find first message after notifyFrom date
-                    let matchingMessages = await imapClient.search({ since: this.connection.notifyFrom }, { uid: true });
-                    if (matchingMessages) {
-                        let earliestUid = matchingMessages[0];
-                        if (earliestUid) {
-                            knownUidNext = earliestUid;
-                        } else if (mailboxStatus.uidNext) {
-                            // no match, start from newest
-                            knownUidNext = mailboxStatus.uidNext;
-                        }
-                    }
-                }
-
-                let range = `${knownUidNext}:*`;
-                let opts = {
-                    uid: true
-                };
-
-                // Fetch messages with retry logic
-                let fetchCompleted = false;
-                let fetchRetryCount = 0;
-
-                while (!fetchCompleted) {
-                    try {
-                        let messages = [];
-
-                        // Fetch all messages in range
-                        for await (let messageData of imapClient.fetch(range, fields, opts)) {
-                            if (!messageData || !messageData.uid) {
-                                //TODO: support partial responses
-                                this.logger.debug({ msg: 'Partial FETCH response', code: 'partial_fetch', query: { range, fields, opts } });
-                                continue;
-                            }
-
-                            // ignore Recent flag
-                            messageData.flags.delete('\\Recent');
-
-                            messages.push(messageData);
-                        }
-                        // ensure that messages are sorted by UID
-                        messages = messages.sort((a, b) => a.uid - b.uid);
-
-                        // Process each new message
-                        for (let messageData of messages) {
-                            // Update uidNext if this is a new message
-                            let updated = await this.connection.redis.hUpdateBigger(this.getMailboxKey(), 'uidNext', messageData.uid + 1, messageData.uid + 1);
-
-                            if (updated) {
-                                // new email! Queue for processing
-                                await this.connection.redis.zadd(
-                                    this.getNotificationsKey(),
-                                    messageData.uid,
-                                    JSON.stringify({
-                                        uid: messageData.uid,
-                                        flags: messageData.flags,
-                                        internalDate:
-                                            (messageData.internalDate &&
-                                                typeof messageData.internalDate.toISOString === 'function' &&
-                                                messageData.internalDate.toISOString()) ||
-                                            null
-                                    })
-                                );
-                            }
-                        }
-
-                        try {
-                            // clear failure flag
-                            await this.connection.redis.hdel(this.connection.getAccountKey(), 'syncError');
-                        } catch (err) {
-                            // ignore
-                        }
-                        fetchCompleted = true;
-                    } catch (err) {
-                        try {
-                            // set failure flag
-                            await this.connection.redis.hSetExists(
-                                this.connection.getAccountKey(),
-                                'syncError',
-                                JSON.stringify({
-                                    path: this.path,
-                                    time: new Date().toISOString(),
-                                    error: {
-                                        error: err.message,
-                                        responseStatus: err.responseStatus,
-                                        responseText: err.responseText
-                                    }
-                                })
-                            );
-                        } catch (err) {
-                            // ignore
-                        }
-
-                        // Retry with exponential backoff
-                        if (!imapClient.usable) {
-                            // nothing to do here, connection closed
-                            this.logger.error({ msg: `FETCH failed, connection already closed, not retrying`, err });
-                            return;
-                        }
-
-                        const fetchRetryDelay = calculateFetchBackoff(++fetchRetryCount);
-                        this.logger.error({ msg: `FETCH failed, retrying in ${Math.round(fetchRetryDelay / 1000)}s`, err });
-                        await new Promise(r => setTimeout(r, fetchRetryDelay));
-
-                        if (!imapClient.usable) {
-                            // nothing to do here, connection closed
-                            this.logger.error({ msg: `FETCH failed, connection already closed, not retrying`, err });
-                            return;
-                        }
-                    }
-                }
-            }
-
-            await this.updateStoredStatus(this.getMailboxStatus());
-
-            await this.publishSyncedEvents(storedStatus);
-        } finally {
-            lock.release();
-            this.connection.syncing = false;
-            this.syncing = false;
-        }
-    }
-
-    /**
-     * Partial sync - fetches only changed messages using MODSEQ or UID range
-     * Used for incremental updates when we know something changed
-     * @param {Object} storedStatus - Current stored mailbox status
-     */
-    async runPartialSync(storedStatus) {
-        storedStatus = storedStatus || (await this.getStoredStatus());
-        let mailboxStatus = this.getMailboxStatus();
-
-        let lock = await this.getMailboxLock(null, { description: 'Partial sync' });
-        this.connection.syncing = true;
-        this.syncing = true;
-        try {
-            if (!this.connection.imapClient) {
-                throw new Error('IMAP connection not available');
-            }
-
-            let fields = { uid: true, flags: true, modseq: true, emailId: true, labels: true, internalDate: true };
-            let range = '1:*';
-            let opts = {
-                uid: true
-            };
-
-            // Use CONDSTORE if available for efficient change detection
-            if (this.connection.imapClient.enabled.has('CONDSTORE') && storedStatus.highestModseq) {
-                // Only fetch messages changed since last known MODSEQ
-                opts.changedSince = storedStatus.highestModseq;
-            } else if (storedStatus.uidNext) {
-                // Fall back to fetching new messages only
-                range = `${storedStatus.uidNext}:*`;
-            }
-
-            if (mailboxStatus.messages) {
-                // only fetch messages if there are some
-                let fetchCompleted = false;
-                let fetchRetryCount = 0;
-                while (!fetchCompleted) {
-                    // Get fresh imapClient reference inside retry loop
-                    let imapClient = this.connection.imapClient;
-                    if (!imapClient || !imapClient.usable) {
-                        this.logger.error({ msg: 'IMAP client not available for partial sync' });
-                        throw new Error('IMAP connection not available');
-                    }
-
-                    try {
-                        // Fetch and process each message
-                        for await (let messageData of imapClient.fetch(range, fields, opts)) {
-                            if (!messageData || !messageData.uid) {
-                                //TODO: support partial responses
-                                this.logger.debug({ msg: 'Partial FETCH response', code: 'partial_fetch', query: { range, fields, opts } });
-                                continue;
-                            }
-
-                            // ignore Recent flag
-                            messageData.flags.delete('\\Recent');
-
-                            let storedMessage = await this.entryListGet(messageData.uid, { uid: true });
-
-                            let changes;
-                            if (!storedMessage) {
-                                // New message
-                                let seq = await this.entryListSet(messageData);
-                                if (seq) {
-                                    // Queue for processing
-                                    await this.connection.redis.zadd(
-                                        this.getNotificationsKey(),
-                                        messageData.uid,
-                                        JSON.stringify({
-                                            uid: messageData.uid,
-                                            flags: messageData.flags,
-                                            internalDate:
-                                                (messageData.internalDate &&
-                                                    typeof messageData.internalDate.toISOString === 'function' &&
-                                                    messageData.internalDate.toISOString()) ||
-                                                null
-                                        })
-                                    );
-                                }
-                            } else if ((changes = compareExisting(storedMessage.entry, messageData))) {
-                                // Existing message with changes
-                                let seq = await this.entryListSet(messageData);
-                                if (seq) {
-                                    await this.processChanges(messageData, changes);
-                                }
-                            }
-                        }
-                        try {
-                            // clear failure flag
-                            await this.connection.redis.hdel(this.connection.getAccountKey(), 'syncError');
-                        } catch (err) {
-                            // ignore
-                        }
-                        fetchCompleted = true;
-                    } catch (err) {
-                        try {
-                            // set failure flag
-                            await this.connection.redis.hSetExists(
-                                this.connection.getAccountKey(),
-                                'syncError',
-                                JSON.stringify({
-                                    path: this.path,
-                                    time: new Date().toISOString(),
-                                    error: {
-                                        error: err.message,
-                                        responseStatus: err.responseStatus,
-                                        responseText: err.responseText
-                                    }
-                                })
-                            );
-                        } catch (err) {
-                            // ignore
-                        }
-
-                        // Retry with exponential backoff
-                        if (!imapClient.usable) {
-                            // nothing to do here, connection closed
-                            this.logger.error({ msg: `FETCH failed, connection already closed, not retrying` });
-                            return;
-                        }
-
-                        const fetchRetryDelay = calculateFetchBackoff(++fetchRetryCount);
-                        this.logger.error({ msg: `FETCH failed, retrying in ${Math.round(fetchRetryDelay / 1000)}s` });
-                        await new Promise(r => setTimeout(r, fetchRetryDelay));
-
-                        if (!imapClient.usable) {
-                            // nothing to do here, connection closed
-                            this.logger.error({ msg: `FETCH failed, connection already closed, not retrying` });
-                            return;
-                        }
-                    }
-                }
-            }
-
-            await this.updateStoredStatus(this.getMailboxStatus());
-
-            await this.publishSyncedEvents(storedStatus);
-        } finally {
-            lock.release();
-            this.connection.syncing = false;
-            this.syncing = false;
-        }
-    }
-
-    /**
-     * Full sync - fetches all messages and detects additions, deletions, and changes
-     * Most thorough but slowest sync method
-     */
-    async runFullSync() {
-        let fields = { uid: true, flags: true, modseq: true, emailId: true, labels: true, internalDate: true };
-        let opts = {};
-
-        let lock = await this.getMailboxLock(null, { description: 'Full sync' });
-        this.connection.syncing = true;
-        this.syncing = true;
-        try {
-            // Generate unique ID for this sync loop to track batch ordering
-            const loopId = crypto.randomUUID();
-
-            // Wait for next tick to ensure ImapFlow has processed all untagged responses from SELECT
-            await new Promise(resolve => setImmediate(resolve));
-
-            let mailboxStatus = this.getMailboxStatus();
-
-            this.logger.debug({
-                msg: 'Starting full sync',
-                code: 'full_sync_start',
-                loopId,
-                mailboxStatus,
-                imapClientExists: mailboxStatus.messages
-            });
-
-            // Track highest sequence number seen
-            let seqMax = 0;
-            let changes;
-
-            // Get current message count for deletion detection
-            let storedMaxSeqOld = await this.connection.redis.zcard(this.getMessagesKey());
-
-            let responseCounters = {
-                empty: 0,
-                partial: 0,
-                messages: 0
-            };
-
-            if (mailboxStatus.messages) {
-                this.logger.debug({
-                    msg: 'Running FETCH',
-                    code: 'run_fetch',
-                    query: { fields, opts },
-                    expectedMessages: mailboxStatus.messages,
-                    mailbox: mailboxStatus,
-                    maxBatchSize: FETCH_BATCH_SIZE,
-                    expectedBatches: Math.ceil(mailboxStatus.messages / FETCH_BATCH_SIZE)
-                });
-
-                // Process messages in batches to avoid memory issues
-                let range = false;
-                let lastHighestUid = 0;
-                let batchNumber = 0;
-                // process messages in batches
-                while ((range = getFetchRange(mailboxStatus.messages, range))) {
-                    batchNumber++;
-                    this.logger.debug({
-                        msg: 'Processing batch',
-                        code: 'fetch_batch',
-                        loopId,
-                        batchNumber,
-                        range,
-                        totalMessages: mailboxStatus.messages,
-                        previousRange: batchNumber > 1 ? 'calculated' : 'initial'
-                    });
-                    let fetchCompleted = false;
-                    let fetchRetryCount = 0;
-                    while (!fetchCompleted) {
-                        // Get fresh imapClient reference inside retry loop
-                        // This ensures we use the current connection state
-                        const imapClient = this.connection.imapClient;
-                        if (!imapClient || !imapClient.usable) {
-                            this.logger.error({ msg: 'IMAP client not available for FETCH' });
-                            throw new Error('IMAP connection not available');
-                        }
-
-                        try {
-                            this.logger.debug({
-                                msg: 'Starting FETCH command',
-                                code: 'fetch_start',
-                                loopId,
-                                batchNumber,
-                                range,
-                                retryCount: fetchRetryCount,
-                                totalMessages: mailboxStatus.messages
-                            });
-
-                            for await (let messageData of imapClient.fetch(range, fields, opts)) {
-                                if (!messageData) {
-                                    this.logger.debug({ msg: 'Empty FETCH response', code: 'empty_fetch', query: { range, fields, opts } });
-                                    responseCounters.empty++;
-                                    continue;
-                                }
-
-                                if (!messageData.uid || (fields.flags && !messageData.flags)) {
-                                    // TODO: support partial responses
-                                    // For now, without UID or FLAGS there's nothing to do
-                                    this.logger.debug({
-                                        msg: 'Partial FETCH response',
-                                        code: 'partial_fetch',
-                                        query: { range, fields, opts },
-                                        responseKeys: Object.keys(messageData)
-                                    });
-                                    responseCounters.partial++;
-                                    continue;
-                                }
-
-                                if (messageData.uid <= lastHighestUid) {
-                                    // already processed in the previous batch
-                                    // probably an older email was deleted which shifted message entries
-                                    continue;
-                                }
-                                lastHighestUid = messageData.uid;
-
-                                responseCounters.messages++;
-
-                                if (fields.internalDate && !messageData.internalDate) {
-                                    this.logger.debug({
-                                        msg: 'Missing INTERNALDATE',
-                                        code: 'fetch_date_missing',
-                                        query: { range, fields, opts },
-                                        responseKeys: Object.keys(messageData)
-                                    });
-                                }
-
-                                // ignore Recent flag
-                                messageData.flags.delete('\\Recent');
-
-                                if (messageData.seq > seqMax) {
-                                    seqMax = messageData.seq;
-                                }
-
-                                let storedMessage = await this.entryListGet(messageData.uid, { uid: true });
-                                if (!storedMessage) {
-                                    // New message
-                                    let seq = await this.entryListSet(messageData);
-                                    if (seq) {
-                                        await this.connection.redis.zadd(
-                                            this.getNotificationsKey(),
-                                            messageData.uid,
-                                            JSON.stringify({
-                                                uid: messageData.uid,
-                                                flags: messageData.flags,
-                                                internalDate:
-                                                    (messageData.internalDate &&
-                                                        typeof messageData.internalDate.toISOString === 'function' &&
-                                                        messageData.internalDate.toISOString()) ||
-                                                    null
-                                            })
-                                        );
-                                    }
-                                } else {
-                                    // Check for deleted messages between stored and current sequence
-                                    let diff = storedMessage.seq - messageData.seq;
-                                    if (diff) {
-                                        this.logger.trace({ msg: 'Deleted range', inloop: true, diff, start: messageData.seq });
-                                    }
-                                    // Process deletions
-                                    for (let i = diff - 1; i >= 0; i--) {
-                                        let seq = messageData.seq + i;
-                                        let deletedEntry = await this.entryListExpunge(seq);
-                                        if (deletedEntry) {
-                                            await this.processDeleted(deletedEntry);
-                                        }
-                                    }
-
-                                    // Check for changes
-                                    if ((changes = compareExisting(storedMessage.entry, messageData))) {
-                                        let seq = await this.entryListSet(messageData);
-                                        if (seq) {
-                                            await this.processChanges(messageData, changes);
-                                        }
-                                    }
-                                }
-                            }
-
-                            try {
-                                // clear failure flag
-                                await this.connection.redis.hdel(this.connection.getAccountKey(), 'syncError');
-                            } catch (err) {
-                                // ignore
-                            }
-
-                            this.logger.debug({
-                                msg: 'FETCH completed successfully',
-                                code: 'fetch_success',
-                                loopId,
-                                batchNumber,
-                                range,
-                                retryCount: fetchRetryCount
-                            });
-
-                            fetchCompleted = true;
-                        } catch (err) {
-                            this.logger.error({
-                                msg: 'FETCH failed',
-                                code: 'fetch_error',
-                                loopId,
-                                batchNumber,
-                                range,
-                                retryCount: fetchRetryCount,
-                                totalMessages: mailboxStatus.messages,
-                                error: err.message,
-                                responseStatus: err.responseStatus,
-                                responseText: err.responseText
-                            });
-
-                            if (!imapClient.usable) {
-                                // nothing to do here, connection closed
-                                this.logger.error({ msg: `FETCH failed, connection already closed, not retrying`, loopId });
-                                return;
-                            }
-
-                            try {
-                                // set failure flag
-                                await this.connection.redis.hSetExists(
-                                    this.connection.getAccountKey(),
-                                    'syncError',
-                                    JSON.stringify({
-                                        path: this.path,
-                                        time: new Date().toISOString(),
-                                        error: {
-                                            error: err.message,
-                                            responseStatus: err.responseStatus,
-                                            responseText: err.responseText
-                                        }
-                                    })
-                                );
-                            } catch (err) {
-                                // ignore
-                            }
-
-                            // Retry with exponential backoff
-                            const fetchRetryDelay = calculateFetchBackoff(++fetchRetryCount);
-                            this.logger.error({ msg: `FETCH failed, retrying in ${Math.round(fetchRetryDelay / 1000)}s`, loopId, batchNumber });
-                            await new Promise(r => setTimeout(r, fetchRetryDelay));
-
-                            if (!imapClient.usable) {
-                                // nothing to do here, connection closed
-                                this.logger.error({ msg: `FETCH failed, connection already closed, not retrying`, loopId });
-                                return;
-                            }
-
-                            // Verify we're still on the correct mailbox after the delay
-                            // Another operation might have changed the mailbox while we were waiting
-                            const currentMailbox = this.connection.imapClient.mailbox;
-                            if (!currentMailbox || currentMailbox.path !== this.path) {
-                                this.logger.error({
-                                    msg: 'Mailbox changed during retry delay, aborting sync',
-                                    expectedPath: this.path,
-                                    currentPath: currentMailbox ? currentMailbox.path : 'none',
-                                    loopId
-                                });
-                                throw new Error('Mailbox changed during sync operation');
-                            }
-
-                            // Refresh mailbox status in case it changed
-                            const oldMailboxMessages = mailboxStatus.messages;
-                            mailboxStatus = this.getMailboxStatus();
-
-                            this.logger.debug({
-                                msg: 'Refreshed mailbox status after error',
-                                code: 'mailbox_status_refresh',
-                                loopId,
-                                batchNumber,
-                                oldMessages: oldMailboxMessages,
-                                newMessages: mailboxStatus.messages,
-                                range
-                            });
-                        }
-                    }
-                }
-            }
-
-            // Delete any messages that weren't seen in this sync
-            let storedMaxSeq = await this.connection.redis.zcard(this.getMessagesKey());
-            let diff = storedMaxSeq - seqMax;
-            if (diff) {
-                this.logger.trace({
-                    msg: 'Deleted range',
-                    inloop: false,
-                    diff,
-                    start: seqMax + 1,
-                    messagesKey: this.getMessagesKey(),
-                    zcard: storedMaxSeq,
-                    zcardOld: storedMaxSeqOld,
-                    responseCounters
-                });
-            }
-
-            // Process remaining deletions
-            for (let i = diff - 1; i >= 0; i--) {
-                let seq = seqMax + i + 1;
-                let deletedEntry = await this.entryListExpunge(seq);
-                if (deletedEntry) {
-                    await this.processDeleted(deletedEntry);
-                }
-            }
-
-            // Update status with full sync timestamp
-            let status = this.getMailboxStatus();
-            status.lastFullSync = new Date();
-
-            await this.updateStoredStatus(status);
-            let storedStatus = await this.getStoredStatus();
-
-            await this.publishSyncedEvents(storedStatus);
-        } finally {
-            this.connection.syncing = false;
-            this.syncing = false;
-            lock.release();
-        }
+        return this.syncOps.partialSync(storedStatus);
     }
 
     /**
@@ -2592,7 +1934,7 @@ class Mailbox {
             }
 
             // Check for UIDVALIDITY change (mailbox recreated)
-            if ('uidValidity' in storedStatus && mailboxStatus.uidValidity !== storedStatus.uidValidity) {
+            if (hasUidValidityChanged(storedStatus, mailboxStatus)) {
                 // UIDVALIDITY has changed, full sync is required!
                 // delete mailbox status
                 let result = await this.connection.redis.multi().zcard(this.getMessagesKey()).del(this.getMessagesKey()).del(this.getMailboxKey()).exec();
@@ -2621,10 +1963,10 @@ class Mailbox {
                 storedStatus = await this.getStoredStatus();
             }
 
-            // Determine sync strategy based on various conditions
+            // Determine sync strategy using helper functions
 
             // No changes if MODSEQ hasn't changed
-            if (storedStatus.highestModseq && storedStatus.highestModseq === mailboxStatus.highestModseq) {
+            if (hasNoModseqChanges(storedStatus, mailboxStatus)) {
                 return false;
             }
 
@@ -2633,34 +1975,18 @@ class Mailbox {
                 return false;
             }
 
-            // Partial sync if we can detect only new messages or flag changes
-            if (
-                this.connection.imapClient.enabled.has('CONDSTORE') &&
-                storedStatus.highestModseq < mailboxStatus.highestModseq &&
-                storedStatus.messages <= mailboxStatus.messages &&
-                mailboxStatus.uidNext - storedStatus.uidNext === mailboxStatus.messages - storedStatus.messages
-            ) {
-                // search for flag changes and new messages
+            // Partial sync if CONDSTORE indicates only new messages or flag changes
+            if (canUseCondstorePartialSync(this.connection.imapClient, storedStatus, mailboxStatus)) {
                 return await this.partialSync(storedStatus);
             }
 
             // Partial sync if only new messages
-            if (
-                storedStatus.messages < mailboxStatus.messages &&
-                mailboxStatus.uidNext - storedStatus.uidNext === mailboxStatus.messages - storedStatus.messages
-            ) {
-                // seem to have new messages only
+            if (canUseSimplePartialSync(storedStatus, mailboxStatus)) {
                 return await this.partialSync(storedStatus);
             }
 
             // Skip if nothing changed and recent full sync
-            if (
-                storedStatus.messages === mailboxStatus.messages &&
-                storedStatus.uidNext === mailboxStatus.uidNext &&
-                storedStatus.lastFullSync &&
-                storedStatus.lastFullSync >= new Date(Date.now() - FULL_SYNC_DELAY)
-            ) {
-                // too soon from last full sync, message count seems the same
+            if (canSkipSync(storedStatus, mailboxStatus)) {
                 return false;
             }