imapflow 1.0.108 → 1.0.110

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+-   1.0.110 - 2022-10-10
+
+    -   Allow unicode atoms by default
+
+-   1.0.109 - 2022-09-29
+
+    -   New method `downloadMany`
+
 -   1.0.102 - 2022-08-18
 
     -   Added new option `{statusQuery: {<statusOptions>}` for `list()` method

package/lib/handler/token-parser.js

@@ -271,7 +271,8 @@ class TokenParser {
                             // Any ATOM supported char starts a new Atom sequence, otherwise throw an error
                             // Allow \ as the first char for atom to support system flags
                             // Allow % to support LIST '' %
-                            if (imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 && chr !== '\\' && chr !== '%') {
+                            // Allow 8bit characters (presumably unicode)
+                            if (imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 && chr !== '\\' && chr !== '%' && chr.charCodeAt(0) < 0x80) {
                                 throw new Error(`Unexpected char at position ${this.pos + i} [E10: ${JSON.stringify(chr)}]`);
                             }
 
@@ -336,6 +337,7 @@ class TokenParser {
                     // if the char is not ATOM compatible, throw. Allow \* as an exception
                     if (
                         imapFormalSyntax['ATOM-CHAR']().indexOf(chr) < 0 &&
+                        chr.charCodeAt(0) < 0x80 && // allow 8bit (presumably unicode) bytes
                         chr !== ']' &&
                         !(chr === '*' && this.currentNode.value === '\\') &&
                         (!this.parent || !this.parent.command || !['NO', 'BAD', 'OK'].includes(this.parent.command))

package/lib/imap-flow.js

@@ -2163,6 +2163,7 @@ class ImapFlow extends EventEmitter {
      * @typedef {Object} DownloadObject
      * @global
      * @property {Object} meta content metadata
+     * @property {number} meta.expectedSize The fetch response size
      * @property {String} meta.contentType Content-Type of the streamed file. If part was not set then this value is "message/rfc822"
      * @property {String} [meta.charset] Charset of the body part. Text parts are automaticaly converted to UTF-8, attachments are kept as is
      * @property {String} [meta.disposition] Content-Disposition of the streamed file
@@ -2451,6 +2452,137 @@ class ImapFlow extends EventEmitter {
         };
     }
 
+    /**
+     * Fetch multiple attachments as Buffer values
+     *
+     * @param {SequenceString} range UID or sequence number for the message to fetch
+     * @param {String} parts A list of bodystructure parts
+     * @param {Object} [options]
+     * @param {Boolean} [options.uid] If `true` then uses UID number instead of sequence number for `range`
+     * @returns {Promise<Object>} Download data object
+     *
+     * @example
+     * let mailbox = await client.mailboxOpen('INBOX');
+     * // download body part nr '1.2' from latest message
+     * let response = await client.downloadMany('*', ['2', '3]);
+     * process.stdout.write(response[2].content)
+     * process.stdout.write(response[3].content)
+     */
+    async downloadMany(range, parts, options) {
+        if (!this.mailbox) {
+            // no mailbox selected, nothing to do
+            return {};
+        }
+
+        options = Object.assign(
+            {
+                chunkSize: 64 * 1024,
+                maxBytes: Infinity
+            },
+            options || {}
+        );
+
+        let query = { bodyParts: [] };
+
+        for (let part of parts) {
+            query.bodyParts.push(part + '.mime');
+            query.bodyParts.push(part);
+        }
+
+        let response = await this.fetchOne(range, query, options);
+
+        if (!response || !response.bodyParts) {
+            return { response: false };
+        }
+
+        let data = {};
+
+        for (let [part, content] of response.bodyParts) {
+            let keyParts = part.split('.');
+            if (keyParts.length === 1) {
+                // content
+                let key = keyParts[0];
+                if (!data[key]) {
+                    data[key] = { content };
+                } else {
+                    data[key].content = content;
+                }
+            } else if (keyParts.length === 2) {
+                // header
+                let key = keyParts[0];
+                if (!data[key]) {
+                    data[key] = {};
+                }
+                if (!data[key].meta) {
+                    data[key].meta = {};
+                }
+
+                let headers = new Headers(content);
+                let contentType = libmime.parseHeaderValue(headers.getFirst('Content-Type'));
+                let transferEncoding = libmime.parseHeaderValue(headers.getFirst('Content-Transfer-Encoding'));
+                let disposition = libmime.parseHeaderValue(headers.getFirst('Content-Disposition'));
+
+                if (contentType.value.toLowerCase().trim()) {
+                    data[key].meta.contentType = contentType.value.toLowerCase().trim();
+                }
+
+                if (contentType.params.charset) {
+                    data[key].meta.charset = contentType.params.charset.toLowerCase().trim();
+                }
+
+                if (transferEncoding.value) {
+                    data[key].meta.encoding = transferEncoding.value
+                        .replace(/\(.*\)/g, '')
+                        .toLowerCase()
+                        .trim();
+                }
+
+                if (disposition.value) {
+                    data[key].meta.disposition = disposition.value.toLowerCase().trim() || false;
+                    try {
+                        data[key].meta.disposition = libmime.decodeWords(data[key].meta.disposition);
+                    } catch (err) {
+                        // failed to parse disposition, keep as is (most probably an unknown charset is used)
+                    }
+                }
+
+                if (contentType.params.format && contentType.params.format.toLowerCase().trim() === 'flowed') {
+                    data[key].meta.flowed = true;
+                    if (contentType.params.delsp && contentType.params.delsp.toLowerCase().trim() === 'yes') {
+                        data[key].meta.delSp = true;
+                    }
+                }
+
+                let filename = disposition.params.filename || contentType.params.name || false;
+                if (filename) {
+                    try {
+                        filename = this.libmime.decodeWords(filename);
+                    } catch (err) {
+                        // failed to parse filename, keep as is (most probably an unknown charset is used)
+                    }
+                    data[key].meta.filename = filename;
+                }
+            }
+        }
+
+        for (let part of Object.keys(data)) {
+            let meta = data[part].meta;
+
+            switch (meta.encoding) {
+                case 'base64':
+                    data[part].content = data[part].content ? libbase64.decode(data[part].content.toString()) : null;
+                    break;
+                case 'quoted-printable':
+                    data[part].content = data[part].content ? libqp.decode(data[part].content.toString()) : null;
+                    break;
+                default:
+                // keep as is, already a buffer
+            }
+        }
+
+        return data;
+    }
+
     async run(command, ...args) {
         command = command.toUpperCase();
         if (!this.commands.has(command)) {

package/lib/types.d.ts

@@ -478,6 +478,22 @@ declare module "imapflow" {
             maxBytes?: number;
             chunkSize?: number;
         }): Promise<DownloadObject>;
+        /**
+         * Fetch multiple attachments as Buffer values
+         * @example
+         * let mailbox = await client.mailboxOpen('INBOX');
+         * // download body part nr '1.2' from latest message
+         * let response = await client.downloadMany('*', ['2', '3]);
+         * process.stdout.write(response[2].content)
+         * process.stdout.write(response[3].content)
+         * @param range - UID or sequence number for the message to fetch
+         * @param parts - A list of bodystructure parts
+         * @param [options.uid] - If `true` then uses UID number instead of sequence number for `range`
+         * @returns Download data object
+         */
+        downloadMany(range: SequenceString, parts: string, options?: {
+            uid?: boolean;
+        }): Promise<object>;
         /**
          * Opens a mailbox if not already open and returns a lock. Next call to `getMailboxLock()` is queued
          * until previous lock is released. This is suggested over {@link module:imapflow~ImapFlow#mailboxOpen|mailboxOpen()} as
@@ -925,6 +941,7 @@ declare type FetchMessageObject = {
 
 /**
  * @property meta - content metadata
+ * @property meta.expectedSize - The fetch response size
  * @property meta.contentType - Content-Type of the streamed file. If part was not set then this value is "message/rfc822"
  * @property [meta.charset] - Charset of the body part. Text parts are automaticaly converted to UTF-8, attachments are kept as is
  * @property [meta.disposition] - Content-Disposition of the streamed file
@@ -933,6 +950,7 @@ declare type FetchMessageObject = {
  */
 declare type DownloadObject = {
     meta: {
+        expectedSize: number;
         contentType: string;
         charset?: string;
         disposition?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.108",
+    "version": "1.0.110",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -30,10 +30,10 @@
         "@babel/eslint-parser": "7.19.1",
         "@babel/eslint-plugin": "7.19.1",
         "@babel/plugin-syntax-class-properties": "7.12.13",
-        "@babel/preset-env": "7.19.1",
-        "@types/node": "18.7.18",
+        "@babel/preset-env": "7.19.3",
+        "@types/node": "18.8.3",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.23.1",
+        "eslint": "8.25.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "8.5.0",
         "grunt": "1.5.3",
@@ -51,8 +51,8 @@
         "libmime": "5.1.0",
         "libqp": "1.1.0",
         "mailsplit": "5.3.2",
-        "nodemailer": "6.7.8",
-        "pino": "8.6.0",
-        "socks": "2.7.0"
+        "nodemailer": "6.8.0",
+        "pino": "8.6.1",
+        "socks": "2.7.1"
     }
 }

package/test/imap-parser-test.js

@@ -941,3 +941,32 @@ module.exports['IMAP Parser, single quote in atom'] = test =>
             { type: 'ATOM', value: "'a" }
         ])
     );
+
+module.exports['IMAP Parser, unicode status 1'] = test =>
+    asyncWrapper(test, async test =>
+        test.deepEqual((await parser('* STATUS Segregator/Społeczności (MESSAGES 0 UIDNEXT 1 UIDVALIDITY 1)')).attributes, [
+            { type: 'ATOM', value: 'Segregator/Społeczności' },
+            [
+                { type: 'ATOM', value: 'MESSAGES' },
+                { type: 'ATOM', value: '0' },
+                { type: 'ATOM', value: 'UIDNEXT' },
+                { type: 'ATOM', value: '1' },
+                { type: 'ATOM', value: 'UIDVALIDITY' },
+                { type: 'ATOM', value: '1' }
+            ]
+        ])
+    );
+module.exports['IMAP Parser, unicode status 12'] = test =>
+    asyncWrapper(test, async test =>
+        test.deepEqual((await parser('* STATUS Šegregator/Społeczności (MESSAGES 0 UIDNEXT 1 UIDVALIDITY 1)')).attributes, [
+            { type: 'ATOM', value: 'Šegregator/Społeczności' },
+            [
+                { type: 'ATOM', value: 'MESSAGES' },
+                { type: 'ATOM', value: '0' },
+                { type: 'ATOM', value: 'UIDNEXT' },
+                { type: 'ATOM', value: '1' },
+                { type: 'ATOM', value: 'UIDVALIDITY' },
+                { type: 'ATOM', value: '1' }
+            ]
+        ])
+    );