n8n-nodes-jmap 0.1.0

package/dist/nodes/Jmap/GenericFunctions.js

@@ -0,0 +1,466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JMAP_CAPABILITIES = void 0;
+exports.getJmapSession = getJmapSession;
+exports.jmapApiRequest = jmapApiRequest;
+exports.getPrimaryAccountId = getPrimaryAccountId;
+exports.getMailboxes = getMailboxes;
+exports.findMailboxByName = findMailboxByName;
+exports.findMailboxByRole = findMailboxByRole;
+exports.queryEmails = queryEmails;
+exports.getEmails = getEmails;
+exports.sendEmail = sendEmail;
+exports.createDraft = createDraft;
+exports.getIdentities = getIdentities;
+exports.updateEmailKeywords = updateEmailKeywords;
+exports.moveEmail = moveEmail;
+exports.addLabel = addLabel;
+exports.removeLabel = removeLabel;
+exports.getLabels = getLabels;
+exports.deleteEmails = deleteEmails;
+exports.getThreads = getThreads;
+exports.downloadBlob = downloadBlob;
+const n8n_workflow_1 = require("n8n-workflow");
+// Standard JMAP capabilities
+exports.JMAP_CAPABILITIES = {
+    CORE: 'urn:ietf:params:jmap:core',
+    MAIL: 'urn:ietf:params:jmap:mail',
+    SUBMISSION: 'urn:ietf:params:jmap:submission',
+    VACATION_RESPONSE: 'urn:ietf:params:jmap:vacationresponse',
+    JAMES_SHARES: 'urn:apache:james:params:jmap:mail:shares',
+    JAMES_QUOTA: 'urn:apache:james:params:jmap:mail:quota',
+};
+/**
+ * Get the authentication type from node parameters
+ */
+function getAuthType(context) {
+    try {
+        return context.getNodeParameter('authentication', 0);
+    }
+    catch {
+        return 'jmapOAuth2Api'; // Default to OAuth2
+    }
+}
+/**
+ * Get JMAP server URL based on credential type
+ */
+async function getServerUrl(context) {
+    const authType = getAuthType(context);
+    if (authType === 'jmapOAuth2Api') {
+        const credentials = await context.getCredentials('jmapOAuth2Api');
+        return credentials.jmapServerUrl.replace(/\/$/, '');
+    }
+    else {
+        const credentials = await context.getCredentials('jmapApi');
+        return credentials.serverUrl.replace(/\/$/, '');
+    }
+}
+/**
+ * Make an authenticated JMAP request
+ */
+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.requestWithAuthentication.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 options = {
+            method,
+            uri: url,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body,
+            json: true,
+        };
+        if (authMethod === 'basicAuth') {
+            options.auth = {
+                user: credentials.email,
+                pass: credentials.password,
+            };
+        }
+        else if (authMethod === 'bearerToken') {
+            options.headers = {
+                ...options.headers,
+                Authorization: `Bearer ${credentials.accessToken}`,
+            };
+        }
+        const response = await context.helpers.request(options);
+        return response;
+    }
+}
+/**
+ * Get JMAP session from the server
+ */
+async function getJmapSession() {
+    try {
+        const response = await makeJmapRequest(this, 'GET', '/session');
+        return response;
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+            message: 'Failed to get JMAP session',
+        });
+    }
+}
+/**
+ * Make a JMAP API request
+ */
+async function jmapApiRequest(methodCalls, using = [exports.JMAP_CAPABILITIES.CORE, exports.JMAP_CAPABILITIES.MAIL]) {
+    const body = {
+        using,
+        methodCalls,
+    };
+    try {
+        const response = await makeJmapRequest(this, 'POST', '', body);
+        return response;
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+            message: 'JMAP API request failed',
+        });
+    }
+}
+/**
+ * Get the primary account ID for mail
+ */
+async function getPrimaryAccountId() {
+    const session = await getJmapSession.call(this);
+    const mailCapability = exports.JMAP_CAPABILITIES.MAIL;
+    if (session.primaryAccounts && session.primaryAccounts[mailCapability]) {
+        return session.primaryAccounts[mailCapability];
+    }
+    const accountIds = Object.keys(session.accounts);
+    if (accountIds.length > 0) {
+        return accountIds[0];
+    }
+    throw new Error('No JMAP account found');
+}
+/**
+ * Get all mailboxes for an account
+ */
+async function getMailboxes(accountId) {
+    const response = await jmapApiRequest.call(this, [['Mailbox/get', { accountId }, 'c1']]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Mailbox/get') {
+        return methodResponse[1].list;
+    }
+    throw new Error('Failed to get mailboxes');
+}
+/**
+ * Find a mailbox by name
+ */
+async function findMailboxByName(accountId, name) {
+    const mailboxes = await getMailboxes.call(this, accountId);
+    return mailboxes.find((mb) => mb.name === name);
+}
+/**
+ * Find a mailbox by role
+ */
+async function findMailboxByRole(accountId, role) {
+    const mailboxes = await getMailboxes.call(this, accountId);
+    return mailboxes.find((mb) => mb.role === role);
+}
+/**
+ * Query emails with filters
+ */
+async function queryEmails(accountId, filter = {}, sort = [{ property: 'receivedAt', isAscending: false }], limit = 50, position = 0) {
+    const response = await jmapApiRequest.call(this, [
+        [
+            'Email/query',
+            { accountId, filter, sort, limit, position },
+            'c1',
+        ],
+    ]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/query') {
+        const result = methodResponse[1];
+        return {
+            ids: result.ids,
+            total: result.total,
+        };
+    }
+    throw new Error('Failed to query emails');
+}
+/**
+ * Get emails by IDs
+ */
+async function getEmails(accountId, ids, properties = [
+    'id', 'blobId', 'threadId', 'mailboxIds', 'keywords', 'size',
+    'receivedAt', 'from', 'to', 'cc', 'bcc', 'replyTo', 'subject',
+    'sentAt', 'hasAttachment', 'preview', 'bodyStructure', 'bodyValues',
+    'textBody', 'htmlBody', 'attachments',
+], fetchTextBodyValues = true, fetchHTMLBodyValues = true) {
+    const response = await jmapApiRequest.call(this, [
+        [
+            'Email/get',
+            {
+                accountId,
+                ids,
+                properties,
+                fetchTextBodyValues,
+                fetchHTMLBodyValues,
+                maxBodyValueBytes: 1048576,
+            },
+            'c1',
+        ],
+    ]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/get') {
+        return methodResponse[1].list;
+    }
+    throw new Error('Failed to get emails');
+}
+/**
+ * Create and send an email
+ */
+async function sendEmail(accountId, email, identityId) {
+    const draftsMailbox = await findMailboxByRole.call(this, accountId, 'drafts');
+    if (!draftsMailbox) {
+        throw new Error('Drafts mailbox not found');
+    }
+    const emailCreate = {
+        ...email,
+        mailboxIds: { [draftsMailbox.id]: true },
+        keywords: { $draft: true },
+    };
+    const response = await jmapApiRequest.call(this, [
+        ['Email/set', { accountId, create: { draft: emailCreate } }, 'c1'],
+        [
+            'EmailSubmission/set',
+            {
+                accountId,
+                create: { send: { emailId: '#draft', identityId } },
+                onSuccessDestroyEmail: ['#send'],
+            },
+            'c2',
+        ],
+    ], [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])}`);
+        }
+    }
+    return response.methodResponses[1][1];
+}
+/**
+ * Create a draft email
+ */
+async function createDraft(accountId, email) {
+    const draftsMailbox = await findMailboxByRole.call(this, accountId, 'drafts');
+    if (!draftsMailbox) {
+        throw new Error('Drafts mailbox not found');
+    }
+    const emailCreate = {
+        ...email,
+        mailboxIds: { [draftsMailbox.id]: true },
+        keywords: { $draft: true },
+    };
+    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])}`);
+    }
+    if (methodResponse[0] === 'Email/set') {
+        const result = methodResponse[1];
+        const created = result.created;
+        if (created && created.draft) {
+            return created.draft;
+        }
+    }
+    return methodResponse[1];
+}
+/**
+ * Get identities
+ */
+async function getIdentities(accountId) {
+    const response = await jmapApiRequest.call(this, [['Identity/get', { accountId }, 'c1']], [exports.JMAP_CAPABILITIES.CORE, exports.JMAP_CAPABILITIES.SUBMISSION]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Identity/get') {
+        return methodResponse[1].list;
+    }
+    throw new Error('Failed to get identities');
+}
+/**
+ * Update email keywords
+ */
+async function updateEmailKeywords(accountId, emailId, keywords) {
+    const response = await jmapApiRequest.call(this, [['Email/set', { accountId, update: { [emailId]: { keywords } } }, 'c1']]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/set') {
+        return methodResponse[1];
+    }
+    throw new Error('Failed to update email');
+}
+/**
+ * Move email to a different mailbox
+ */
+async function moveEmail(accountId, emailId, targetMailboxId) {
+    const response = await jmapApiRequest.call(this, [
+        [
+            'Email/set',
+            {
+                accountId,
+                update: { [emailId]: { mailboxIds: { [targetMailboxId]: true } } },
+            },
+            'c1',
+        ],
+    ]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/set') {
+        return methodResponse[1];
+    }
+    throw new Error('Failed to move email');
+}
+/**
+ * Add a label (mailbox) to an email
+ */
+async function addLabel(accountId, emailId, mailboxId) {
+    const response = await jmapApiRequest.call(this, [
+        [
+            'Email/set',
+            {
+                accountId,
+                update: { [emailId]: { [`mailboxIds/${mailboxId}`]: true } },
+            },
+            'c1',
+        ],
+    ]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/set') {
+        return methodResponse[1];
+    }
+    throw new Error('Failed to add label');
+}
+/**
+ * Remove a label (mailbox) from an email
+ */
+async function removeLabel(accountId, emailId, mailboxId) {
+    const response = await jmapApiRequest.call(this, [
+        [
+            'Email/set',
+            {
+                accountId,
+                update: { [emailId]: { [`mailboxIds/${mailboxId}`]: null } },
+            },
+            'c1',
+        ],
+    ]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/set') {
+        return methodResponse[1];
+    }
+    throw new Error('Failed to remove label');
+}
+/**
+ * Get labels (mailboxes) for an email with their names
+ */
+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');
+    }
+    const email = emails[0];
+    const mailboxIds = email.mailboxIds;
+    if (!mailboxIds || Object.keys(mailboxIds).length === 0) {
+        return [];
+    }
+    const allMailboxes = await getMailboxes.call(this, accountId);
+    const labels = [];
+    for (const mailboxId of Object.keys(mailboxIds)) {
+        const mailbox = allMailboxes.find((mb) => mb.id === mailboxId);
+        if (mailbox) {
+            labels.push({
+                id: mailbox.id,
+                name: mailbox.name,
+                role: mailbox.role || null,
+                totalEmails: mailbox.totalEmails,
+                unreadEmails: mailbox.unreadEmails,
+            });
+        }
+        else {
+            labels.push({ id: mailboxId, name: null, role: null });
+        }
+    }
+    return labels;
+}
+/**
+ * Delete emails
+ */
+async function deleteEmails(accountId, emailIds) {
+    const response = await jmapApiRequest.call(this, [['Email/set', { accountId, destroy: emailIds }, 'c1']]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Email/set') {
+        return methodResponse[1];
+    }
+    throw new Error('Failed to delete emails');
+}
+/**
+ * Get threads
+ */
+async function getThreads(accountId, ids) {
+    const response = await jmapApiRequest.call(this, [['Thread/get', { accountId, ids }, 'c1']]);
+    const methodResponse = response.methodResponses[0];
+    if (methodResponse[0] === 'Thread/get') {
+        return methodResponse[1].list;
+    }
+    throw new Error('Failed to get threads');
+}
+/**
+ * Download an attachment blob
+ */
+async function downloadBlob(accountId, blobId, name, type) {
+    const session = await getJmapSession.call(this);
+    const authType = getAuthType(this);
+    let downloadUrl = session.downloadUrl
+        .replace('{accountId}', accountId)
+        .replace('{blobId}', blobId)
+        .replace('{name}', encodeURIComponent(name))
+        .replace('{type}', encodeURIComponent(type));
+    if (authType === 'jmapOAuth2Api') {
+        const response = await this.helpers.requestWithAuthentication.call(this, 'jmapOAuth2Api', {
+            method: 'GET',
+            url: downloadUrl,
+            encoding: null,
+        });
+        return response;
+    }
+    else {
+        const credentials = await this.getCredentials('jmapApi');
+        const authMethod = credentials.authMethod || 'basicAuth';
+        const options = {
+            method: 'GET',
+            uri: downloadUrl,
+            encoding: null,
+        };
+        if (authMethod === 'basicAuth') {
+            options.auth = {
+                user: credentials.email,
+                pass: credentials.password,
+            };
+        }
+        else if (authMethod === 'bearerToken') {
+            options.headers = {
+                Authorization: `Bearer ${credentials.accessToken}`,
+            };
+        }
+        return await this.helpers.request(options);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Jmap implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getMailboxes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getIdentities(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}