n8n-nodes-jmap 0.2.6 → 0.3.0

package/dist/credentials/JmapBasicAuthApi.credentials.d.ts

@@ -0,0 +1,13 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties, Icon } from 'n8n-workflow';
+/**
+ * JMAP API Credentials for Basic Auth authentication
+ */
+export declare class JmapBasicAuthApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    icon: Icon;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/JmapBasicAuthApi.credentials.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JmapBasicAuthApi = void 0;
+/**
+ * JMAP API Credentials for Basic Auth authentication
+ */
+class JmapBasicAuthApi {
+    constructor() {
+        this.name = 'jmapBasicAuthApi';
+        this.displayName = 'JMAP Basic Auth API';
+        this.documentationUrl = 'https://jmap.io/spec-core.html';
+        this.icon = {
+            light: 'file:../nodes/Jmap/jmap.svg',
+            dark: 'file:../nodes/Jmap/jmap.svg',
+        };
+        this.properties = [
+            {
+                displayName: 'JMAP Server URL',
+                name: 'serverUrl',
+                type: 'string',
+                default: 'https://jmap.example.com/jmap',
+                placeholder: 'https://jmap.example.com/jmap',
+                description: 'The base URL of the JMAP server',
+                required: true,
+            },
+            {
+                displayName: 'Email',
+                name: 'email',
+                type: 'string',
+                placeholder: 'user@example.com',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                auth: {
+                    username: '={{$credentials.email}}',
+                    password: '={{$credentials.password}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.serverUrl}}',
+                url: '/session',
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                },
+            },
+        };
+    }
+}
+exports.JmapBasicAuthApi = JmapBasicAuthApi;

package/dist/credentials/JmapBearerTokenApi.credentials.d.ts

@@ -0,0 +1,13 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties, Icon } from 'n8n-workflow';
+/**
+ * JMAP API Credentials for Bearer Token authentication
+ */
+export declare class JmapBearerTokenApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    icon: Icon;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/JmapBearerTokenApi.credentials.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JmapBearerTokenApi = void 0;
+/**
+ * JMAP API Credentials for Bearer Token authentication
+ */
+class JmapBearerTokenApi {
+    constructor() {
+        this.name = 'jmapBearerTokenApi';
+        this.displayName = 'JMAP Bearer Token API';
+        this.documentationUrl = 'https://jmap.io/spec-core.html';
+        this.icon = {
+            light: 'file:../nodes/Jmap/jmap.svg',
+            dark: 'file:../nodes/Jmap/jmap.svg',
+        };
+        this.properties = [
+            {
+                displayName: 'JMAP Server URL',
+                name: 'serverUrl',
+                type: 'string',
+                default: 'https://jmap.example.com/jmap',
+                placeholder: 'https://jmap.example.com/jmap',
+                description: 'The base URL of the JMAP server',
+                required: true,
+            },
+            {
+                displayName: 'Access Token',
+                name: 'accessToken',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'The access token (e.g., from OAuth2/OIDC)',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.accessToken}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.serverUrl}}',
+                url: '/session',
+                method: 'GET',
+                headers: {
+                    Accept: 'application/json',
+                },
+            },
+        };
+    }
+}
+exports.JmapBearerTokenApi = JmapBearerTokenApi;

package/dist/credentials/JmapOAuth2Api.credentials.d.ts

@@ -11,17 +11,4 @@ export declare class JmapOAuth2Api implements ICredentialType {
     extends: string[];
     icon: Icon;
     properties: INodeProperties[];
-    oauth2: {
-        tokenExpiredStatusCode: number;
-        grantType: string;
-        scope: string;
-        tokenRequestMethod: "POST";
-        authorizeUrl: {
-            url: string;
-        };
-        accessTokenUrl: {
-            url: string;
-        };
-        clientAuthentication: "body";
-    };
 }

package/dist/credentials/JmapOAuth2Api.credentials.js

@@ -88,16 +88,6 @@ class JmapOAuth2Api {
                 default: 'body',
             },
         ];
