imapkit 4.0.3 → 4.1.0

package/lib/commands/close.js

@@ -1,30 +0,0 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    // a read-only mailbox is closed without removing anything
-    if (connection.canExpunge()) {
-        connection.expungeDeleted(connection.selectedMailbox, true);
-    }
-
-    // CLOSE does not send pending EXPUNGE or EXISTS responses (RFC 3501 section 6.4.2)
-    connection.notificationQueue = [];
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'Mailbox closed'
-                }
-            ]
-        },
-        'CLOSE',
-        parsed,
-        data
-    );
-
-    connection.closeMailbox();
-    return callback();
-};

package/lib/commands/examine.js

@@ -1,7 +0,0 @@
-'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

@@ -1,27 +0,0 @@
-'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/list.js

@@ -1,100 +0,0 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    let folders;
-
-    if (
-        !parsed.attributes ||
-        parsed.attributes.length !== 2 ||
-        !parsed.attributes[0] ||
-        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
-        !parsed.attributes[1] ||
-        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0
-    ) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: 'LIST expects 2 string arguments'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
-        return callback();
-    }
-
-    if (!parsed.attributes[1].value) {
-        // empty reference lists separator only
-        const namespace = connection.server.storage[parsed.attributes[1].value || connection.server.referenceNamespace];
-        if (namespace) {
-            connection.send(
-                {
-                    tag: '*',
-                    command: 'LIST',
-                    attributes: [
-                        [
-                            {
-                                type: 'ATOM',
-                                value: '\\Noselect'
-                            }
-                        ],
-                        namespace.separator,
-                        ''
-                    ]
-                },
-                'LIST ITEM',
-                parsed,
-                data
-            );
-        }
-    } else {
-        folders = connection.server.matchFolders(parsed.attributes[0].value, parsed.attributes[1].value, path => connection.exportMailboxName(path));
-
-        folders.forEach(folder => {
-            connection.send(
-                {
-                    tag: '*',
-                    command: 'LIST',
-                    attributes: [
-                        folder.flags.map(flag => {
-                            return {
-                                type: 'ATOM',
-                                value: flag
-                            };
-                        }),
-                        connection.server.getSeparator(folder),
-                        connection.exportMailboxName(folder.path)
-                    ]
-                },
-                'LIST ITEM',
-                parsed,
-                data,
-                folder
-            );
-        });
-    }
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'Completed'
-                }
-            ]
-        },
-        'LIST',
-        parsed,
-        data
-    );
-
-    return callback();
-};

package/lib/commands/logout.js

@@ -1,41 +0,0 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    connection.state = 'Logout';
-
-    connection.send(
-        {
-            tag: '*',
-            command: 'BYE',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'LOGOUT received'
-                }
-            ]
-        },
-        'LOGOUT UNTAGGED',
-        parsed,
-        data
-    );
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'Completed'
-                }
-            ]
-        },
-        'LOGOUT COMPLETED',
-        parsed,
-        data
-    );
-
-    connection.end();
-
-    callback();
-};

package/lib/commands/lsub.js

@@ -1,87 +0,0 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    if (
-        !parsed.attributes ||
-        parsed.attributes.length !== 2 ||
-        !parsed.attributes[0] ||
-        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0 ||
-        !parsed.attributes[1] ||
-        ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[1].type) < 0
-    ) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: 'LSUB expects 2 string arguments'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
-        return callback();
-    }
-
-    const server = connection.server;
-    const match = parsed.attributes[1].value;
-    const folders = server.matchFolders(parsed.attributes[0].value, match, path => connection.exportMailboxName(path), server.getSubscriptionTree());
-
-    folders.forEach(folder => {
-        let flags;
-        if (folder.subscribed) {
-            // the subscription list holds names, a subscribed name is listed even if the mailbox does not exist.
-            // \Noselect has a special meaning in LSUB (RFC 5258 section 3.1), so it is not listed for these
-            flags = folder.flags.filter(flag => flag !== '\\Noselect');
-        } else if (match.substr(-1) === '%') {
-            // RFC 3501 section 6.3.9: with "%" a level that is not subscribed but has subscribed names
-            // below it is listed with \Noselect
-            flags = ['\\Noselect'];
-        } else {
-            return;
-        }
-
-        connection.send(
-            {
-                tag: '*',
-                command: 'LSUB',
-                attributes: [
-                    flags.map(flag => {
-                        return {
-                            type: 'ATOM',
-                            value: flag
-                        };
-                    }),
-                    server.getSeparator(folder),
-                    connection.exportMailboxName(folder.path)
-                ]
-            },
-            'LSUB ITEM',
-            parsed,
-            data,
-            folder
-        );
-    });
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'Completed'
-                }
-            ]
-        },
-        'LSUB',
-        parsed,
-        data
-    );
-
-    return callback();
-};

