imapflow 1.0.107 → 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/commands/namespace.js

@@ -81,31 +81,6 @@ async function getListPrefix(connection) {
             }
         });
         response.next();
-        if (map.flags.has('\\Noselect') && map.delimiter) {
-            // can not use root namespace
-            let inboxEntry = {};
-            response = await connection.exec('LIST', ['INBOX', ''], {
-                untagged: {
-                    LIST: async untagged => {
-                        if (!untagged.attributes || !untagged.attributes.length) {
-                            return;
-                        }
-
-                        inboxEntry.flags = new Set(untagged.attributes[0].map(entry => entry.value));
-                        inboxEntry.delimiter = untagged.attributes[1] && untagged.attributes[1].value;
-                        inboxEntry.prefix = (untagged.attributes[2] && untagged.attributes[2].value) || '';
-
-                        if (inboxEntry.delimiter && inboxEntry.prefix.charAt(0) === inboxEntry.delimiter) {
-                            inboxEntry.prefix = inboxEntry.prefix.slice(1);
-                        }
-                    }
-                }
-            });
-            response.next();
-            if (inboxEntry) {
-                return inboxEntry;
-            }
-        }
         return map;
     } catch (err) {
         connection.log.warn({ err, cid: connection.id });

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.107",
+    "version": "1.0.109",
     "description": "IMAP Client for Node",
     "main": "./lib/imap-flow.js",
     "scripts": {
@@ -27,13 +27,13 @@
     },
     "homepage": "https://imapflow.com/",
     "devDependencies": {
-        "@babel/eslint-parser": "7.18.9",
-        "@babel/eslint-plugin": "7.18.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.18.10",
-        "@types/node": "18.7.14",
+        "@babel/preset-env": "7.19.3",
+        "@types/node": "18.7.23",
         "braintree-jsdoc-template": "3.3.0",
-        "eslint": "8.23.0",
+        "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.4.2",
+        "nodemailer": "6.8.0",
+        "pino": "8.6.1",
         "socks": "2.7.0"
     }
 }