-        // OAuth2 flow configuration
-        this.oauth2 = {
-            tokenExpiredStatusCode: 401,
-            grantType: 'pkce',
-            scope: 'openid email profile offline_access',
-            tokenRequestMethod: 'POST',
-            authorizeUrl: { url: '={{ $credentials.authUrl }}' },
-            accessTokenUrl: { url: '={{ $credentials.accessTokenUrl }}' },
-            clientAuthentication: 'body',
-        };
     }
 }
 exports.JmapOAuth2Api = JmapOAuth2Api;

package/dist/nodes/Jmap/GenericFunctions.js

@@ -52,7 +52,8 @@ async function getServerUrl(context) {
         return credentials.jmapServerUrl.replace(/\/$/, '');
     }
     else {
-        const credentials = await context.getCredentials('jmapApi');
+        // Both jmapBasicAuthApi and jmapBearerTokenApi use 'serverUrl'
+        const credentials = await context.getCredentials(authType);
         return credentials.serverUrl.replace(/\/$/, '');
     }
 }
@@ -63,45 +64,18 @@ async function makeJmapRequest(context, method, endpoint, body) {
     const authType = getAuthType(context);
     const serverUrl = await getServerUrl(context);
     const url = endpoint.startsWith('http') ? endpoint : `${serverUrl}${endpoint}`;
-    if (authType === 'jmapOAuth2Api') {
-        // Use n8n's built-in OAuth2 authentication
-        const response = await context.helpers.httpRequestWithAuthentication.call(context, 'jmapOAuth2Api', {
-            method,
-            url,
-            headers: {
-                'Content-Type': 'application/json',
-                Accept: 'application/json',
-            },
-            body,
-            json: true,
-        });
-        return response;
-    }
-    else {
-        // Use Basic Auth or Bearer Token
-        const credentials = await context.getCredentials('jmapApi');
-        const authMethod = credentials.authMethod || 'basicAuth';
-        const headers = {
+    const requestOptions = {
+        method,
+        url,
+        headers: {
             'Content-Type': 'application/json',
             Accept: 'application/json',
-        };
-        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,
-            url,
-            headers,
-            body,
-            json: true,
-        };
-        const response = await context.helpers.httpRequest(options);
-        return response;
-    }
+        },
+        body,
+        json: true,
+    };
+    const response = await context.helpers.httpRequestWithAuthentication.call(context, authType, requestOptions);
+    return response;
 }
 /**
  * Get JMAP session from the server
@@ -148,7 +122,7 @@ async function getPrimaryAccountId() {
     if (accountIds.length > 0) {
         return accountIds[0];
     }
-    throw new Error('No JMAP account found');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No JMAP account found');
 }
 /**
  * Get all mailboxes for an account
@@ -159,7 +133,7 @@ async function getMailboxes(accountId) {
     if (methodResponse[0] === 'Mailbox/get') {
         return methodResponse[1].list;
     }
-    throw new Error('Failed to get mailboxes');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to get mailboxes');
 }
 /**
  * Find a mailbox by name
@@ -194,7 +168,7 @@ async function queryEmails(accountId, filter = {}, sort = [{ property: 'received
             total: result.total,
         };
     }
-    throw new Error('Failed to query emails');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to query emails');
 }
 /**
  * Get emails by IDs
@@ -223,7 +197,7 @@ async function getEmails(accountId, ids, properties = [
     if (methodResponse[0] === 'Email/get') {
         return methodResponse[1].list;
     }
-    throw new Error('Failed to get emails');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to get emails');
 }
 /**
  * Create and send an email
@@ -231,7 +205,7 @@ async function getEmails(accountId, ids, properties = [
 async function sendEmail(accountId, email, identityId) {
     const draftsMailbox = await findMailboxByRole.call(this, accountId, 'drafts');
     if (!draftsMailbox) {
-        throw new Error('Drafts mailbox not found');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Drafts mailbox not found');
     }
     const emailCreate = {
         ...email,
@@ -252,7 +226,7 @@ async function sendEmail(accountId, email, identityId) {
     ], [exports.JMAP_CAPABILITIES.CORE, exports.JMAP_CAPABILITIES.MAIL, exports.JMAP_CAPABILITIES.SUBMISSION]);
     for (const methodResponse of response.methodResponses) {
         if (methodResponse[0] === 'error') {
-            throw new Error(`JMAP error: ${JSON.stringify(methodResponse[1])}`);
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `JMAP error: ${JSON.stringify(methodResponse[1])}`);
         }
     }
     return response.methodResponses[1][1];
@@ -263,7 +237,7 @@ async function sendEmail(accountId, email, identityId) {
 async function createDraft(accountId, email) {
     const draftsMailbox = await findMailboxByRole.call(this, accountId, 'drafts');
     if (!draftsMailbox) {
-        throw new Error('Drafts mailbox not found');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Drafts mailbox not found');
     }
     const emailCreate = {
         ...email,
@@ -273,7 +247,7 @@ async function createDraft(accountId, email) {
     const response = await jmapApiRequest.call(this, [['Email/set', { accountId, create: { draft: emailCreate } }, 'c1']]);
     const methodResponse = response.methodResponses[0];
     if (methodResponse[0] === 'error') {
-        throw new Error(`JMAP error: ${JSON.stringify(methodResponse[1])}`);
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `JMAP error: ${JSON.stringify(methodResponse[1])}`);
     }
     if (methodResponse[0] === 'Email/set') {
         const result = methodResponse[1];
@@ -293,7 +267,7 @@ async function getIdentities(accountId) {
     if (methodResponse[0] === 'Identity/get') {
         return methodResponse[1].list;
     }
-    throw new Error('Failed to get identities');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to get identities');
 }
 /**
  * Update email keywords
@@ -304,7 +278,7 @@ async function updateEmailKeywords(accountId, emailId, keywords) {
     if (methodResponse[0] === 'Email/set') {
         return methodResponse[1];
     }
-    throw new Error('Failed to update email');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to update email');
 }
 /**
  * Move email to a different mailbox
@@ -324,7 +298,7 @@ async function moveEmail(accountId, emailId, targetMailboxId) {
     if (methodResponse[0] === 'Email/set') {
         return methodResponse[1];
     }
-    throw new Error('Failed to move email');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to move email');
 }
 /**
  * Add a label (mailbox) to an email
@@ -344,7 +318,7 @@ async function addLabel(accountId, emailId, mailboxId) {
     if (methodResponse[0] === 'Email/set') {
         return methodResponse[1];
     }
-    throw new Error('Failed to add label');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to add label');
 }
 /**
  * Remove a label (mailbox) from an email
@@ -364,7 +338,7 @@ async function removeLabel(accountId, emailId, mailboxId) {
     if (methodResponse[0] === 'Email/set') {
         return methodResponse[1];
     }
-    throw new Error('Failed to remove label');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to remove label');
 }
 /**
  * Get labels (mailboxes) for an email with their names
@@ -372,7 +346,7 @@ async function removeLabel(accountId, emailId, mailboxId) {
 async function getLabels(accountId, emailId) {
     const emails = await getEmails.call(this, accountId, [emailId], ['id', 'mailboxIds']);
     if (emails.length === 0) {
-        throw new Error('Email not found');
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Email not found');
     }
     const email = emails[0];
     const mailboxIds = email.mailboxIds;
@@ -407,7 +381,7 @@ async function deleteEmails(accountId, emailIds) {
     if (methodResponse[0] === 'Email/set') {
         return methodResponse[1];
     }
-    throw new Error('Failed to delete emails');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to delete emails');
 }
 /**
  * Get threads
@@ -418,7 +392,7 @@ async function getThreads(accountId, ids) {
     if (methodResponse[0] === 'Thread/get') {
         return methodResponse[1].list;
     }
-    throw new Error('Failed to get threads');
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to get threads');
 }
 /**
  * Download an attachment blob
@@ -431,34 +405,12 @@ async function downloadBlob(accountId, blobId, name, type) {
         .replace('{blobId}', blobId)
         .replace('{name}', encodeURIComponent(name))
         .replace('{type}', encodeURIComponent(type));
-    if (authType === 'jmapOAuth2Api') {
-        const response = await this.helpers.httpRequestWithAuthentication.call(this, 'jmapOAuth2Api', {
-            method: 'GET',
-            url: downloadUrl,
-            encoding: 'arraybuffer',
-        });
-        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',
-            url: downloadUrl,
-            headers,
-            encoding: 'arraybuffer',
-        };
-        const response = await this.helpers.httpRequest(options);
-        return Buffer.from(response);
-    }
+    const response = await this.helpers.httpRequestWithAuthentication.call(this, authType, {
+        method: 'GET',
+        url: downloadUrl,
+        encoding: 'arraybuffer',
+    });
+    return Buffer.from(response);
 }
 /**
  * Check if a MIME type matches a filter pattern
@@ -486,7 +438,7 @@ async function getAttachments(accountId, emailId, options = {}) {
         'attachments',
     ]);
     if (emails.length === 0) {
-        throw new Error(`Email with ID ${emailId} not found`);
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Email with ID ${emailId} not found`);
     }
     const email = emails[0];
     const attachments = email.attachments || [];

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

@@ -18,15 +18,24 @@ class Jmap {
             defaults: {
                 name: 'JMAP',
             },
-            inputs: ['main'],
-            outputs: ['main'],
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             credentials: [
                 {
-                    name: 'jmapApi',
+                    name: 'jmapBasicAuthApi',
                     required: true,
                     displayOptions: {
                         show: {
-                            authentication: ['jmapApi'],
+                            authentication: ['jmapBasicAuthApi'],
+                        },
+                    },
+                },
+                {
+                    name: 'jmapBearerTokenApi',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['jmapBearerTokenApi'],
                         },
                     },
                 },
@@ -52,8 +61,12 @@ class Jmap {
                             value: 'jmapOAuth2Api',
                         },
                         {
-                            name: 'Basic Auth / Bearer Token',
-                            value: 'jmapApi',
+                            name: 'Basic Auth',
+                            value: 'jmapBasicAuthApi',
+                        },
+                        {
+                            name: 'Bearer Token',
+                            value: 'jmapBearerTokenApi',
                         },
                     ],
                     default: 'jmapOAuth2Api',
@@ -608,7 +621,12 @@ class Jmap {
         const resource = this.getNodeParameter('resource', 0);
         const operation = this.getNodeParameter('operation', 0);
         const accountId = await GenericFunctions_1.getPrimaryAccountId.call(this);
-        for (let i = 0; i < items.length; i++) {
+        // Operations that should only run once, regardless of input items
+        const singleExecutionOperations = [
+            'getMany', // Email/Mailbox/Thread getMany - query with filters, not per-item
+        ];
+        const itemsToProcess = singleExecutionOperations.includes(operation) ? 1 : items.length;
+        for (let i = 0; i < itemsToProcess; i++) {
             try {
                 let responseData = {};
                 // ==================== EMAIL ====================

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JmapTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
 const GenericFunctions_1 = require("./GenericFunctions");
 class JmapTrigger {
     constructor() {
@@ -16,14 +17,23 @@ class JmapTrigger {
                 name: 'JMAP Trigger',
             },
             inputs: [],
-            outputs: ['main'],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             credentials: [
                 {
-                    name: 'jmapApi',
+                    name: 'jmapBasicAuthApi',
                     required: true,
                     displayOptions: {
                         show: {
-                            authentication: ['jmapApi'],
+                            authentication: ['jmapBasicAuthApi'],
+                        },
+                    },
+                },
+                {
+                    name: 'jmapBearerTokenApi',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ['jmapBearerTokenApi'],
                         },
                     },
                 },
@@ -50,8 +60,12 @@ class JmapTrigger {
                             value: 'jmapOAuth2Api',
                         },
                         {
-                            name: 'Basic Auth / Bearer Token',
-                            value: 'jmapApi',
+                            name: 'Basic Auth',
+                            value: 'jmapBasicAuthApi',
+                        },
+                        {
+                            name: 'Bearer Token',
+                            value: 'jmapBearerTokenApi',
                         },
                     ],
                     default: 'jmapOAuth2Api',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-jmap",
-  "version": "0.2.6",
+  "version": "0.3.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",
@@ -38,7 +38,8 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "credentials": [
-      "dist/credentials/JmapApi.credentials.js",
+      "dist/credentials/JmapBasicAuthApi.credentials.js",
+      "dist/credentials/JmapBearerTokenApi.credentials.js",
       "dist/credentials/JmapOAuth2Api.credentials.js"
     ],
     "nodes": [

package/dist/credentials/JmapApi.credentials.d.ts

@@ -1,13 +0,0 @@
-import { ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
-/**
- * JMAP API Credentials for Basic Auth or Bearer Token authentication
- *
- * For OAuth2/OIDC with LemonLDAP, use the JmapOAuth2Api credentials instead.
- */
-export declare class JmapApi implements ICredentialType {
-    name: string;
-    displayName: string;
-    documentationUrl: string;
-    properties: INodeProperties[];
-    test: ICredentialTestRequest;
-}