package/lib/commands/noop.js

@@ -1,21 +0,0 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'Completed'
-                }
-            ]
-        },
-        'NOOP completed',
-        parsed,
-        data
-    );
-
-    callback();
-};

package/lib/commands/search.js

@@ -1,76 +0,0 @@
-'use strict';
-
-const makeSearch = require('./handlers/search');
-const { criteriaValues, sendSearchError } = makeSearch;
-
-/**
- * Shared implementation of SEARCH and UID SEARCH
- *
- * @param {Boolean} isUid If true, the response lists UIDs instead of sequence numbers
- */
-function processSearch(isUid, connection, parsed, data, callback) {
-    const command = isUid ? 'UID SEARCH' : 'SEARCH';
-
-    if (!parsed.attributes || !parsed.attributes.length) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: command + ' expects search criteria, empty query given'
-                    }
-                ]
-            },
-            command + ' FAILED',
-            parsed,
-            data
-        );
-        return callback();
-    }
-
-    let searchResult;
-    try {
-        searchResult = makeSearch(connection, connection.getSessionMessages(), criteriaValues(parsed.attributes));
-    } catch (E) {
-        sendSearchError(connection, parsed, data, E, command + ' FAILED');
-        return callback();
-    }
-
-    // RFC 3501 7.2.5: the SEARCH response is sent even when nothing matched. Plugins get the
-    // search result, so they can extend the response or replace it (e.g. ESEARCH)
-    connection.send(
-        {
-            tag: '*',
-            command: 'SEARCH',
-            attributes: searchResult.list.map(item => {
-                return isUid ? item.uid : searchResult.numbers[item.uid];
-            })
-        },
-        command,
-        parsed,
-        data,
-        searchResult
-    );
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: command + ' completed'
-                }
-            ]
-        },
-        command,
-        parsed,
-        data
-    );
-    return callback();
-}
-
-module.exports = (connection, parsed, data, callback) => processSearch(false, connection, parsed, data, callback);
-module.exports.processSearch = processSearch;

package/lib/commands/select.js

