n8n-nodes-mailhooks 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# n8n-nodes-mailhooks
+
+This is an n8n community node. It lets you use _app/service name_ in your n8n workflows.
+
+_App/service name_ is _one or two sentences describing the service this node integrates with_.
+
+[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/sustainable-use-license/) workflow automation platform.
+
+[Installation](#installation)
+[Operations](#operations)
+[Credentials](#credentials)
+[Compatibility](#compatibility)
+[Usage](#usage)
+[Resources](#resources)
+[Version history](#version-history)
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+## Operations
+
+_List the operations supported by your node._
+
+## Credentials
+
+_If users need to authenticate with the app/service, provide details here. You should include prerequisites (such as signing up with the service), available authentication methods, and how to set them up._
+
+## Compatibility
+
+_State the minimum n8n version, as well as which versions you test against. You can also include any known version incompatibility issues._
+
+## Usage
+
+_This is an optional section. Use it to help users with any difficult or confusing aspects of the node._
+
+_By the time users are looking for community nodes, they probably already know n8n basics. But if you expect new users, you can link to the [Try it out](https://docs.n8n.io/try-it-out/) documentation to help them get started._
+
+## Resources
+
+* [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
+* _Link to app/service documentation._
+
+## Version history
+
+_This is another optional section. If your node has multiple versions, include a short description of available versions and what changed, as well as any compatibility impact._

package/dist/credentials/MailhooksApi.credentials.d.ts

@@ -0,0 +1,10 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class MailhooksApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    icon: "file:mailhooks-logo.png";
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/MailhooksApi.credentials.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MailhooksApi = void 0;
+class MailhooksApi {
+    constructor() {
+        this.name = 'mailhooksApi';
+        this.displayName = 'Mailhooks API';
+        this.documentationUrl = 'https://mailhooks.dev/docs';
+        this.icon = 'file:mailhooks-logo.png';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Your Mailhooks API key',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://mailhooks.dev/api',
+                description: 'The base URL for the Mailhooks API',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'x-api-key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl}}',
+                url: '/v1/emails?perPage=1',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.MailhooksApi = MailhooksApi;
+//# sourceMappingURL=MailhooksApi.credentials.js.map

package/dist/credentials/MailhooksApi.credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MailhooksApi.credentials.js","sourceRoot":"","sources":["../../credentials/MailhooksApi.credentials.ts"],"names":[],"mappings":";;;AAOA,MAAa,YAAY;IAAzB;QACC,SAAI,GAAG,cAAc,CAAC;QACtB,gBAAW,GAAG,eAAe,CAAC;QAC9B,qBAAgB,GAAG,4BAA4B,CAAC;QAChD,SAAI,GAAG,yBAAkC,CAAC;QAC1C,eAAU,GAAsB;YAC/B;gBACC,WAAW,EAAE,SAAS;gBACtB,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,wBAAwB;aACrC;YACD;gBACC,WAAW,EAAE,UAAU;gBACvB,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,2BAA2B;gBACpC,WAAW,EAAE,oCAAoC;aACjD;SACD,CAAC;QAEF,iBAAY,GAAyB;YACpC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE;gBACX,OAAO,EAAE;oBACR,WAAW,EAAE,0BAA0B;iBACvC;aACD;SACD,CAAC;QAEF,SAAI,GAA2B;YAC9B,OAAO,EAAE;gBACR,OAAO,EAAE,2BAA2B;gBACpC,GAAG,EAAE,sBAAsB;gBAC3B,MAAM,EAAE,KAAK;aACb;SACD,CAAC;IACH,CAAC;CAAA;AAxCD,oCAwCC"}

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

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Mailhooks implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Mailhooks/Mailhooks.node.js

@@ -0,0 +1,554 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mailhooks = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const sdk_1 = require("@mailhooks/sdk");
+function toDataObject(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+class Mailhooks {
+    constructor() {
+        this.description = {
+            displayName: 'Mailhooks',
+            name: 'mailhooks',
+            icon: 'file:mailhooks-logo.png',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with the Mailhooks API',
+            defaults: {
+                name: 'Mailhooks',
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            usableAsTool: true,
+            credentials: [
+                {
+                    name: 'mailhooksApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Email',
+                            value: 'email',
+                        },
+                        {
+                            name: 'Utility',
+                            value: 'utility',
+                        },
+                    ],
+                    default: 'email',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Download Attachment',
+                            value: 'downloadAttachment',
+                            description: 'Download a specific attachment',
+                            action: 'Download attachment',
+                        },
+                        {
+                            name: 'Download EML',
+                            value: 'downloadEml',
+                            description: 'Download email in EML format',
+                            action: 'Download email as EML',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get a specific email by ID',
+                            action: 'Get email',
+                        },
+                        {
+                            name: 'Get Content',
+                            value: 'getContent',
+                            description: 'Get the HTML and text content of an email',
+                            action: 'Get email content',
+                        },
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List emails with optional filters',
+                            action: 'List emails',
+                        },
+                        {
+                            name: 'Mark as Read',
+                            value: 'markAsRead',
+                            description: 'Mark an email as read',
+                            action: 'Mark email as read',
+                        },
+                        {
+                            name: 'Mark as Unread',
+                            value: 'markAsUnread',
+                            description: 'Mark an email as unread',
+                            action: 'Mark email as unread',
+                        },
+                        {
+                            name: 'Wait For',
+                            value: 'waitFor',
+                            description: 'Wait for an email matching filters',
+                            action: 'Wait for email',
+                        },
+                    ],
+                    default: 'list',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['utility'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Parse EML',
+                            value: 'parseEml',
+                            description: 'Parse raw EML content into structured data',
+                            action: 'Parse EML file',
+                        },
+                        {
+                            name: 'Verify Webhook',
+                            value: 'verifyWebhook',
+                            description: 'Verify a webhook signature',
+                            action: 'Verify webhook signature',
+                        },
+                    ],
+                    default: 'parseEml',
+                },
+                {
+                    displayName: 'Email ID',
+                    name: 'emailId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['get', 'getContent', 'markAsRead', 'markAsUnread', 'downloadEml', 'downloadAttachment'],
+                        },
+                    },
+                    description: 'The ID of the email',
+                },
+                {
+                    displayName: 'Attachment ID',
+                    name: 'attachmentId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['downloadAttachment'],
+                        },
+                    },
+                    description: 'The ID of the attachment to download',
+                },
+                {
+                    displayName: 'Mark as Read',
+                    name: 'markAsReadOnGet',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['get'],
+                        },
+                    },
+                    description: 'Whether to mark the email as read when fetching',
+                },
+                {
+                    displayName: 'Filters',
+                    name: 'filters',
+                    type: 'collection',
+                    placeholder: 'Add Filter',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['list'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'End Date',
+                            name: 'endDate',
+                            type: 'dateTime',
+                            default: '',
+                            description: 'Filter emails received before this date',
+                        },
+                        {
+                            displayName: 'From',
+                            name: 'from',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter by sender email address',
+                        },
+                        {
+                            displayName: 'Read Status',
+                            name: 'read',
+                            type: 'options',
+                            options: [
+                                { name: 'All', value: '' },
+                                { name: 'Read', value: 'true' },
+                                { name: 'Unread', value: 'false' },
+                            ],
+                            default: '',
+                            description: 'Filter by read status',
+                        },
+                        {
+                            displayName: 'Start Date',
+                            name: 'startDate',
+                            type: 'dateTime',
+                            default: '',
+                            description: 'Filter emails received after this date',
+                        },
+                        {
+                            displayName: 'Subject',
+                            name: 'subject',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter by subject',
+                        },
+                        {
+                            displayName: 'To',
+                            name: 'to',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter by recipient email address',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['list'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Page',
+                            name: 'page',
+                            type: 'number',
+                            default: 1,
+                            description: 'Page number',
+                        },
+                        {
+                            displayName: 'Per Page',
+                            name: 'perPage',
+                            type: 'number',
+                            default: 20,
+                            description: 'Number of results per page',
+                        },
+                        {
+                            displayName: 'Sort Field',
+                            name: 'sortField',
+                            type: 'options',
+                            options: [
+                                { name: 'Created At', value: 'createdAt' },
+                                { name: 'From', value: 'from' },
+                                { name: 'Subject', value: 'subject' },
+                            ],
+                            default: 'createdAt',
+                            description: 'Field to sort by',
+                        },
+                        {
+                            displayName: 'Sort Order',
+                            name: 'sortOrder',
+                            type: 'options',
+                            options: [
+                                { name: 'Ascending', value: 'asc' },
+                                { name: 'Descending', value: 'desc' },
+                            ],
+                            default: 'desc',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Wait For Filters',
+                    name: 'waitForFilters',
+                    type: 'collection',
+                    placeholder: 'Add Filter',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['waitFor'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'From',
+                            name: 'from',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter by sender email address',
+                        },
+                        {
+                            displayName: 'To',
+                            name: 'to',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter by recipient email address',
+                        },
+                        {
+                            displayName: 'Subject',
+                            name: 'subject',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter by subject',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Wait For Options',
+                    name: 'waitForOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['email'],
+                            operation: ['waitFor'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Timeout (Ms)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 30000,
+                            description: 'Maximum time to wait for email (in milliseconds)',
+                        },
+                        {
+                            displayName: 'Poll Interval (Ms)',
+                            name: 'pollInterval',
+                            type: 'number',
+                            default: 1000,
+                            description: 'How often to check for new emails (in milliseconds)',
+                        },
+                        {
+                            displayName: 'Lookback Window (Ms)',
+                            name: 'lookbackWindow',
+                            type: 'number',
+                            default: 10000,
+                            description: 'Only consider emails from this time window (in milliseconds)',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'EML Content',
+                    name: 'emlContent',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 10,
+                    },
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['utility'],
+                            operation: ['parseEml'],
+                        },
+                    },
+                    description: 'The raw EML content to parse',
+                },
+                {
+                    displayName: 'Payload',
+                    name: 'webhookPayload',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 5,
+                    },
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['utility'],
+                            operation: ['verifyWebhook'],
+                        },
+                    },
+                    description: 'The raw webhook payload body',
+                },
+                {
+                    displayName: 'Signature',
+                    name: 'webhookSignature',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['utility'],
+                            operation: ['verifyWebhook'],
+                        },
+                    },
+                    description: 'The X-Webhook-Signature header value',
+                },
+                {
+                    displayName: 'Webhook Secret',
+                    name: 'webhookSecret',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['utility'],
+                            operation: ['verifyWebhook'],
+                        },
+                    },
+                    description: 'Your webhook secret (starts with whsec_)',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        const credentials = await this.getCredentials('mailhooksApi');
+        const mailhooks = new sdk_1.Mailhooks({
+            apiKey: credentials.apiKey,
+            baseUrl: credentials.baseUrl,
+        });
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (resource === 'email') {
+                    if (operation === 'list') {
+                        const filters = this.getNodeParameter('filters', i, {});
+                        const options = this.getNodeParameter('options', i, {});
+                        const response = await mailhooks.emails.list({
+                            filter: {
+                                from: filters.from,
+                                to: filters.to,
+                                subject: filters.subject,
+                                read: filters.read ? filters.read === 'true' : undefined,
+                                startDate: filters.startDate,
+                                endDate: filters.endDate,
+                            },
+                            page: options.page,
+                            perPage: options.perPage,
+                            sort: options.sortField
+                                ? { field: options.sortField, order: options.sortOrder }
+                                : undefined,
+                        });
+                        returnData.push({
+                            json: toDataObject(response),
+                        });
+                    }
+                    else if (operation === 'get') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const markAsRead = this.getNodeParameter('markAsReadOnGet', i);
+                        const email = await mailhooks.emails.getEmail(emailId, markAsRead);
+                        returnData.push({ json: toDataObject(email) });
+                    }
+                    else if (operation === 'getContent') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const content = await mailhooks.emails.getContent(emailId);
+                        returnData.push({ json: toDataObject(content) });
+                    }
+                    else if (operation === 'markAsRead') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const email = await mailhooks.emails.markAsRead(emailId);
+                        returnData.push({ json: toDataObject(email) });
+                    }
+                    else if (operation === 'markAsUnread') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const email = await mailhooks.emails.markAsUnread(emailId);
+                        returnData.push({ json: toDataObject(email) });
+                    }
+                    else if (operation === 'downloadEml') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const response = await mailhooks.emails.downloadEml(emailId);
+                        returnData.push({
+                            json: {
+                                filename: response.filename,
+                                contentType: response.contentType,
+                            },
+                            binary: {
+                                data: await this.helpers.prepareBinaryData(Buffer.from(response.data), response.filename || `email-${emailId}.eml`, response.contentType || 'message/rfc822'),
+                            },
+                        });
+                    }
+                    else if (operation === 'downloadAttachment') {
+                        const emailId = this.getNodeParameter('emailId', i);
+                        const attachmentId = this.getNodeParameter('attachmentId', i);
+                        const response = await mailhooks.emails.downloadAttachment(emailId, attachmentId);
+                        returnData.push({
+                            json: {
+                                filename: response.filename,
+                                contentType: response.contentType,
+                            },
+                            binary: {
+                                data: await this.helpers.prepareBinaryData(Buffer.from(response.data), response.filename || `attachment-${attachmentId}`, response.contentType || 'application/octet-stream'),
+                            },
+                        });
+                    }
+                    else if (operation === 'waitFor') {
+                        const filters = this.getNodeParameter('waitForFilters', i, {});
+                        const options = this.getNodeParameter('waitForOptions', i, {});
+                        const email = await mailhooks.emails.waitFor({
+                            filter: filters,
+                            timeout: options.timeout,
+                            pollInterval: options.pollInterval,
+                            lookbackWindow: options.lookbackWindow,
+                        });
+                        returnData.push({ json: toDataObject(email) });
+                    }
+                }
+                else if (resource === 'utility') {
+                    if (operation === 'parseEml') {
+                        const emlContent = this.getNodeParameter('emlContent', i);
+                        const parsed = await (0, sdk_1.parseEml)(emlContent);
+                        returnData.push({ json: toDataObject(parsed) });
+                    }
+                    else if (operation === 'verifyWebhook') {
+                        const payload = this.getNodeParameter('webhookPayload', i);
+                        const signature = this.getNodeParameter('webhookSignature', i);
+                        const secret = this.getNodeParameter('webhookSecret', i);
+                        const isValid = (0, sdk_1.verifyWebhookSignature)(payload, signature, secret);
+                        returnData.push({ json: { valid: isValid } });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Mailhooks = Mailhooks;
+//# sourceMappingURL=Mailhooks.node.js.map