package/dist/credentials/JmapApi.credentials.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JmapApi = void 0;
-/**
- * JMAP API Credentials for Basic Auth or Bearer Token authentication
- *
- * For OAuth2/OIDC with LemonLDAP, use the JmapOAuth2Api credentials instead.
- */
-class JmapApi {
-    constructor() {
-        this.name = 'jmapApi';
-        this.displayName = 'JMAP API';
-        this.documentationUrl = 'https://jmap.io/spec-core.html';
-        this.properties = [
-            {
-                displayName: 'JMAP Server URL',
-                name: 'serverUrl',
-                type: 'string',
-                default: 'https://jmap.example.com/jmap',
-                placeholder: 'https://jmap.example.com/jmap',
-                description: 'The base URL of the JMAP server',
-                required: true,
-            },
-            {
-                displayName: 'Authentication Method',
-                name: 'authMethod',
-                type: 'options',
-                options: [
-                    {
-                        name: 'Basic Auth',
-                        value: 'basicAuth',
-                        description: 'Authenticate with email and password',
-                    },
-                    {
-                        name: 'Bearer Token',
-                        value: 'bearerToken',
-                        description: 'Authenticate with an existing access token',
-                    },
-                ],
-                default: 'basicAuth',
-            },
-            // Basic Auth fields
-            {
-                displayName: 'Email',
-                name: 'email',
-                type: 'string',
-                placeholder: 'user@example.com',
-                default: '',
-                required: true,
-                displayOptions: {
-                    show: {
-                        authMethod: ['basicAuth'],
-                    },
-                },
-            },
-            {
-                displayName: 'Password',
-                name: 'password',
-                type: 'string',
-                typeOptions: {
-                    password: true,
-                },
-                default: '',
-                required: true,
-                displayOptions: {
-                    show: {
-                        authMethod: ['basicAuth'],
-                    },
-                },
-            },
-            // Bearer Token field
-            {
-                displayName: 'Access Token',
-                name: 'accessToken',
-                type: 'string',
-                typeOptions: {
-                    password: true,
-                },
-                default: '',
-                required: true,
-                description: 'The access token (e.g., from OAuth2/OIDC)',
-                displayOptions: {
-                    show: {
-                        authMethod: ['bearerToken'],
-                    },
-                },
-            },
-        ];
-        this.test = {
-            request: {
-                baseURL: '={{$credentials.serverUrl}}',
-                url: '/session',
-                method: 'GET',
-                headers: {
-                    Accept: 'application/json',
-                },
-                auth: {
-                    username: '={{$credentials.email}}',
-                    password: '={{$credentials.password}}',
-                },
-            },
-        };
-    }
-}
-exports.JmapApi = JmapApi;