n8n-nodes-jmap 0.2.1 → 0.2.3

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

@@ -123,11 +123,12 @@ export declare function downloadBlob(this: IExecuteFunctions, accountId: string,
  * Interface for attachment options
  */
 export interface IAttachmentOptions {
-    extractArchives?: boolean;
     includeInline?: boolean;
     mimeTypeFilter?: string;
 }
 /**
- * Get attachments from an email and return them as binary data
+ * Get attachments from an email and return them as binary data.
+ * Each attachment is returned as a separate item with binary data in the 'file' field.
+ * To extract archives (ZIP, tar.gz), chain with the n8n Compression node.
  */
 export declare function getAttachments(this: IExecuteFunctions, accountId: string, emailId: string, options?: IAttachmentOptions): Promise<INodeExecutionData[]>;

package/dist/nodes/Jmap/GenericFunctions.js

@@ -473,60 +473,12 @@ function matchesMimeType(mimeType, filter) {
     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
+ * Get attachments from an email and return them as binary data.
+ * Each attachment is returned as a separate item with binary data in the 'file' field.
+ * To extract archives (ZIP, tar.gz), chain with the n8n Compression node.
  */
 async function getAttachments(accountId, emailId, options = {}) {
-    const { extractArchives = false, includeInline = false, mimeTypeFilter = '' } = options;
+    const { includeInline = false, mimeTypeFilter = '' } = options;
     // Get email with attachments metadata
     const emails = await getEmails.call(this, accountId, [emailId], [
         'id',
@@ -561,63 +513,17 @@ async function getAttachments(accountId, emailId, 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)
+        // Prepare binary data for n8n
         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,
+                isInline: attachment.isInline || false,
             },
             binary: {
                 file: binaryData,

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

@@ -429,13 +429,6 @@ class Jmap {
                         },
                     },
                     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',
@@ -471,6 +464,89 @@ class Jmap {
                     default: 50,
                     description: 'Max number of results to return',
                 },
+                // Options for getMany (search filters)
+                {
+                    displayName: 'Options',
+                    name: 'getManyOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['getMany'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Flagged Only',
+                            name: 'flaggedOnly',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to return only flagged/starred emails',
+                        },
+                        {
+                            displayName: 'From Contains',
+                            name: 'from',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'sender@example.com',
+                            description: 'Filter emails where the From address contains this text',
+                        },
+                        {
+                            displayName: 'Full Text Search',
+                            name: 'text',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'search terms',
+                            description: 'Search in subject, body, and addresses',
+                        },
+                        {
+                            displayName: 'Has Attachment',
+                            name: 'hasAttachment',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to return only emails with attachments',
+                        },
+                        {
+                            displayName: 'Received After',
+                            name: 'after',
+                            type: 'dateTime',
+                            default: '',
+                            description: 'Filter emails received after this date',
+                        },
+                        {
+                            displayName: 'Received Before',
+                            name: 'before',
+                            type: 'dateTime',
+                            default: '',
+                            description: 'Filter emails received before this date',
+                        },
+                        {
+                            displayName: 'Subject Contains',
+                            name: 'subject',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'Invoice',
+                            description: 'Filter emails where the subject contains this text',
+                        },
+                        {
+                            displayName: 'To Contains',
+                            name: 'to',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'recipient@example.com',
+                            description: 'Filter emails where the To address contains this text',
+                        },
+                        {
+                            displayName: 'Unread Only',
+                            name: 'unreadOnly',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to return only unread emails',
+                        },
+                    ],
+                },
                 // ==================== MAILBOX PARAMETERS ====================
                 {
                     displayName: 'Mailbox ID',
@@ -637,10 +713,42 @@ class Jmap {
                     if (operation === 'getMany') {
                         const mailbox = this.getNodeParameter('mailbox', i);
                         const limit = this.getNodeParameter('limit', i);
+                        const options = this.getNodeParameter('getManyOptions', i);
                         const filter = {};
+                        // Mailbox filter
                         if (mailbox) {
                             filter.inMailbox = mailbox;
                         }
+                        // Date filters
+                        if (options.after) {
+                            filter.after = new Date(options.after).toISOString();
+                        }
+                        if (options.before) {
+                            filter.before = new Date(options.before).toISOString();
+                        }
+                        // Content filters
+                        if (options.from) {
+                            filter.from = options.from;
+                        }
+                        if (options.to) {
+                            filter.to = options.to;
+                        }
+                        if (options.subject) {
+                            filter.subject = options.subject;
+                        }
+                        if (options.text) {
+                            filter.text = options.text;
+                        }
+                        // Boolean filters
+                        if (options.hasAttachment) {
+                            filter.hasAttachment = true;
+                        }
+                        if (options.unreadOnly) {
+                            filter.notKeyword = '$seen';
+                        }
+                        if (options.flaggedOnly) {
+                            filter.hasKeyword = '$flagged';
+                        }
                         const { ids } = await GenericFunctions_1.queryEmails.call(this, accountId, filter, [{ property: 'receivedAt', isAscending: false }], limit);
                         if (ids.length > 0) {
                             responseData = await GenericFunctions_1.getEmails.call(this, accountId, ids);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-jmap",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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",