imapkit 4.0.3 → 4.1.1

package/{lib → dist/esm}/plugins/context-search.js

@@ -1,31 +1,23 @@
-'use strict';
-
 /**
  * @help Adds CONTEXT=SEARCH [RFC5267] capability, loads ESEARCH as well
  * @help SEARCH RETURN (UPDATE) sends ADDTO and REMOVEFROM updates as the result changes, until CANCELUPDATE or the mailbox is closed
  * @help SEARCH RETURN (PARTIAL 1:100) returns a window of the results, the CONTEXT hint is accepted and ignored
  * @help Server option "maxSearchContexts" (default 10) limits the updating contexts of a session, above it NOUPDATE is sent
  */
-
-const esearch = require('./esearch');
-const { buildCorrelator, registerPartialOption, toSequenceSet, toOrderedSet } = require('../esearch');
-const { states } = require('../command-states');
-
+import esearch from './esearch.js';
+import { buildCorrelator, registerPartialOption, toSequenceSet, toOrderedSet } from '../esearch.js';
+import { states } from '../command-states.js';
 const DEFAULT_MAX_CONTEXTS = 10;
-
 // commands that close the selected mailbox, updates cease with them (RFC 5267 section 4.3)
 const CLOSING_COMMANDS = new Set(['SELECT', 'EXAMINE', 'CLOSE', 'UNSELECT']);
-
 // searching commands that can create updating contexts, SORT and UID SORT only with CONTEXT=SORT (see the ESORT plugin)
 const SEARCHING_COMMANDS = new Set(['SEARCH', 'UID SEARCH', 'SORT', 'UID SORT']);
