@trg-admin/n8n-nodes-zoho-desk 0.1.10 → 0.1.12

package/dist/credentials/ZohoCRMDeskOAuth2Api.credentials.js

@@ -110,7 +110,7 @@ class ZohoCRMDeskOAuth2Api {
                 displayName: 'Scope',
                 name: 'scope',
                 type: 'string',
-                default: 'ZohoCRM.modules.ALL Desk.tickets.ALL Desk.contacts.ALL Desk.search.READ Desk.tasks.ALL Desk.basic.READ Desk.settings.READ',
+                default: 'ZohoCRM.modules.ALL Desk.tickets.ALL Desk.contacts.ALL Desk.search.READ Desk.tasks.ALL Desk.basic.READ Desk.settings.READ Desk.webhooks.CREATE Desk.webhooks.READ Desk.webhooks.UPDATE Desk.webhooks.DELETE',
                 required: true,
                 description: 'Space-separated OAuth scopes. Default includes both CRM and Desk permissions. Add or remove scopes as needed (e.g., Desk.settings.ALL, Desk.tasks.ALL).',
             },

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './nodes/ZohoDesk/ZohoDesk.node';
+export * from './nodes/ZohoDesk/ZohoDeskTrigger.node';
 export * from './credentials/ZohoCRMDeskOAuth2Api.credentials';

package/dist/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./nodes/ZohoDesk/ZohoDesk.node"), exports);
+__exportStar(require("./nodes/ZohoDesk/ZohoDeskTrigger.node"), exports);
 __exportStar(require("./credentials/ZohoCRMDeskOAuth2Api.credentials"), exports);

package/dist/nodes/ZohoDesk/ZohoDeskTrigger.node.d.ts

