n8n-nodes-jmap 0.1.0

package/dist/nodes/Jmap/JmapTrigger.node.d.ts

@@ -0,0 +1,10 @@
+import { ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription, IPollFunctions } from 'n8n-workflow';
+export declare class JmapTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getMailboxes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+}

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

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JmapTrigger = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+class JmapTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'JMAP Trigger',
+            name: 'jmapTrigger',
+            icon: 'file:jmap.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Trigger workflow on new JMAP emails',
+            defaults: {
+                name: 'JMAP Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'jmapApi',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['jmapApi'],
+                        },
+                    },
+                },
+                {
+                    name: 'jmapOAuth2Api',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['jmapOAuth2Api'],
+                        },
+                    },
+                },
+            ],
+            polling: true,
+            properties: [
+                // Authentication selection
+                {
+                    displayName: 'Authentication',
+                    name: 'authentication',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'OAuth2',
+                            value: 'jmapOAuth2Api',
+                        },
+                        {
+                            name: 'Basic Auth / Bearer Token',
+                            value: 'jmapApi',
+                        },
+                    ],
+                    default: 'jmapOAuth2Api',
+                    description: 'Authentication method to use',
+                },
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'New Email',
+                            value: 'newEmail',
+                            description: 'Triggers when a new email is received',
+                        },
+                        {
+                            name: 'New Email in Mailbox',
+                            value: 'newEmailInMailbox',
+                            description: 'Triggers when a new email is received in a specific mailbox',
+                        },
+                    ],
+                    default: 'newEmail',
+                    required: true,
+                },
+                {
+                    displayName: 'Mailbox',
+                    name: 'mailbox',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getMailboxes',
+                    },
+                    displayOptions: {
+                        show: {
+                            event: ['newEmailInMailbox'],
+                        },
+                    },
+                    default: '',
+                    description: 'The mailbox to monitor for new emails',
+                },
+                {
+                    displayName: 'Simple Output',
+                    name: 'simple',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to return a simplified version of the email data',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Include Attachments Info',
+                            name: 'includeAttachments',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to include attachment information in the output',
+                        },
+                        {
+                            displayName: 'Mark as Read',
+                            name: 'markAsRead',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to mark fetched emails as read',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getMailboxes() {
+                    const accountId = await GenericFunctions_1.getPrimaryAccountId.call(this);
+                    const mailboxes = await GenericFunctions_1.getMailboxes.call(this, accountId);
+                    return mailboxes.map((mailbox) => ({
+                        name: `${mailbox.name} (${mailbox.totalEmails} emails)`,
+                        value: mailbox.id,
+                    }));
+                },
+            },
+        };
+    }
+    async poll() {
+        const webhookData = this.getWorkflowStaticData('node');
+        const event = this.getNodeParameter('event');
+        const simple = this.getNodeParameter('simple');
+        const options = this.getNodeParameter('options');
+        // Get the last processed email timestamp
+        const lastProcessedTime = webhookData.lastProcessedTime;
+        // Get account ID
+        const accountId = await GenericFunctions_1.getPrimaryAccountId.call(this);
+        // Build filter
+        const filter = {};
+        if (event === 'newEmailInMailbox') {
+            const mailbox = this.getNodeParameter('mailbox');
+            filter.inMailbox = mailbox;
+        }
+        // If we have a last processed time, only get emails after that
+        if (lastProcessedTime) {
+            filter.after = lastProcessedTime;
+        }
+        // Query for new emails
+        const { ids } = await GenericFunctions_1.queryEmails.call(this, accountId, filter, [{ property: 'receivedAt', isAscending: false }], 100);
+        if (ids.length === 0) {
+            return null;
+        }
+        // Get full email data
+        let properties = [
+            'id',
+            'blobId',
+            'threadId',
+            'mailboxIds',
+            'keywords',
+            'receivedAt',
+            'from',
+            'to',
+            'cc',
+            'subject',
+            'preview',
+            'hasAttachment',
+        ];
+        if (!simple) {
+            properties = [
+                ...properties,
+                'bodyValues',
+                'textBody',
+                'htmlBody',
+                'bodyStructure',
+            ];
+        }
+        if (options.includeAttachments) {
+            properties.push('attachments');
+        }
+        const emails = await GenericFunctions_1.getEmails.call(this, accountId, ids, properties, !simple, !simple);
+        if (emails.length === 0) {
+            return null;
+        }
+        // Update the last processed time to the most recent email
+        const mostRecentEmail = emails[0];
+        webhookData.lastProcessedTime = mostRecentEmail.receivedAt;
+        // Filter out already processed emails if we had a lastProcessedTime
+        let newEmails = emails;
+        if (lastProcessedTime) {
+            newEmails = emails.filter((email) => {
+                const emailTime = new Date(email.receivedAt).getTime();
+                const lastTime = new Date(lastProcessedTime).getTime();
+                return emailTime > lastTime;
+            });
+        }
+        if (newEmails.length === 0) {
+            return null;
+        }
+        // Transform output
+        const returnData = newEmails.map((email) => {
+            var _a, _b;
+            let outputEmail;
+            if (simple) {
+                outputEmail = {
+                    id: email.id,
+                    threadId: email.threadId,
+                    from: email.from,
+                    to: email.to,
+                    cc: email.cc,
+                    subject: email.subject,
+                    preview: email.preview,
+                    receivedAt: email.receivedAt,
+                    hasAttachment: email.hasAttachment,
+                    isRead: !!((_a = email.keywords) === null || _a === void 0 ? void 0 : _a.$seen),
+                    isFlagged: !!((_b = email.keywords) === null || _b === void 0 ? void 0 : _b.$flagged),
+                };
+            }
+            else {
+                outputEmail = email;
+            }
+            return { json: outputEmail };
+        });
+        return [returnData];
+    }
+}
+exports.JmapTrigger = JmapTrigger;

package/dist/nodes/Jmap/jmap.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <defs>
+    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#4A90D9;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#2E5B8E;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  <!-- Envelope shape -->
+  <rect x="4" y="14" width="56" height="40" rx="4" ry="4" fill="url(#grad1)"/>
+  <!-- Envelope flap -->
+  <path d="M4 18 L32 38 L60 18" fill="none" stroke="#ffffff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/>
+  <!-- JMAP text -->
+  <text x="32" y="49" font-family="Arial, sans-serif" font-size="20" font-weight="bold" fill="#ffffff" text-anchor="middle">JMAP</text>
+</svg>

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "n8n-nodes-jmap",
+  "version": "0.1.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",
+    "jmap",
+    "email",
+    "apache-james",
+    "twake-mail",
+    "fastmail",
+    "rfc8620",
+    "rfc8621"
+  ],
+  "license": "AGPL-3.0",
+  "homepage": "https://github.com/mmaudet/n8n-nodes-jmap",
+  "author": {
+    "name": "Michel-Marie Maudet",
+    "url": "https://github.com/mmaudet"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mmaudet/n8n-nodes-jmap.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint 'nodes/**/*.ts' 'credentials/**/*.ts'",
+    "lintfix": "eslint 'nodes/**/*.ts' 'credentials/**/*.ts' --fix",
+    "prepublishOnly": "npm run build && npm run lint -q"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/JmapApi.credentials.js",
+      "dist/credentials/JmapOAuth2Api.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Jmap/Jmap.node.js",
+      "dist/nodes/Jmap/JmapTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.56.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^3.2.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}