imapkit 0.0.0-stage → 4.0.1

package/lib/commands/copy.js

@@ -0,0 +1,115 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    return copyMessages(connection, parsed, data, callback, false);
+};
+
+/**
+ * Shared implementation of COPY and UID COPY
+ *
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ */
+function copyMessages(connection, parsed, data, callback, isUid) {
+    const command = isUid ? 'UID COPY' : 'COPY';
+
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        ['ATOM', 'STRING', 'LITERAL'].indexOf(parsed.attributes[1].type) < 0
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: command + ' expects sequence set and a mailbox name'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const result = copyToMailbox(connection, parsed, data, isUid, command + ' FAIL');
+    if (!result) {
+        return callback();
+    }
+
+    // the result is the extra context info for UIDPLUS
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' Completed'
+                }
+            ]
+        },
+        command,
+        parsed,
+        data,
+        result
+    );
+    callback();
+}
+
+/**
+ * Copies messages from the selected mailbox to another one, the copy step of COPY and MOVE.
+ * Sends a tagged NO and returns false if the target mailbox can not be used.
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} parsed Parsed command, with the sequence set and the mailbox name as arguments
+ * @param {String} data Raw command
+ * @param {Boolean} isUid If true, the sequence set holds UID values
+ * @param {String} failDescription Description for the failure response
+ * @param {Boolean} [isMove] If true, the messages are moved, the caller expunges them afterwards
+ * @return {Object|false} `{ mailbox, sourceUids, targetUids, messages }`, where messages lists the copied source messages
+ */
+function copyToMailbox(connection, parsed, data, isUid, failDescription, isMove) {
+    const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
+    const mailbox = connection.getTargetMailbox(parsed.attributes[1].value, parsed, data, failDescription);
+    if (!mailbox) {
+        return false;
+    }
+
+    const messages = range.map(rangeMessage => rangeMessage[1]);
+    if (messages.some(message => message.ghost)) {
+        // RFC 2180 section 4.4.1: nothing is copied when the set includes a message that another session expunged,
+        // the pending EXPUNGE responses go out before the NO
+        connection.sendStatus(parsed, data, 'NO', 'Some of the requested messages no longer exist', 'EXPUNGEISSUED', failDescription);
+        return false;
+    }
+
+    if (!connection.checkAppend(mailbox, messages, parsed, data, failDescription, { move: !!isMove, source: connection.selectedMailbox })) {
+        return false;
+    }
+
+    const sourceUids = [];
+    const targetUids = [];
+    // a range that is processed from the highest UID down (parsed.highestFirst) is still copied in UID order,
+    // so the new UIDs follow the order of the source UIDs (RFC 9738 section 3.1 MOVE example)
+    (parsed.highestFirst ? messages.slice().reverse() : messages).forEach(message => {
+        sourceUids.push(message.uid);
+        targetUids.push(connection.server.copyMessage(mailbox, message).message.uid);
+    });
+
+    return {
+        mailbox,
+        sourceUids,
+        targetUids,
+        messages
+    };
+}
+
+module.exports.copyMessages = copyMessages;
+module.exports.copyToMailbox = copyToMailbox;

package/lib/commands/create.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'CREATE expects mailbox name'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const path = parsed.attributes[0].value;
+
+    let mailbox;
+    try {
+        mailbox = connection.server.createMailbox(path);
+    } catch (E) {
+        // RFC 5530 response codes, e.g. [ALREADYEXISTS]
+        connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'CREATE FAILED');
+        return callback();
+    }
+    connection.server.mailboxChanged('create', mailbox.path);
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'CREATE completed'
+                }
+            ]
+        },
+        'CREATE',
+        parsed,
+        data,
+        mailbox
+    );
+    return callback();
+};

package/lib/commands/delete.js

@@ -0,0 +1,64 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: 'DELETE expects mailbox name'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const path = parsed.attributes[0].value;
+
+    const mailbox = connection.server.getMailbox(path);
+
+    if (!mailbox) {
+        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', 'DELETE FAILED');
+        return callback();
+    }
+
+    try {
+        connection.server.deleteMailbox(path);
+    } catch (E) {
+        connection.sendStatus(parsed, data, 'NO', E.message, E.code, 'DELETE FAILED');
+        return callback();
+    }
+    connection.server.mailboxChanged('delete', mailbox.path, { mailbox });
+
+    // RFC 2180 section 3.3: the other sessions that have the mailbox selected are disconnected with an untagged
+    // BYE (RFC 2683 section 3.1.2), as they can not be told about the deletion in any other way
+    connection.server.connections.forEach(other => {
+        if (other !== connection && other.selectedMailbox === mailbox) {
+            other.bye('Selected mailbox was deleted', 'MAILBOX DELETED');
+        }
+    });
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'DELETE completed'
+                }
+            ]
+        },
+        'DELETE',
+        parsed,
+        data
+    );
+    return callback();
+};