-
-const getContexts = connection => {
+const getContexts = (connection) => {
     if (!connection.searchContexts) {
         connection.searchContexts = new Map();
     }
     return connection.searchContexts;
 };
-
 /**
  * Groups updates of one kind into context position and result set pairs (RFC 5267 sections 4.3.3 and
  * 4.3.4). Updates of a searching command all use position 0 and form one set in mailbox order. Updates of
@@ -43,7 +35,8 @@ const groupUpdates = (updates, isRemoval) => {
         const next = last && (isRemoval || !position ? last.position : last.position + last.values.length);
         if (last && position === next) {
             last.values.push(value);
-        } else {
+        }
+        else {
             groups.push({ position, values: [value] });
         }
     });
@@ -54,7 +47,6 @@ const groupUpdates = (updates, isRemoval) => {
     });
     return payload;
 };
-
 /**
  * Sends ADDTO and REMOVEFROM updates of a context (RFC 5267 sections 4.3.3 and 4.3.4)
  *
@@ -76,12 +68,11 @@ const sendUpdate = (connection, context, removed, added) => {
     }
     connection.send({ tag: '*', command: 'ESEARCH', attributes }, 'ESEARCH UPDATE', null, null, context);
 };
-
 /**
  * Checks every updating context against the selected mailbox as the session sees it, and sends the
  * changes. Expunged messages are handled when their EXPUNGE response is sent
  */
-const checkContexts = connection => {
+const checkContexts = (connection) => {
     const contexts = connection.searchContexts;
     const mailbox = connection.selectedMailbox;
     const messages = mailbox ? mailbox.messages : [];
@@ -92,32 +83,34 @@ const checkContexts = connection => {
             return;
         }
         const matching = messages.filter((message, i) => context.matches(message, i + 1));
-        const getValue = message => (context.isUid ? message.uid : numbers.get(message));
+        // only messages of the mailbox get a value
+        const getValue = (message) => (context.isUid ? message.uid : numbers.get(message));
         const current = new Set(matching);
         const removed = [];
         const added = [];
-
         if (!context.compare) {
             // a searching command, positions are 0 (RFC 5267 section 4.3.3)
-            context.results.forEach(message => {
+            context.results.forEach((message) => {
                 // a message that is gone without an EXPUNGE response for this session is just dropped
                 if (!current.has(message) && numbers.has(message)) {
                     removed.push([0, getValue(message)]);
                 }
             });
-            matching.forEach(message => {
+            matching.forEach((message) => {
                 if (!context.results.has(message)) {
                     added.push([0, getValue(message)]);
                 }
             });
-        } else {
+        }
+        else {
             // a sorting command. The sort values of a message do not change, so the results that stay keep their order.
             // Removals are counted on the list as it shrinks, insertions in ascending order of their final position
             let kept = 0;
-            context.order.forEach(message => {
+            context.order.forEach((message) => {
                 if (current.has(message)) {
                     kept++;
-                } else if (numbers.has(message)) {
+                }
+                else if (numbers.has(message)) {
                     removed.push([kept + 1, getValue(message)]);
                 }
             });
@@ -128,14 +121,12 @@ const checkContexts = connection => {
                 }
             });
         }
-
         context.results = current;
         if (removed.length || added.length) {
             sendUpdate(connection, context, removed, added);
         }
     });
 };
-
 /**
  * Removes expunged messages from the contexts that hold them, with one REMOVEFROM update per context
  *
@@ -144,7 +135,7 @@ const checkContexts = connection => {
  * @param {Number} seq Sequence number of the EXPUNGE response for a single message, null when there is none (VANISHED)
  */
 const removeExpunged = (connection, messages, seq) => {
-    connection.searchContexts.forEach(context => {
+    connection.searchContexts.forEach((context) => {
         if (context.mailbox !== connection.selectedMailbox) {
             return;
         }
@@ -167,34 +158,24 @@ const removeExpunged = (connection, messages, seq) => {
         }
     });
 };
-
-module.exports = function (server) {
+export default function contextSearchPlugin(server) {
     // CONTEXT=SORT loads this plugin as well, so it may be called twice
     if (server.addSearchContext) {
         return;
     }
-
     // the result options of CONTEXT=SEARCH extend the extended SEARCH command (RFC 5267 section 4.1)
     esearch(server);
-
     server.registerCapability('CONTEXT=SEARCH');
-
     const maxContexts = Math.max(Number(server.options.maxSearchContexts) || DEFAULT_MAX_CONTEXTS, 1);
-
     // RFC 5267 section 4.2: the server MAY ignore the CONTEXT hint
     server.searchReturnOptions.set('CONTEXT', { hint: true });
     // RFC 5267 section 4.3: UPDATE has no data of its own, but the ESEARCH response is still sent
     server.searchReturnOptions.set('UPDATE', { data: false, response: true, once: true });
     // RFC 5267 section 4.4
     registerPartialOption(server);
-
     // RFC 5267 section 4.3: UPDATE with the tag of an earlier searching command that still has an updating
     // context SHALL be rejected with BAD
-    server.searchReturnChecks.push(
-        (options, connection, parsed) =>
-            options.has('UPDATE') && getContexts(connection).has(parsed.tag) && 'Tag ' + parsed.tag + ' is already in use by an updating search'
-    );
-
+    server.searchReturnChecks.push((options, connection, parsed) => options.has('UPDATE') && getContexts(connection).has(parsed.tag) && 'Tag ' + parsed.tag + ' is already in use by an updating search');
     /**
      * Creates an updating context once a searching command with UPDATE has completed. Also used by
      * CONTEXT=SORT and by the ESEARCH command of MULTISEARCH
@@ -211,25 +192,20 @@ module.exports = function (server) {
         const contexts = getContexts(connection);
         if (contexts.size >= maxContexts) {
             // RFC 5267 section 4.3.1: an untagged NO with NOUPDATE, the other result options are still honoured
-            connection.send(
-                {
-                    tag: '*',
-                    command: 'NO',
-                    attributes: [
-                        {
-                            type: 'SECTION',
-                            section: [
-                                { type: 'ATOM', value: 'NOUPDATE' },
-                                { type: 'STRING', value: parsed.tag }
-                            ]
-                        },
-                        { type: 'TEXT', value: 'Too many updating contexts' }
-                    ]
-                },
-                'NOUPDATE',
-                parsed,
-                data
-            );
+            connection.send({
+                tag: '*',
+                command: 'NO',
+                attributes: [
+                    {
+                        type: 'SECTION',
+                        section: [
+                            { type: 'ATOM', value: 'NOUPDATE' },
+                            { type: 'STRING', value: parsed.tag }
+                        ]
+                    },
+                    { type: 'TEXT', value: 'Too many updating contexts' }
+                ]
+            }, 'NOUPDATE', parsed, data);
             return;
         }
         contexts.set(parsed.tag, {
@@ -243,36 +219,29 @@ module.exports = function (server) {
             correlatorMailbox: correlatorMailbox || null
         });
     };
-
     // RFC 5267 section 4.3.5: command-select =/ "CANCELUPDATE" 1*(SP quoted)
-    server.setCommandHandler(
-        'CANCELUPDATE',
-        (connection, parsed, data, callback) => {
-            const tags = parsed.attributes || [];
-            if (!tags.length || tags.some(tag => !tag || tag.type !== 'STRING')) {
-                connection.sendStatus(parsed, data, 'BAD', 'CANCELUPDATE expects one or more quoted tags', false, 'CANCELUPDATE FAILED');
-                return callback();
-            }
-            const contexts = getContexts(connection);
-            const unknown = tags.find(tag => !contexts.has(tag.value));
-            if (unknown) {
-                // nothing is cancelled when a tag has no updating context
-                connection.sendStatus(parsed, data, 'NO', 'Unknown tag', false, 'CANCELUPDATE FAILED');
-                return callback();
-            }
-            tags.forEach(tag => contexts.delete(tag.value));
-            connection.sendStatus(parsed, data, 'OK', 'Updates cancelled', false, 'CANCELUPDATE');
+    server.setCommandHandler('CANCELUPDATE', (connection, parsed, data, callback) => {
+        const tags = parsed.attributes || [];
+        if (!tags.length || tags.some(tag => !tag || tag.type !== 'STRING')) {
+            connection.sendStatus(parsed, data, 'BAD', 'CANCELUPDATE expects one or more quoted tags', false, 'CANCELUPDATE FAILED');
             return callback();
-        },
-        { states: states.SELECTED }
-    );
-
+        }
+        const contexts = getContexts(connection);
+        const unknown = tags.find(tag => !contexts.has(tag.value));
+        if (unknown) {
+            // nothing is cancelled when a tag has no updating context
+            connection.sendStatus(parsed, data, 'NO', 'Unknown tag', false, 'CANCELUPDATE FAILED');
+            return callback();
+        }
+        tags.forEach(tag => contexts.delete(tag.value));
+        connection.sendStatus(parsed, data, 'OK', 'Updates cancelled', false, 'CANCELUPDATE');
+        return callback();
+    }, { states: states.SELECTED });
     // UNAUTHENTICATE (RFC 8437) closes the mailbox, so the updates end
-    server.resetHandlers.push(connection => {
+    server.resetHandlers.push((connection) => {
         connection.searchContexts = null;
     });
-
-    server.connectionHandlers.push(connection => {
+    server.connectionHandlers.push((connection) => {
         // Notifications from other sessions (and this one) are flushed here. Once none are pending, the session
         // knows the current message list, so new matches can be reported after their EXISTS and FETCH responses
         // (RFC 5267 section 4.3.2). A command that closes the mailbox gets no updates, its tagged response ends them
@@ -285,7 +254,6 @@ module.exports = function (server) {
             }
         };
     });
-
     server.outputHandlers.push((connection, response, description, parsed, data, extra) => {
         // RFC 5267 section 4.3.4: REMOVEFROM for an expunged message MUST be sent before the EXPUNGE response. After
         // ENABLE QRESYNC a VANISHED response reports the expunged messages (RFC 7162 section 3.2.10), it has no sequence
@@ -295,22 +263,19 @@ module.exports = function (server) {
             removeExpunged(connection, expunged, response.message ? response.attributes[0] : null);
             return;
         }
-
         if (!parsed) {
             return;
         }
         const command = (parsed.command || '').toUpperCase();
-
         if (response.tag === parsed.tag && CLOSING_COMMANDS.has(command)) {
             connection.searchContexts = null;
             return;
         }
-
         if (!SEARCHING_COMMANDS.has(command) || !parsed.searchReturn || !parsed.searchReturn.has('UPDATE')) {
             return;
         }
         // the full search result, the context is created when the command succeeded
-        if (response.tag === '*' && command.endsWith(response.command) && description === command && extra && Array.isArray(extra.list)) {
+        if (response.tag === '*' && command.endsWith(String(response.command)) && description === command && extra && Array.isArray(extra.list)) {
             parsed.contextResult = extra;
             return;
         }
@@ -318,4 +283,4 @@ module.exports = function (server) {
             server.addSearchContext(connection, parsed, data, parsed.contextResult, command.startsWith('UID '));
         }
     });
-};
+}

package/dist/esm/plugins/context-sort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @help Adds CONTEXT=SORT [RFC5267] capability, loads ESORT and CONTEXT=SEARCH as well
+ * @help SORT RETURN (UPDATE) sends ADDTO and REMOVEFROM updates with context positions in sort order, PARTIAL and CONTEXT work for SORT too
+ */
+import type { IMAPServer } from '../types.js';
+export default function contextSortPlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/context-sort.js

@@ -1,19 +1,14 @@
-'use strict';
-
 /**
  * @help Adds CONTEXT=SORT [RFC5267] capability, loads ESORT and CONTEXT=SEARCH as well
  * @help SORT RETURN (UPDATE) sends ADDTO and REMOVEFROM updates with context positions in sort order, PARTIAL and CONTEXT work for SORT too
  */
-
-const esort = require('./esort');
-const contextSearch = require('./context-search');
-
-module.exports = function (server) {
+import esort from './esort.js';
+import contextSearch from './context-search.js';
+export default function contextSortPlugin(server) {
     // RFC 5267 section 4.1: CONTEXT=SORT means SORT and the extended SORT syntax of section 3. The updating
     // contexts are shared with CONTEXT=SEARCH, so that is loaded (and advertised) as well
     esort(server);
     contextSearch(server);
-
     server.registerCapability('CONTEXT=SORT');
     server.contextSort = true;
-};
+}

package/dist/esm/plugins/create-special-use.d.ts

@@ -0,0 +1,7 @@
+import type { IMAPServer } from '../types.js';
+/**
+ * @help Enables CREATE-SPECIAL-USE [RFC6154] capability
+ * @help Allowed special flags can be set with server
+ * @help option "special-use"
+ */
+export default function createSpecialUsePlugin(server: IMAPServer): void;

package/{lib → dist/esm}/plugins/create-special-use.js

@@ -1,18 +1,13 @@
-'use strict';
-
 /**
  * @help Enables CREATE-SPECIAL-USE [RFC6154] capability
  * @help Allowed special flags can be set with server
  * @help option "special-use"
  */
-
-module.exports = function (server) {
+export default function createSpecialUsePlugin(server) {
     // Register capability
     server.registerCapability('CREATE-SPECIAL-USE');
-
     const createHandler = server.getCommandHandler('CREATE');
     const allowedList = [].concat(server.options['special-use'] || ['\\Archive', '\\Drafts', '\\Flagged', '\\Junk', '\\Sent', '\\Trash']);
-
     server.setCommandHandler('CREATE', (connection, parsed, data, callback) => {
         let i;
         let len;
@@ -20,71 +15,57 @@ module.exports = function (server) {
         const mailboxSpecialUse = [];
         if (parsed.attributes && Array.isArray(parsed.attributes[1])) {
             for (i = 0; i < parsed.attributes[1].length; i += 2) {
-                if (
-                    parsed.attributes[1][i] &&
+                if (parsed.attributes[1][i] &&
                     parsed.attributes[1][i].type === 'ATOM' &&
                     parsed.attributes[1][i].value.toUpperCase() === 'USE' &&
-                    Array.isArray(parsed.attributes[1][i + 1])
-                ) {
+                    Array.isArray(parsed.attributes[1][i + 1])) {
                     specialUseList = parsed.attributes[1][i + 1];
                     parsed.attributes[1].splice(i, 2);
                     i -= 2;
                 }
             }
-
             // Remove extra arguments if no members were left
             if (!parsed.attributes[1].length) {
                 parsed.attributes.splice(1, 1);
             }
         }
-
         if (specialUseList) {
             for (i = 0, len = specialUseList.length; i < len; i++) {
                 if (['ATOM', 'STRING', 'LITERAL'].indexOf(specialUseList[i].type) < 0) {
-                    connection.send(
-                        {
-                            tag: parsed.tag,
-                            command: 'BAD',
-                            attributes: [
-                                {
-                                    type: 'TEXT',
-                                    value: 'Invalid syntax for special use flag #' + (i + 1)
-                                }
-                            ]
-                        },
-                        'CREATE-SPECIAL-USE FAILED',
-                        parsed,
-                        data
-                    );
+                    connection.send({
+                        tag: parsed.tag,
+                        command: 'BAD',
+                        attributes: [
+                            {
+                                type: 'TEXT',
+                                value: 'Invalid syntax for special use flag #' + (i + 1)
+                            }
+                        ]
+                    }, 'CREATE-SPECIAL-USE FAILED', parsed, data);
                     return callback();
                 }
                 // attribute names are case-insensitive, store the canonical form
                 const specialUse = allowedList.find(value => value.toLowerCase() === String(specialUseList[i].value).toLowerCase());
                 if (!specialUse) {
-                    connection.send(
-                        {
-                            tag: parsed.tag,
-                            command: 'NO',
-                            attributes: [
-                                {
-                                    type: 'SECTION',
-                                    section: [
-                                        {
-                                            type: 'ATOM',
-                                            value: 'USEATTR'
-                                        }
-                                    ]
-                                },
-                                {
-                                    type: 'TEXT',
-                                    value: specialUseList[i].value + ' not supported'
-                                }
-                            ]
-                        },
-                        'CREATE-SPECIAL-USE FAILED',
-                        parsed,
-                        data
-                    );
+                    connection.send({
+                        tag: parsed.tag,
+                        command: 'NO',
+                        attributes: [
+                            {
+                                type: 'SECTION',
+                                section: [
+                                    {
+                                        type: 'ATOM',
+                                        value: 'USEATTR'
+                                    }
+                                ]
+                            },
+                            {
+                                type: 'TEXT',
+                                value: specialUseList[i].value + ' not supported'
+                            }
+                        ]
+                    }, 'CREATE-SPECIAL-USE FAILED', parsed, data);
                     return callback();
                 }
                 if (mailboxSpecialUse.indexOf(specialUse) < 0) {
@@ -92,17 +73,14 @@ module.exports = function (server) {
                 }
             }
         }
-
         if (mailboxSpecialUse.length) {
             parsed.mailboxSpecialUse = mailboxSpecialUse;
         }
-
         createHandler(connection, parsed, data, callback);
     });
-
     server.outputHandlers.push((connection, response, description, parsed, data, folder) => {
         if (description === 'CREATE' && folder && parsed.mailboxSpecialUse) {
             folder['special-use'] = parsed.mailboxSpecialUse;
         }
     });
-};
+}

package/dist/esm/plugins/enable.d.ts

@@ -0,0 +1,23 @@
+import type { IMAPConnection, IMAPServer } from '../types.js';
+/**
+ * @help Adds ENABLE capability [RFC5161]
+ * @help Plugins that can be enabled (eg. CONDSTORE)
+ * @help can be loaded in any order
+ */
+/**
+ * Makes an extension available for ENABLE. Plugins call it whether the ENABLE plugin is loaded before or after them
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {String} name Capability name in the spelling it is advertised in, e.g. "IMAP4rev2"
+ */
+declare function registerEnable(server: IMAPServer, name: string): void;
+/**
+ * Checks if a session has enabled an extension with ENABLE. UNAUTHENTICATE clears the list (RFC 8437 section 4.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} name Capability name in the spelling it was registered with, see registerEnable
+ * @return {Boolean} true if the extension is enabled
+ */
+declare function isEnabled(connection: IMAPConnection, name: string): boolean;
+export default function enablePlugin(server: IMAPServer): void;
+export { registerEnable, isEnabled };

package/dist/esm/plugins/enable.js

@@ -0,0 +1,111 @@
+import { states } from '../command-states.js';
+/**
+ * @help Adds ENABLE capability [RFC5161]
+ * @help Plugins that can be enabled (eg. CONDSTORE)
+ * @help can be loaded in any order
+ */
+/**
+ * Makes an extension available for ENABLE. Plugins call it whether the ENABLE plugin is loaded before or after them
+ *
+ * @param {Object} server IMAPServer instance
+ * @param {String} name Capability name in the spelling it is advertised in, e.g. "IMAP4rev2"
+ */
+function registerEnable(server, name) {
+    server.enableAvailable = server.enableAvailable || [];
+    if (server.enableAvailable.indexOf(name) < 0) {
+        server.enableAvailable.push(name);
+    }
+}
+/**
+ * Checks if a session has enabled an extension with ENABLE. UNAUTHENTICATE clears the list (RFC 8437 section 4.1)
+ *
+ * @param {Object} connection IMAP connection
+ * @param {String} name Capability name in the spelling it was registered with, see registerEnable
+ * @return {Boolean} true if the extension is enabled
+ */
+function isEnabled(connection, name) {
+    return !!connection.enabled && connection.enabled.indexOf(name) >= 0;
+}
+export default function enablePlugin(server) {
+    server.registerCapability('ENABLE');
+    // Shared with plugins that can be enabled, these might be loaded before or after this one
+    server.enableAvailable = server.enableAvailable || [];
+    server.connectionHandlers.push((connection) => {
+        connection.enabled = connection.enabled || [];
+    });
+    // RFC 8437 section 4.1: extensions enabled with ENABLE cease to be enabled after UNAUTHENTICATE
+    server.resetHandlers.push((connection) => {
+        connection.enabled = [];
+    });
+    server.setCommandHandler('ENABLE', (connection, parsed, data, callback) => {
+        let capability;
+        let i;
+        let len;
+        // RFC 5161 section 3.1: "Clients MUST NOT issue ENABLE once they SELECT/EXAMINE a mailbox".
+        // Servers do not have to check this, ImapKit does to catch the client bug.
+        if (connection.everSelected) {
+            connection.sendStatus(parsed, data, 'BAD', 'ENABLE is not allowed after SELECT or EXAMINE');
+            return callback();
+        }
+        if (!parsed.attributes) {
+            connection.send({
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'ENABLE expects capability list'
+                    }
+                ]
+            }, 'INVALID COMMAND', parsed, data);
+            return callback();
+        }
+        for (i = 0, len = parsed.attributes.length; i < len; i++) {
+            if (!parsed.attributes[i] || parsed.attributes[i].type !== 'ATOM') {
+                connection.send({
+                    tag: parsed.tag,
+                    command: 'BAD',
+                    attributes: [
+                        {
+                            type: 'TEXT',
+                            value: 'Attribute nr ' + (i + 1) + ' is not an ATOM'
+                        }
+                    ]
+                }, 'INVALID COMMAND', parsed, data);
+                return callback();
+            }
+        }
+        // The ENABLED response lists only the extensions enabled by this command
+        // Capability names are matched case-insensitively and listed in the spelling the server advertises them
+        // (`server.enableAvailable`), e.g. "IMAP4rev2", so plugins look them up in `connection.enabled` by that name
+        const enabled = [];
+        for (i = 0, len = parsed.attributes.length; i < len; i++) {
+            const requested = parsed.attributes[i].value.toUpperCase();
+            capability = server.enableAvailable.find((name) => name.toUpperCase() === requested);
+            if (capability && connection.enabled.indexOf(capability) < 0) {
+                connection.enabled.push(capability);
+                enabled.push(capability);
+            }
+        }
+        connection.send({
+            tag: '*',
+            command: 'ENABLED',
+            attributes: enabled.map(capability => ({
+                type: 'ATOM',
+                value: capability
+            }))
+        }, 'ENABLED', parsed, data, enabled);
+        connection.send({
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'ENABLE completed'
+                }
+            ]
+        }, 'ENABLE', parsed, data);
+        return callback();
+    }, { states: states.AUTHENTICATED });
+}
+export { registerEnable, isEnabled };

package/dist/esm/plugins/esearch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @help Adds ESEARCH [RFC4731] capability
+ * @help SEARCH and UID SEARCH take the RETURN (MIN MAX ALL COUNT) result options and answer with ESEARCH
+ */
+import type { IMAPServer } from '../types.js';
+export default function esearchPlugin(server: IMAPServer): void;