@@ -0,0 +1,20 @@
+import type { IHookFunctions, IWebhookFunctions, ILoadOptionsFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class ZohoDeskTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    methods: {
+        loadOptions: {
+            getDepartments(this: ILoadOptionsFunctions): Promise<{
+                name: string;
+                value: string;
+            }[]>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/ZohoDesk/ZohoDeskTrigger.node.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZohoDeskTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+function getDeskBaseUrl(tokenUrl = '', apiDomain = '', overrideBaseUrl = '') {
+    if (overrideBaseUrl)
+        return overrideBaseUrl;
+    if (apiDomain) {
+        if (apiDomain.includes('.com.au'))
+            return 'https://desk.zoho.com.au';
+        if (apiDomain.includes('.eu'))
+            return 'https://desk.zoho.eu';
+        if (apiDomain.includes('.in'))
+            return 'https://desk.zoho.in';
+        if (apiDomain.includes('.com.cn'))
+            return 'https://desk.zoho.com.cn';
+        if (apiDomain.includes('.com'))
+            return 'https://desk.zoho.com';
+    }
+    if (tokenUrl.includes('zoho.com.au'))
+        return 'https://desk.zoho.com.au';
+    if (tokenUrl.includes('zoho.eu'))
+        return 'https://desk.zoho.eu';
+    if (tokenUrl.includes('zoho.in'))
+        return 'https://desk.zoho.in';
+    if (tokenUrl.includes('zoho.com.cn'))
+        return 'https://desk.zoho.com.cn';
+    return 'https://desk.zoho.com';
+}
+async function deskRequest(context, method, endpoint, organizationId, body = {}) {
+    const credentials = (await context.getCredentials('zohoCRMDeskOAuth2Api'));
+    const { oauthTokenData, accessTokenUrl, authUrl, deskBaseUrl } = credentials;
+    const baseUrl = getDeskBaseUrl(accessTokenUrl || authUrl || '', oauthTokenData?.api_domain || '', deskBaseUrl || '');
+    const options = {
+        method,
+        uri: `${baseUrl}/api/v1${endpoint}`,
+        headers: {
+            orgId: organizationId,
+            'Content-Type': 'application/json',
+        },
+        json: true,
+    };
+    if (method !== 'GET' && method !== 'DELETE' && Object.keys(body).length) {
+        options.body = body;
+    }
+    try {
+        return await context.helpers.requestOAuth2?.call(context, 'zohoCRMDeskOAuth2Api', options);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(context.getNode(), error);
+    }
+}
+async function deskWebhookRequest(context, method, endpoint, body = {}) {
+    const organizationId = context.getNodeParameter('organizationId');
+    return deskRequest(context, method, endpoint, organizationId, body);
+}
+class ZohoDeskTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Zoho Desk Trigger',
+            name: 'zohoDeskTrigger',
+            icon: 'file:zohodesk.png',
+            group: ['trigger'],
+            version: 1,
+            description: 'Starts the workflow when a Zoho Desk event occurs (ticket created, updated, comment added, etc.). Automatically creates and removes the webhook subscription in Zoho Desk.',
+            defaults: { name: 'Zoho Desk Trigger' },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [{ name: 'zohoCRMDeskOAuth2Api', required: true }],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: '={{$parameter["httpMethod"] || "POST"}}',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Organization ID',
+                    name: 'organizationId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'Your Zoho Desk Organization ID. Found in Setup → Developer Space → API.',
+                },
+                {
+                    displayName: 'Events',
+                    name: 'events',
+                    type: 'multiOptions',
+                    required: true,
+                    default: ['Ticket_Add'],
+                    description: 'Zoho Desk events to subscribe to. Ref: https://desk.zoho.com/support/WebhookDocument.do#EventsSupported',
+                    options: [
+                        { name: 'Ticket Created', value: 'Ticket_Add' },
+                        { name: 'Ticket Updated', value: 'Ticket_Update' },
+                        { name: 'Ticket Deleted', value: 'Ticket_Delete' },
+                        { name: 'Comment Added', value: 'Ticket_Comment_Add' },
+                        { name: 'Comment Updated', value: 'Ticket_Comment_Update' },
+                        { name: 'Thread Added', value: 'Ticket_Thread_Add' },
+                        { name: 'Contact Created', value: 'Contact_Add' },
+                        { name: 'Contact Updated', value: 'Contact_Update' },
+                        { name: 'Contact Deleted', value: 'Contact_Delete' },
+                    ],
+                },
+                {
+                    displayName: 'Departments (Optional)',
+                    name: 'departmentIds',
+                    type: 'multiOptions',
+                    default: [],
+                    description: 'Filter ticket/comment events to specific departments. Leave blank to receive events from all departments. Only applies to Ticket and Comment events.',
+                    typeOptions: {
+                        loadOptionsMethod: 'getDepartments',
+                        loadOptionsDependsOn: ['organizationId'],
+                    },
+                    options: [],
+                },
+                {
+                    displayName: 'Webhook Name',
+                    name: 'webhookName',
+                    type: 'string',
+                    default: 'n8n Zoho Desk Trigger',
+                    description: 'Name for the webhook subscription created in Zoho Desk',
+                },
+                {
+                    displayName: 'Include Previous State (Ticket Update)',
+                    name: 'includePrevState',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to include the previous state of the ticket in Ticket_Update events. Zoho Desk returns prevState only when supported by the event.',
+                },
+            ],
+        };
+        // Lifecycle methods: create/delete webhook in Zoho Desk on workflow activate/deactivate
+        // Ref: POST /api/v1/webhooks (Desk.webhooks.CREATE), DELETE /api/v1/webhooks/{id} (Desk.webhooks.DELETE)
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (!webhookData.webhookId)
+                        return false;
+                    // Verify the webhook still exists in Zoho Desk
+                    // Ref: GET /api/v1/webhooks/{webhook_id} (Desk.webhooks.READ)
+                    try {
+                        const response = await deskWebhookRequest(this, 'GET', `/webhooks/${webhookData.webhookId}`);
+                        return !!(response && response.id);
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const events = this.getNodeParameter('events');
+                    const deptIds = this.getNodeParameter('departmentIds', []);
+                    const webhookName = this.getNodeParameter('webhookName');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    // Build subscriptions object per API spec
+                    // Ticket/Comment events support optional departmentIds filter
+                    // Ref: https://desk.zoho.com/support/WebhookDocument.do#Webhook
+                    const ticketEvents = new Set([
+                        'Ticket_Add', 'Ticket_Update', 'Ticket_Delete',
+                        'Ticket_Comment_Add', 'Ticket_Comment_Update', 'Ticket_Thread_Add',
+                    ]);
+                    const subscriptions = {};
+                    for (const event of events) {
+                        if (deptIds.length > 0 && ticketEvents.has(event)) {
+                            subscriptions[event] = { departmentIds: deptIds };
+                        }
+                        else {
+                            subscriptions[event] = null;
+                        }
+                    }
+                    const body = {
+                        name: webhookName,
+                        url: webhookUrl,
+                        subscriptions,
+                        isEnabled: true,
+                    };
+                    const response = await deskWebhookRequest(this, 'POST', '/webhooks', body);
+                    if (!response?.id) {
+                        throw new n8n_workflow_1.NodeApiError(this.getNode(), response, {
+                            message: 'Zoho Desk did not return a webhook ID. Webhook creation may have failed.',
+                        });
+                    }
+                    // Store the webhook ID so we can delete it on deactivate
+                    webhookData.webhookId = response.id;
+                    return true;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (!webhookData.webhookId)
+                        return true;
+                    // Ref: DELETE /api/v1/webhooks/{webhooks_id} (Desk.webhooks.DELETE)
+                    try {
+                        await deskWebhookRequest(this, 'DELETE', `/webhooks/${webhookData.webhookId}`);
+                    }
+                    catch {
+                        return false;
+                    }
+                    delete webhookData.webhookId;
+                    return true;
+                },
+            },
+        };
+        this.methods = {
+            loadOptions: {
+                async getDepartments() {
+                    const organizationId = this.getNodeParameter('organizationId', 0, '');
+                    try {
+                        const responseData = await deskRequest(this, 'GET', '/departments', organizationId);
+                        const departments = Array.isArray(responseData.data)
+                            ? responseData.data
+                            : Array.isArray(responseData)
+                                ? responseData
+                                : [];
+                        return departments.map((dept) => ({
+                            name: dept.name || dept.departmentName || String(dept.id),
+                            value: dept.id,
+                        }));
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to load departments: ${error.message}. Ensure Organization ID is set correctly.`);
+                    }
+                },
+            },
+        };
+    }
+    // Receive and process incoming webhook payload from Zoho Desk
+    // Ref: https://desk.zoho.com/support/WebhookDocument.do#EventsSupported
+    async webhook() {
+        const req = this.getRequestObject();
+        // Zoho sends a validation GET request when first creating the webhook.
+        // Return 200 OK immediately so registration succeeds.
+        if (req.method === 'GET') {
+            return {
+                webhookResponse: { status: 'ok' },
+            };
+        }
+        // Payload is an array of event objects
+        const body = this.getBodyData();
+        const events = Array.isArray(body) ? body : [body];
+        const jwtToken = req.headers['x-zdesk-jwt'] || null;
+        const returnItems = [];
+        for (const event of events) {
+            const output = {
+                eventType: event.eventType,
+                eventTime: event.eventTime,
+                orgId: event.orgId,
+                payload: event.payload ?? {},
+            };
+            // Include prevState for update events when present
+            if (event.prevState) {
+                output.prevState = event.prevState;
+            }
+            // Forward JWT token for caller verification if needed
+            // Ref: https://desk.zoho.com/support/WebhookDocument.do#WebhookAuthentication
+            if (jwtToken) {
+                output._jwtToken = jwtToken;
+            }
+            returnItems.push(output);
+        }
+        return {
+            workflowData: [returnItems.map((item) => ({ json: item }))],
+        };
+    }
+}
+exports.ZohoDeskTrigger = ZohoDeskTrigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trg-admin/n8n-nodes-zoho-desk",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Community n8n node starter for Zoho Desk using built-in Zoho OAuth2 auth behavior",
   "license": "MIT",
   "type": "commonjs",
@@ -22,7 +22,8 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "nodes": [
-      "dist/nodes/ZohoDesk/ZohoDesk.node.js"
+      "dist/nodes/ZohoDesk/ZohoDesk.node.js",
+      "dist/nodes/ZohoDesk/ZohoDeskTrigger.node.js"
     ],
     "credentials": [
       "dist/credentials/ZohoCRMDeskOAuth2Api.credentials.js"