package/lib/commands/examine.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { selectMailbox } = require('./select');
+
+module.exports = function (connection, parsed, data, callback) {
+    return selectMailbox(connection, parsed, data, callback, true);
+};

package/lib/commands/expunge.js

@@ -0,0 +1,27 @@
+'use strict';
+
+module.exports = function (connection, parsed, data, callback) {
+    if (connection.refuseReadOnly(parsed, data, 'EXPUNGE FAILED')) {
+        return callback();
+    }
+
+    connection.expungeDeleted(connection.selectedMailbox, false, true);
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'EXPUNGE Completed'
+                }
+            ]
+        },
+        'EXPUNGE',
+        parsed,
+        data
+    );
+
+    callback();
+};

package/lib/commands/fetch.js

@@ -0,0 +1,229 @@
+'use strict';
+
+const fetchHandlers = require('./handlers/fetch');
+
+const macros = {
+    ALL: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE', 'ENVELOPE'],
+    FAST: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE'],
+    FULL: ['FLAGS', 'INTERNALDATE', 'RFC822.SIZE', 'ENVELOPE', 'BODY']
+};
+
+/**
+ * Returns the item names as they appear in a FETCH response, without .PEEK and only with the origin
+ * octet of a partial range (RFC 3501 section 7.4.2)
+ *
+ * @param {Array} params Fetch items
+ * @return {Array} names
+ */
+function responseNames(params) {
+    return params.map(param => {
+        const name = Object.assign({}, param, { value: param.value.replace(/\.PEEK\b/i, '') });
+        if (name.partial) {
+            name.partial = name.partial.slice(0, 1);
+        }
+        return name;
+    });
+}
+
+/**
+ * Returns the handlers of fetch items
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Array} params Fetch items
+ * @return {Array} handlers
+ * @throws {Error} for an unknown item
+ */
+function getHandlers(connection, params) {
+    return params.map((param, i) => {
+        const key = (param.value || '').toUpperCase();
+        const handler = connection.server.fetchHandlers[key] || fetchHandlers[key];
+        if (!handler) {
+            throw new Error('Invalid FETCH argument ' + (key ? ' ' + key : '#' + (i + 1)));
+        }
+        return handler;
+    });
+}
+
+/**
+ * Builds the data list of a FETCH response for a message, without any side effects like setting \Seen
+ *
+ * @param {Object} connection IMAP connection
+ * @param {Object} message Message object
+ * @param {Array} params Fetch items
+ * @param {Array} [handlers] Handlers from getHandlers
+ * @param {Array} [names] Names from responseNames
+ * @return {Array} FETCH data items
+ * @throws {Error} for an unknown item or invalid item arguments
+ */
+function fetchResponse(connection, message, params, handlers, names) {
+    handlers = handlers || getHandlers(connection, params);
+    names = names || responseNames(params);
+    const response = [];
+    params.forEach((param, i) => response.push(names[i], handlers[i](connection, message, param)));
+    return response;
+}
+
+/**
+ * Shared implementation of FETCH and UID FETCH
+ *
+ * @param {Boolean} isUid If true, the sequence set lists UIDs and UID is always included in the response
+ */
+function processFetch(isUid, connection, parsed, data, callback) {
+    const command = isUid ? 'UID FETCH' : 'FETCH';
+
+    if (
+        !parsed.attributes ||
+        parsed.attributes.length !== 2 ||
+        !parsed.attributes[0] ||
+        ['ATOM', 'SEQUENCE'].indexOf(parsed.attributes[0].type) < 0 ||
+        !parsed.attributes[1] ||
+        (['ATOM'].indexOf(parsed.attributes[1].type) < 0 && !Array.isArray(parsed.attributes[1]))
+    ) {
+        connection.send(
+            {
+                tag: parsed.tag,
+                command: 'BAD',
+                attributes: [
+                    {
+                        type: 'TEXT',
+                        value: command + ' expects sequence set and message item names'
+                    }
+                ]
+            },
+            'INVALID COMMAND',
+            parsed,
+            data
+        );
+        return callback();
+    }
+
+    const range = connection.limitRange(parsed, connection.getCommandRange(parsed.attributes[0].value, isUid));
+    let params = [].concat(parsed.attributes[1] || []);
+
+    if (parsed.attributes[1].type === 'ATOM' && Object.prototype.hasOwnProperty.call(macros, parsed.attributes[1].value.toUpperCase())) {
+        params = macros[parsed.attributes[1].value.toUpperCase()].slice();
+    }
+
+    // messages that get \Seen set by this FETCH
+    const seen = [];
+    // untagged FETCH responses and their messages
+    const responses = [];
+    const messages = [];
+
+    try {
+        let uidExist = false;
+        let flagsExist = false;
+        let forceSeen = false;
+
+        params.forEach((param, i) => {
+            if (!param || (typeof param !== 'string' && param.type !== 'ATOM')) {
+                throw new Error('Invalid FETCH argument #' + (i + 1));
+            }
+
+            if (typeof param === 'string') {
+                param = params[i] = {
+                    type: 'ATOM',
+                    value: param
+                };
+            }
+
+            const key = param.value.toUpperCase();
+
+            if (key === 'FLAGS') {
+                flagsExist = true;
+            }
+
+            if (key === 'UID') {
+                uidExist = true;
+            }
+
+            // RFC 3501 6.4.5: BODY[<section>] and items whose handler is marked with setsSeen set \Seen
+            const handler = connection.server.fetchHandlers[key] || fetchHandlers[key];
+            if (connection.canSetSeen() && ((key === 'BODY' && param.section) || (handler && handler.setsSeen))) {
+                forceSeen = true;
+            }
+        });
+
+        if (forceSeen && !flagsExist) {
+            params.push({
+                type: 'ATOM',
+                value: 'FLAGS'
+            });
+        }
+
+        if (isUid && !uidExist) {
+            params.push({
+                type: 'ATOM',
+                value: 'UID'
+            });
+        }
+
+        const handlers = getHandlers(connection, params);
+
+        // item names as they appear in the response
+        const names = responseNames(params);
+
+        // nothing is sent before every message is done, so a failing item leaves no partial output
+        range.forEach(rangeMessage => {
+            for (let i = 0, len = connection.server.fetchFilters.length; i < len; i++) {
+                if (!connection.server.fetchFilters[i](connection, rangeMessage[1], parsed, rangeMessage[0])) {
+                    return;
+                }
+            }
+
+            if (forceSeen && rangeMessage[1].flags.indexOf('\\Seen') < 0) {
+                rangeMessage[1].flags.push('\\Seen');
+                seen.push(rangeMessage[1]);
+            }
+
+            const response = fetchResponse(connection, rangeMessage[1], params, handlers, names);
+
+            messages.push(rangeMessage[1]);
+            responses.push({
+                tag: '*',
+                attributes: [
+                    rangeMessage[0],
+                    {
+                        type: 'ATOM',
+                        value: 'FETCH'
+                    },
+                    response
+                ]
+            });
+        });
+    } catch (E) {
+        // the failed FETCH did not set \Seen after all
+        seen.forEach(message => connection.server.removeFlag(message.flags, '\\Seen'));
+        // a handler can fail with NO and a response code, e.g. NO [UNKNOWN-CTE] (RFC 3516 section 4.3)
+        connection.sendStatus(parsed, data, E.imapResponse === 'NO' ? 'NO' : 'BAD', E.message, E.code, command + ' FAILED');
+        return callback();
+    }
+
+    // the message goes with its response, for output handlers
+    responses.forEach((response, i) => connection.send(response, command, parsed, data, messages[i]));
+
+    connection.send(
+        {
+            tag: parsed.tag,
+            command: 'OK',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: command + ' Completed'
+                }
+            ]
+        },
+        command,
+        parsed,
+        data
+    );
+
+    // other sessions that have the mailbox selected learn about the new flags (RFC 3501 section 5.2)
+    connection.notifyFlagChanges(seen);
+    return callback();
+}
+
+module.exports = (connection, parsed, data, callback) => processFetch(false, connection, parsed, data, callback);
+module.exports.processFetch = processFetch;
+module.exports.macros = macros;
+module.exports.fetchResponse = fetchResponse;