n8n-nodes-jmap 0.1.1 → 0.2.1

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

@@ -20,6 +20,7 @@ exports.getLabels = getLabels;
 exports.deleteEmails = deleteEmails;
 exports.getThreads = getThreads;
 exports.downloadBlob = downloadBlob;
+exports.getAttachments = getAttachments;
 const n8n_workflow_1 = require("n8n-workflow");
 // Standard JMAP capabilities
 exports.JMAP_CAPABILITIES = {
@@ -459,3 +460,170 @@ async function downloadBlob(accountId, blobId, name, type) {
         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');
+}
+/**
+ * Extract files from a ZIP archive
+ * Note: Archive extraction is not yet available (planned for future release with self-hosted support)
+ * Returns empty array, causing the archive to be returned as-is
+ */
+function extractZip(_buffer) {
+    // Archive extraction not yet implemented
+    // Will be available in a future release for self-hosted n8n
+    return [];
+}
+/**
+ * Extract files from a tar.gz archive
+ * Note: Archive extraction is not yet available (planned for future release with self-hosted support)
+ * Returns empty array, causing the archive to be returned as-is
+ */
+async function extractTarGz(_buffer) {
+    // Archive extraction not yet implemented
+    // Will be available in a future release for self-hosted n8n
+    return [];
+}
+/**
+ * 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;
+            }
+        }
+        // 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 (Coming Soon)',
+                            name: 'extractArchives',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Extract ZIP and tar.gz archives. Note: This feature is planned for a future release and currently returns archives as-is.',
+                        },
+                        {
+                            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.1",
+  "version": "0.2.1",
   "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",