n8n-nodes-jmap 0.1.0 → 0.2.0

package/dist/nodes/Jmap/GenericFunctions.d.ts

@@ -1,4 +1,4 @@
-import type { IExecuteFunctions, ILoadOptionsFunctions, IPollFunctions, IDataObject } from 'n8n-workflow';
+import type { IExecuteFunctions, ILoadOptionsFunctions, IPollFunctions, IDataObject, INodeExecutionData } from 'n8n-workflow';
 export interface IJmapSession {
     accounts: {
         [key: string]: IJmapAccount;
@@ -119,3 +119,15 @@ export declare function getThreads(this: IExecuteFunctions | ILoadOptionsFunctio
  * Download an attachment blob
  */
 export declare function downloadBlob(this: IExecuteFunctions, accountId: string, blobId: string, name: string, type: string): Promise<Buffer>;
+/**
+ * Interface for attachment options
+ */
+export interface IAttachmentOptions {
+    extractArchives?: boolean;
+    includeInline?: boolean;
+    mimeTypeFilter?: string;
+}
+/**
+ * Get attachments from an email and return them as binary data
+ */
+export declare function getAttachments(this: IExecuteFunctions, accountId: string, emailId: string, options?: IAttachmentOptions): Promise<INodeExecutionData[]>;

package/dist/nodes/Jmap/GenericFunctions.js

@@ -1,4 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JMAP_CAPABILITIES = void 0;
 exports.getJmapSession = getJmapSession;
@@ -20,7 +56,10 @@ exports.getLabels = getLabels;
 exports.deleteEmails = deleteEmails;
 exports.getThreads = getThreads;
 exports.downloadBlob = downloadBlob;
+exports.getAttachments = getAttachments;
 const n8n_workflow_1 = require("n8n-workflow");
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const tar = __importStar(require("tar"));
 // Standard JMAP capabilities
 exports.JMAP_CAPABILITIES = {
     CORE: 'urn:ietf:params:jmap:core',
@@ -64,7 +103,7 @@ async function makeJmapRequest(context, method, endpoint, body) {
     const url = endpoint.startsWith('http') ? endpoint : `${serverUrl}${endpoint}`;
     if (authType === 'jmapOAuth2Api') {
         // Use n8n's built-in OAuth2 authentication
-        const response = await context.helpers.requestWithAuthentication.call(context, 'jmapOAuth2Api', {
+        const response = await context.helpers.httpRequestWithAuthentication.call(context, 'jmapOAuth2Api', {
             method,
             url,
             headers: {
@@ -80,29 +119,25 @@ async function makeJmapRequest(context, method, endpoint, body) {
         // Use Basic Auth or Bearer Token
         const credentials = await context.getCredentials('jmapApi');
         const authMethod = credentials.authMethod || 'basicAuth';
-        const options = {
-            method,
-            uri: url,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            body,
-            json: true,
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
         };
         if (authMethod === 'basicAuth') {
-            options.auth = {
-                user: credentials.email,
-                pass: credentials.password,
-            };
+            const authString = Buffer.from(`${credentials.email}:${credentials.password}`).toString('base64');
+            headers.Authorization = `Basic ${authString}`;
         }
         else if (authMethod === 'bearerToken') {
-            options.headers = {
-                ...options.headers,
-                Authorization: `Bearer ${credentials.accessToken}`,
-            };
+            headers.Authorization = `Bearer ${credentials.accessToken}`;
         }
-        const response = await context.helpers.request(options);
+        const options = {
+            method,
+            url,
+            headers,
+            body,
+            json: true,
+        };
+        const response = await context.helpers.httpRequest(options);
         return response;
     }
 }
@@ -435,32 +470,285 @@ async function downloadBlob(accountId, blobId, name, type) {
         .replace('{name}', encodeURIComponent(name))
         .replace('{type}', encodeURIComponent(type));
     if (authType === 'jmapOAuth2Api') {
-        const response = await this.helpers.requestWithAuthentication.call(this, 'jmapOAuth2Api', {
+        const response = await this.helpers.httpRequestWithAuthentication.call(this, 'jmapOAuth2Api', {
             method: 'GET',
             url: downloadUrl,
-            encoding: null,
+            encoding: 'arraybuffer',
         });
-        return response;
+        return Buffer.from(response);
     }
     else {
         const credentials = await this.getCredentials('jmapApi');
         const authMethod = credentials.authMethod || 'basicAuth';
+        const headers = {};
+        if (authMethod === 'basicAuth') {
+            const authString = Buffer.from(`${credentials.email}:${credentials.password}`).toString('base64');
+            headers.Authorization = `Basic ${authString}`;
+        }
+        else if (authMethod === 'bearerToken') {
+            headers.Authorization = `Bearer ${credentials.accessToken}`;
+        }
         const options = {
             method: 'GET',
-            uri: downloadUrl,
-            encoding: null,
+            url: downloadUrl,
+            headers,
+            encoding: 'arraybuffer',
         };
-        if (authMethod === 'basicAuth') {
-            options.auth = {
-                user: credentials.email,
-                pass: credentials.password,
-            };
+        const response = await this.helpers.httpRequest(options);
+        return Buffer.from(response);
+    }
+}
+/**
+ * Check if a MIME type matches a filter pattern
+ */
+function matchesMimeType(mimeType, filter) {
+    const normalizedMime = mimeType.toLowerCase();
+    const normalizedFilter = filter.toLowerCase().trim();
+    if (normalizedFilter.endsWith('/*')) {
+        const prefix = normalizedFilter.slice(0, -1);
+        return normalizedMime.startsWith(prefix);
+    }
+    return normalizedMime === normalizedFilter;
+}
+/**
+ * Check if a MIME type is a ZIP archive
+ */
+function isZipMimeType(mimeType) {
+    const zipTypes = [
+        'application/zip',
+        'application/x-zip-compressed',
+        'application/x-zip',
+    ];
+    return zipTypes.includes(mimeType.toLowerCase());
+}
+/**
+ * Check if a MIME type is a tar.gz archive
+ */
+function isTarGzMimeType(mimeType) {
+    const tarGzTypes = [
+        'application/gzip',
+        'application/x-gzip',
+        'application/x-tar',
+        'application/x-compressed-tar',
+    ];
+    return tarGzTypes.includes(mimeType.toLowerCase());
+}
+/**
+ * Check if filename suggests tar.gz
+ */
+function isTarGzFilename(filename) {
+    const lower = filename.toLowerCase();
+    return lower.endsWith('.tar.gz') || lower.endsWith('.tgz');
+}
+/**
+ * Get file extension from filename
+ */
+function getFileExtension(filename) {
+    const parts = filename.split('.');
+    if (parts.length > 1) {
+        return parts[parts.length - 1].toLowerCase();
+    }
+    return '';
+}
+/**
+ * Guess MIME type from filename extension
+ */
+function guessMimeType(filename) {
+    const ext = getFileExtension(filename).toLowerCase();
+    const mimeTypes = {
+        pdf: 'application/pdf',
+        doc: 'application/msword',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        xls: 'application/vnd.ms-excel',
+        xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        ppt: 'application/vnd.ms-powerpoint',
+        pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        txt: 'text/plain',
+        csv: 'text/csv',
+        json: 'application/json',
+        xml: 'application/xml',
+        html: 'text/html',
+        htm: 'text/html',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        png: 'image/png',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        webp: 'image/webp',
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        mp4: 'video/mp4',
+        avi: 'video/x-msvideo',
+        zip: 'application/zip',
+        tar: 'application/x-tar',
+        gz: 'application/gzip',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+/**
+ * Extract files from a ZIP archive
+ */
+function extractZip(buffer) {
+    const files = [];
+    const zip = new adm_zip_1.default(buffer);
+    const entries = zip.getEntries();
+    for (const entry of entries) {
+        if (!entry.isDirectory) {
+            const data = entry.getData();
+            const name = entry.entryName.split('/').pop() || entry.entryName;
+            files.push({
+                name,
+                data,
+                mimeType: guessMimeType(name),
+            });
         }
-        else if (authMethod === 'bearerToken') {
-            options.headers = {
-                Authorization: `Bearer ${credentials.accessToken}`,
-            };
+    }
+    return files;
+}
+/**
+ * Extract files from a tar.gz archive
+ */
+async function extractTarGz(buffer) {
+    const files = [];
+    return new Promise((resolve, reject) => {
+        const chunks = new Map();
+        const parser = new tar.Parser();
+        parser.on('entry', (entry) => {
+            if (entry.type === 'File') {
+                const entryChunks = [];
+                entry.on('data', (chunk) => {
+                    entryChunks.push(chunk);
+                });
+                entry.on('end', () => {
+                    const name = entry.path.split('/').pop() || entry.path;
+                    chunks.set(name, entryChunks);
+                });
+            }
+            else {
+                entry.resume();
+            }
+        });
+        parser.on('end', () => {
+            for (const [name, entryChunks] of chunks) {
+                const data = Buffer.concat(entryChunks);
+                files.push({
+                    name,
+                    data,
+                    mimeType: guessMimeType(name),
+                });
+            }
+            resolve(files);
+        });
+        parser.on('error', reject);
+        const { Gunzip } = require('zlib');
+        const gunzip = new Gunzip();
+        gunzip.pipe(parser);
+        gunzip.write(buffer);
+        gunzip.end();
+    });
+}
+/**
+ * Get attachments from an email and return them as binary data
+ */
+async function getAttachments(accountId, emailId, options = {}) {
+    const { extractArchives = false, includeInline = false, mimeTypeFilter = '' } = options;
+    // Get email with attachments metadata
+    const emails = await getEmails.call(this, accountId, [emailId], [
+        'id',
+        'subject',
+        'attachments',
+    ]);
+    if (emails.length === 0) {
+        throw new Error(`Email with ID ${emailId} not found`);
+    }
+    const email = emails[0];
+    const attachments = email.attachments || [];
+    if (attachments.length === 0) {
+        return [];
+    }
+    // Parse MIME type filters
+    const mimeFilters = mimeTypeFilter
+        ? mimeTypeFilter.split(',').map((f) => f.trim()).filter((f) => f)
+        : [];
+    const results = [];
+    let attachmentIndex = 0;
+    for (const attachment of attachments) {
+        // Filter by inline status
+        if (attachment.isInline && !includeInline) {
+            continue;
+        }
+        // Filter by MIME type
+        if (mimeFilters.length > 0) {
+            const matches = mimeFilters.some((filter) => matchesMimeType(attachment.type, filter));
+            if (!matches) {
+                continue;
+            }
         }
-        return await this.helpers.request(options);
+        // Download the attachment
+        const buffer = await downloadBlob.call(this, accountId, attachment.blobId, attachment.name, attachment.type);
+        // Check if this is an archive that should be extracted
+        const isZip = isZipMimeType(attachment.type);
+        const isTarGz = isTarGzMimeType(attachment.type) || isTarGzFilename(attachment.name);
+        if (extractArchives && (isZip || isTarGz)) {
+            // Extract archive contents
+            let extractedFiles = [];
+            try {
+                if (isZip) {
+                    extractedFiles = extractZip(buffer);
+                }
+                else if (isTarGz) {
+                    extractedFiles = await extractTarGz(buffer);
+                }
+            }
+            catch (error) {
+                // If extraction fails, return the archive as-is
+                extractedFiles = [];
+            }
+            if (extractedFiles.length > 0) {
+                // Return each extracted file as a separate item
+                for (const file of extractedFiles) {
+                    const binaryData = await this.helpers.prepareBinaryData(file.data, file.name, file.mimeType);
+                    results.push({
+                        json: {
+                            emailId: email.id,
+                            emailSubject: email.subject,
+                            attachmentIndex,
+                            originalFileName: attachment.name,
+                            fileName: file.name,
+                            mimeType: file.mimeType,
+                            fileSize: file.data.length,
+                            wasExtractedFromArchive: true,
+                            sourceArchiveName: attachment.name,
+                        },
+                        binary: {
+                            file: binaryData,
+                        },
+                    });
+                    attachmentIndex++;
+                }
+                continue;
+            }
+            // If extraction failed or no files, fall through to return the archive as-is
+        }
+        // Return the attachment as-is (not an archive, or extraction disabled/failed)
+        const binaryData = await this.helpers.prepareBinaryData(buffer, attachment.name, attachment.type);
+        results.push({
+            json: {
+                emailId: email.id,
+                emailSubject: email.subject,
+                attachmentIndex,
+                originalFileName: attachment.name,
+                fileName: attachment.name,
+                mimeType: attachment.type,
+                fileSize: attachment.size,
+                wasExtractedFromArchive: false,
+                sourceArchiveName: null,
+            },
+            binary: {
+                file: binaryData,
+            },
+        });
+        attachmentIndex++;
     }
+    return results;
 }

package/dist/nodes/Jmap/Jmap.node.js

@@ -115,6 +115,12 @@ class Jmap {
                             description: 'Get an email by ID',
                             action: 'Get an email',
                         },
+                        {
+                            name: 'Get Attachments',
+                            value: 'getAttachments',
+                            description: 'Download attachments from an email',
+                            action: 'Get attachments from an email',
+                        },
                         {
                             name: 'Get Labels',
                             value: 'getLabels',
@@ -221,7 +227,7 @@ class Jmap {
                     default: 'get',
                 },
                 // ==================== EMAIL PARAMETERS ====================
-                // Email ID (for get, delete, markAsRead, markAsUnread, move, reply, addLabel, removeLabel, getLabels)
+                // Email ID (for get, delete, markAsRead, markAsUnread, move, reply, addLabel, removeLabel, getLabels, getAttachments)
                 {
                     displayName: 'Email ID',
                     name: 'emailId',
@@ -230,7 +236,7 @@ class Jmap {
                     displayOptions: {
                         show: {
                             resource: ['email'],
-                            operation: ['get', 'delete', 'markAsRead', 'markAsUnread', 'move', 'reply', 'addLabel', 'removeLabel', 'getLabels'],
+                            operation: ['get', 'delete', 'markAsRead', 'markAsUnread', 'move', 'reply', 'addLabel', 'removeLabel', 'getLabels', 'getAttachments'],
                         },
                     },
                     default: '',
@@ -409,6 +415,44 @@ class Jmap {
                         },
                     ],
                 },
+                // Options for getAttachments
+                {
+                    displayName: 'Options',
+                    name: 'attachmentOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['getAttachments'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Extract Archives',
+                            name: 'extractArchives',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to extract ZIP and tar.gz archives and return their contents as individual files',
+                        },
+                        {
+                            displayName: 'Include Inline Images',
+                            name: 'includeInline',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to include inline images (embedded in the email body) in addition to regular attachments',
+                        },
+                        {
+                            displayName: 'Filter by MIME Type',
+                            name: 'mimeTypeFilter',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'application/pdf, image/*',
+                            description: 'Comma-separated list of MIME types to include. Supports wildcards (e.g., image/*). Leave empty to include all.',
+                        },
+                    ],
+                },
                 // Limit for getMany
                 {
                     displayName: 'Limit',
@@ -576,6 +620,20 @@ class Jmap {
                             count: labels.length,
                         };
                     }
+                    if (operation === 'getAttachments') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const attachmentOptions = this.getNodeParameter('attachmentOptions', i);
+                        const attachmentResults = await GenericFunctions_1.getAttachments.call(this, accountId, emailId, attachmentOptions);
+                        // getAttachments returns INodeExecutionData[] directly with binary data
+                        // Add them directly to returnData instead of using responseData
+                        for (const result of attachmentResults) {
+                            returnData.push({
+                                ...result,
+                                pairedItem: { item: i },
+                            });
+                        }
+                        continue; // Skip the normal responseData handling
+                    }
                     if (operation === 'getMany') {
                         const mailbox = this.getNodeParameter('mailbox', i);
                         const limit = this.getNodeParameter('limit', i);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-jmap",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "n8n community node for JMAP email protocol (RFC 8620/8621) - Works with Apache James, Twake Mail, Fastmail, and other JMAP-compatible servers",
   "keywords": [
     "n8n-community-node-package",
@@ -46,7 +46,9 @@
     ]
   },
   "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
     "@types/node": "^20.0.0",
+    "@types/tar": "^6.1.13",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "eslint": "^8.56.0",
@@ -57,5 +59,9 @@
   },
   "peerDependencies": {
     "n8n-workflow": "*"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "tar": "^7.5.2"
   }
 }