@@ -1,289 +0,0 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
-    return selectMailbox(connection, parsed, data, callback, false);
-};
-
-/**
- * Starts a SELECT or EXAMINE, also one that is going to fail: ENABLE is not allowed once a mailbox has been selected
- * (RFC 5161 section 3.1), and the selected mailbox gets closed. CLOSED marks where the responses for the new mailbox
- * start (RFC 7162 section 3.2.11, RFC 9051 sections 6.3.2 and 7.1)
- *
- * @param {Object} connection IMAP connection
- * @param {Object} parsed Parsed command
- * @param {String} data Raw command
- */
-function beginSelect(connection, parsed, data) {
-    connection.everSelected = true;
-
-    if (connection.state === 'Selected' && connection.server.closedChecks.some(check => check(connection))) {
-        connection.send(
-            {
-                tag: '*',
-                command: 'OK',
-                attributes: [
-                    { type: 'SECTION', section: [{ type: 'ATOM', value: 'CLOSED' }] },
-                    { type: 'TEXT', value: 'Previous mailbox closed' }
-                ]
-            },
-            'CLOSED',
-            parsed,
-            data
-        );
-    }
-}
-
-/**
- * Shared implementation of SELECT and EXAMINE
- *
- * @param {Boolean} readOnly If true, the mailbox is opened read-only (EXAMINE)
- */
-function selectMailbox(connection, parsed, data, callback, readOnly) {
-    const command = readOnly ? 'EXAMINE' : 'SELECT';
-
-    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: command + ' expects 1 mailbox argument'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
-        return callback();
-    }
-
-    const path = parsed.attributes[0].value;
-
-    beginSelect(connection, parsed, data);
-
-    const mailbox = connection.server.getMailbox(path);
-
-    if (!mailbox || mailbox.flags.indexOf('\\Noselect') >= 0) {
-        // a failed SELECT leaves no mailbox selected (RFC 3501 section 6.3.1)
-        connection.closeMailbox();
-
-        connection.sendStatus(parsed, data, 'NO', 'Mailbox does not exist', 'NONEXISTENT', command + ' FAILED');
-        return callback();
-    }
-
-    connection.state = 'Selected';
-    connection.selectedMailbox = mailbox;
-    connection.readOnly = readOnly;
-
-    connection.notificationQueue = [];
-
-    // \Recent is a session flag: a read-write session takes over the messages
-    // that no other session has seen yet (RFC 3501 section 2.3.2)
-    connection.recent = new Set();
-    mailbox.messages.forEach(message => {
-        if (message.recent) {
-            connection.recent.add(message);
-            if (!readOnly) {
-                delete message.recent;
-            }
-        }
-    });
-
-    const status = connection.server.getStatus(mailbox);
-    const permanentFlags = status.permanentFlags.map(flag => {
-        return {
-            type: 'ATOM',
-            value: flag
-        };
-    });
-
-    connection.send(
-        {
-            tag: '*',
-            command: 'FLAGS',
-            attributes: [permanentFlags]
-        },
-        command + ' FLAGS',
-        parsed,
-        data
-    );
-
-    if (mailbox.allowPermanentFlags) {
-        permanentFlags.push({
-            type: 'TEXT',
-            value: '\\*'
-        });
-    }
-
-    connection.send(
-        {
-            tag: '*',
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'SECTION',
-                    section: [
-                        {
-                            type: 'ATOM',
-                            value: 'PERMANENTFLAGS'
-                        },
-                        // nothing can be changed in a read-only mailbox
-                        readOnly ? [] : permanentFlags
-                    ]
-                },
-                {
-                    type: 'TEXT',
-                    value: readOnly ? 'No permanent flags permitted' : 'Flags permitted'
-                }
-            ]
-        },
-        command + ' PERMANENTFLAGS',
-        parsed,
-        data
-    );
-
-    connection.send(
-        {
-            tag: '*',
-            attributes: [
-                mailbox.messages.length,
-                {
-                    type: 'ATOM',
-                    value: 'EXISTS'
-                }
-            ]
-        },
-        command + ' EXISTS',
-        parsed,
-        data
-    );
-
-    connection.send(
-        {
-            tag: '*',
-            attributes: [
-                connection.recent.size,
-                {
-                    type: 'ATOM',
-                    value: 'RECENT'
-                }
-            ]
-        },
-        command + ' RECENT',
-        parsed,
-        data
-    );
-
-    const firstUnseen = mailbox.messages.findIndex(message => message.flags.indexOf('\\Seen') < 0);
-    if (firstUnseen >= 0) {
-        connection.send(
-            {
-                tag: '*',
-                command: 'OK',
-                attributes: [
-                    {
-                        type: 'SECTION',
-                        section: [
-                            {
-                                type: 'ATOM',
-                                value: 'UNSEEN'
-                            },
-                            firstUnseen + 1
-                        ]
-                    },
-                    {
-                        type: 'TEXT',
-                        value: 'First unseen message'
-                    }
-                ]
-            },
-            command + ' UNSEEN',
-            parsed,
-            data
-        );
-    }
-
-    connection.send(
-        {
-            tag: '*',
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'SECTION',
-                    section: [
-                        {
-                            type: 'ATOM',
-                            value: 'UIDVALIDITY'
-                        },
-                        mailbox.uidvalidity
-                    ]
-                },
-                {
-                    type: 'TEXT',
-                    value: 'UIDs valid'
-                }
-            ]
-        },
-        command + ' UIDVALIDITY',
-        parsed,
-        data
-    );
-
-    connection.send(
-        {
-            tag: '*',
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'SECTION',
-                    section: [
-                        {
-                            type: 'ATOM',
-                            value: 'UIDNEXT'
-                        },
-                        mailbox.uidnext
-                    ]
-                },
-                {
-                    type: 'TEXT',
-                    value: 'Predicted next UID'
-                }
-            ]
-        },
-        command + ' UIDNEXT',
-        parsed,
-        data
-    );
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'SECTION',
-                    section: [
-                        {
-                            type: 'ATOM',
-                            value: readOnly ? 'READ-ONLY' : 'READ-WRITE'
-                        }
-                    ]
-                },
-                {
-                    type: 'TEXT',
-                    value: 'Completed'
-                }
-            ]
-        },
-        command,
-        parsed,
-        data
-    );
-    return callback();
-}
-
-module.exports.selectMailbox = selectMailbox;
-module.exports.beginSelect = beginSelect;

package/lib/commands/uid copy.js

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

package/lib/commands/uid fetch.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const { processFetch } = require('./fetch');
-
-module.exports = (connection, parsed, data, callback) => processFetch(true, connection, parsed, data, callback);

package/lib/commands/uid search.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const { processSearch } = require('./search');
-
-module.exports = (connection, parsed, data, callback) => processSearch(true, connection, parsed, data, callback);