imapflow 1.0.108 → 1.0.109

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+-   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/imap-flow.js

@@ -2451,6 +2451,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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "1.0.108",
+    "version": "1.0.109",
     "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.7.23",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.23.1",
+        "eslint": "8.24.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",
+        "nodemailer": "6.8.0",
+        "pino": "8.6.1",
         "socks": "2.7.0"
     }
 }