@trg-admin/n8n-nodes-zoho-desk 0.1.22 → 0.1.24

package/README.md

@@ -33,15 +33,19 @@ When you create the credential in n8n, the default scope is:
 
 ```
 ZohoCRM.modules.ALL Desk.tickets.ALL Desk.contacts.ALL Desk.search.READ
+Desk.tasks.ALL Desk.basic.READ Desk.fields.READ Desk.settings.READ
+Desk.webhooks.CREATE Desk.webhooks.READ Desk.webhooks.UPDATE Desk.webhooks.DELETE
 ```
 
 **Available Zoho Desk Scopes:**
 - `Desk.tickets.ALL` - Full access to tickets
 - `Desk.contacts.ALL` - Full access to contacts  
 - `Desk.search.READ` - Search across modules
+- `Desk.fields.READ` - Read field definitions (required for the Classification / Category / Sub-Category and Channel dropdowns)
 - `Desk.settings.ALL` - Access to settings and configurations
 - `Desk.tasks.ALL` - Task management
 - `Desk.basic.READ` - Read-only access to basic information
+- `Desk.webhooks.*` - Webhook subscription management (required by the Zoho Desk Trigger node)
 
 You can customize the scope field in the credential to add or remove permissions as needed.
 

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 Desk.webhooks.CREATE Desk.webhooks.READ Desk.webhooks.UPDATE Desk.webhooks.DELETE',
+                default: 'ZohoCRM.modules.ALL Desk.tickets.ALL Desk.contacts.ALL Desk.search.READ Desk.tasks.ALL Desk.basic.READ Desk.fields.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/nodes/ZohoDesk/ZohoDesk.node.d.ts

@@ -1,4 +1,23 @@
 import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions } from 'n8n-workflow';
+/**
+ * Load a ticket taxonomy picklist (classification / category / subCategory) for a dropdown.
+ *
+ * Zoho Desk has no /classifications, /categories or /subcategories endpoints — ticket
+ * taxonomy is exposed through the ticket module's organization field definitions.
+ *
+ * The ticket payload takes the taxonomy *name string* (there is no classificationId /
+ * categoryId / subCategoryId on a ticket), so the option value is the value itself.
+ *
+ * ponytail: the three levels are listed independently rather than cascaded. Whether a
+ * subCategory must be mapped under the chosen category is configured per-tenant (field
+ * dependencies) and is not documented as an API rule, so we list all values and let the
+ * API answer. Upgrade to GET /layouts/{layoutId}/fields/{fieldId}/dependentValues if users
+ * hit rejections in tenants that do enforce the mapping.
+ */
+export declare function loadTaxonomyOptions(context: ILoadOptionsFunctions, apiName: string): Promise<Array<{
+    name: string;
+    value: string;
+}>>;
 export declare class ZohoDesk implements INodeType {
     description: INodeTypeDescription;
     methods: {
@@ -11,6 +30,18 @@ export declare class ZohoDesk implements INodeType {
                 name: string;
                 value: string;
             }[]>;
+            getClassifications(this: ILoadOptionsFunctions): Promise<{
+                name: string;
+                value: string;
+            }[]>;
+            getCategories(this: ILoadOptionsFunctions): Promise<{
+                name: string;
+                value: string;
+            }[]>;
+            getSubCategories(this: ILoadOptionsFunctions): Promise<{
+                name: string;
+                value: string;
+            }[]>;
         };
     };
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;

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

@@ -1,8 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZohoDesk = void 0;
+exports.loadTaxonomyOptions = loadTaxonomyOptions;
 const n8n_workflow_1 = require("n8n-workflow");
 const GenericFunctions_1 = require("./GenericFunctions");
+function cleanCommaSeparated(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .join(',');
+}
+/**
+ * Load a ticket taxonomy picklist (classification / category / subCategory) for a dropdown.
+ *
+ * Zoho Desk has no /classifications, /categories or /subcategories endpoints — ticket
+ * taxonomy is exposed through the ticket module's organization field definitions.
+ *
+ * The ticket payload takes the taxonomy *name string* (there is no classificationId /
+ * categoryId / subCategoryId on a ticket), so the option value is the value itself.
+ *
+ * ponytail: the three levels are listed independently rather than cascaded. Whether a
+ * subCategory must be mapped under the chosen category is configured per-tenant (field
+ * dependencies) and is not documented as an API rule, so we list all values and let the
+ * API answer. Upgrade to GET /layouts/{layoutId}/fields/{fieldId}/dependentValues if users
+ * hit rejections in tenants that do enforce the mapping.
+ */
+async function loadTaxonomyOptions(context, apiName) {
+    // Taxonomy is department-scoped; only top-level ticket parameters carry a department.
+    const departmentId = context.getCurrentNodeParameter('departmentId');
+    const qs = { module: 'tickets', apiNames: apiName };
+    if (departmentId) {
+        qs.departmentId = String(departmentId);
+    }
+    try {
+        const responseData = await GenericFunctions_1.zohoDeskApiRequest.call(context, 'GET', '/organizationFields', {}, qs, 0);
+        const fields = Array.isArray(responseData?.data)
+            ? responseData.data
+            : Array.isArray(responseData)
+                ? responseData
+                : [];
+        const field = fields.find((f) => String(f.apiName || '').toLowerCase() === apiName.toLowerCase());
+        // Field definitions carry picklist values under either key depending on tenant.
+        const rawValues = (field?.pickListValues ?? field?.allowedValues ?? []);
+        const seen = new Set();
+        const options = [];
+        for (const entry of rawValues) {
+            const value = typeof entry === 'string'
+                ? entry
+                : (entry.value || entry.displayValue || '');
+            if (!value || seen.has(value)) {
+                continue;
+            }
+            seen.add(value);
+            options.push({ name: value, value });
+        }
+        return options.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    catch (error) {
+        throw new Error(`Failed to load "${apiName}" values from the ticket layout. Error: ${error.message}`);
+    }
+}
 class ZohoDesk {
     constructor() {
         this.description = {
@@ -43,6 +104,21 @@ class ZohoDesk {
                         { name: 'Ticket', value: 'ticket' },
                         { name: 'Contact', value: 'contact' },
                         { name: 'Comment', value: 'comment' },
+                        { name: 'Thread', value: 'thread' },
+                    ],
+                },
+                // Thread Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['thread'] } },
+                    default: 'getAll',
+                    options: [
+                        { name: 'Get', value: 'get', action: 'Get a thread from a ticket' },
+                        { name: 'Get Many', value: 'getAll', action: 'Get all threads from a ticket' },
+                        { name: 'Send Reply', value: 'sendReply', action: 'Send a reply to a ticket' },
                     ],
                 },
                 // Ticket Operations
@@ -165,6 +241,39 @@ class ZohoDesk {
                             default: 'Email',
                             description: 'Channel through which the ticket was received or created. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
                         },
+                        {
+                            displayName: 'Classification',
+                            name: 'classification',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getClassifications',
+                                loadOptionsDependsOn: ['organizationId', 'departmentId'],
+                            },
+                            default: '',
+                            description: 'Top-level ticket classification, as configured on the department\'s ticket layout. Choose from the list, or specify a value using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                        },
+                        {
+                            displayName: 'Category',
+                            name: 'category',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getCategories',
+                                loadOptionsDependsOn: ['organizationId', 'departmentId'],
+                            },
+                            default: '',
+                            description: 'Ticket category, as configured on the department\'s ticket layout. Choose from the list, or specify a value using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                        },
+                        {
+                            displayName: 'Sub-Category',
+                            name: 'subCategory',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getSubCategories',
+                                loadOptionsDependsOn: ['organizationId', 'departmentId'],
+                            },
+                            default: '',
+                            description: 'Ticket sub-category, as configured on the department\'s ticket layout. Choose from the list, or specify a value using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                        },
                         {
                             displayName: 'Contact ID',
                             name: 'contactId',
@@ -593,6 +702,155 @@ class ZohoDesk {
                     displayOptions: { show: { resource: ['comment'], operation: ['getAll'] } },
                     description: 'Max number of results to return',
                 },
+                // ================== Thread Resource Parameters ==================
+                {
+                    displayName: 'Ticket ID',
+                    name: 'ticketId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { resource: ['thread'], operation: ['get', 'getAll', 'sendReply'] } },
+                    description: 'The unique ID of the ticket',
+                },
+                {
+                    displayName: 'Thread ID',
+                    name: 'threadId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { resource: ['thread'], operation: ['get'] } },
+                    description: 'The unique ID of the thread',
+                },
+                {
+                    displayName: 'Content',
+                    name: 'content',
+                    type: 'string',
+                    typeOptions: { alwaysOpenEditWindow: true },
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { resource: ['thread'], operation: ['sendReply'] } },
+                    description: 'Content / body of the reply',
+                },
+                {
+                    displayName: 'Content Type',
+                    name: 'contentType',
+                    type: 'options',
+                    options: [
+                        { name: 'HTML', value: 'html' },
+                        { name: 'Plain Text', value: 'plainText' },
+                    ],
+                    default: 'html',
+                    displayOptions: { show: { resource: ['thread'], operation: ['sendReply'] } },
+                    description: 'Format of the reply content',
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'additionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { resource: ['thread'], operation: ['sendReply'] } },
+                    options: [
+                        {
+                            displayName: 'BCC',
+                            name: 'bcc',
+                            type: 'string',
+                            default: '',
+                            placeholder: '[EMAIL_REDACTED], [EMAIL_REDACTED]',
+                            description: 'Blind carbon copy recipient email addresses. Multiple addresses can be separated with commas.',
+                        },
+                        {
+                            displayName: 'CC',
+                            name: 'cc',
+                            type: 'string',
+                            default: '',
+                            placeholder: '[EMAIL_REDACTED], [EMAIL_REDACTED]',
+                            description: 'Carbon copy recipient email addresses. Multiple addresses can be separated with commas.',
+                        },
+                        {
+                            displayName: 'Channel',
+                            name: 'channel',
+                            type: 'options',
+                            options: [
+                                { name: 'Email', value: 'EMAIL' },
+                                { name: 'Phone', value: 'PHONE' },
+                            ],
+                            default: 'EMAIL',
+                            description: 'Channel through which the reply is sent',
+                        },
+                        {
+                            displayName: 'From Email Address',
+                            name: 'fromEmailAddress',
+                            type: 'string',
+                            default: '',
+                            description: 'Sender email address. Must be a verified "From Address" configured in Zoho Desk Setup.',
+                        },
+                        {
+                            displayName: 'Is Forward',
+                            name: 'isForward',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether this reply is a forwarded message',
+                        },
+                        {
+                            displayName: 'To',
+                            name: 'to',
+                            type: 'string',
+                            default: '',
+                            placeholder: '[EMAIL_REDACTED], [EMAIL_REDACTED]',
+                            description: 'Recipient email address(es). Multiple addresses can be separated with commas.',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: { show: { resource: ['thread'], operation: ['getAll'] } },
+                    description: 'Whether to return all results or limit to specified number',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 100 },
+                    default: 50,
+                    displayOptions: {
+                        show: {
+                            resource: ['thread'],
+                            operation: ['getAll'],
+                            returnAll: [false],
+                        },
+                    },
+                    description: 'Max number of results to return (1-100)',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: { show: { resource: ['thread'], operation: ['get', 'getAll'] } },
+                    options: [
+                        {
+                            displayName: 'From (Offset)',
+                            name: 'from',
+                            type: 'number',
+                            typeOptions: { minValue: 0 },
+                            default: 0,
+                            description: 'Index number from which the threads should be fetched (getAll only)',
+                        },
+                        {
+                            displayName: 'Include',
+                            name: 'include',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'canReply, draft, portalHtmlUrl',
+                            description: 'Additional information to include in response (e.g. canReply, draft, portalHtmlUrl). Multiple values can be separated with commas.',
+                        },
+                    ],
+                },
             ],
         };
         this.methods = {
@@ -701,6 +959,15 @@ class ZohoDesk {
                     }
                     return fallbackChannels;
                 },
+                async getClassifications() {
+                    return loadTaxonomyOptions(this, 'classification');
+                },
+                async getCategories() {
+                    return loadTaxonomyOptions(this, 'category');
+                },
+                async getSubCategories() {
+                    return loadTaxonomyOptions(this, 'subCategory');
+                },
             },
         };
     }
@@ -1049,6 +1316,85 @@ class ZohoDesk {
                         }
                     }
                 }
+                // ==================== THREAD OPERATIONS ====================
+                if (resource === 'thread') {
+                    if (operation === 'get') {
+                        const ticketId = this.getNodeParameter('ticketId', i);
+                        const threadId = this.getNodeParameter('threadId', i);
+                        const options = this.getNodeParameter('options', i, {});
+                        const qs = {};
+                        if (options.include) {
+                            const clean = cleanCommaSeparated(options.include);
+                            if (clean)
+                                qs.include = clean;
+                        }
+                        const responseData = await GenericFunctions_1.zohoDeskApiRequest.call(this, 'GET', `/tickets/${ticketId}/threads/${threadId}`, {}, qs, i);
+                        returnData.push({ json: responseData });
+                    }
+                    if (operation === 'getAll') {
+                        const ticketId = this.getNodeParameter('ticketId', i);
+                        const returnAll = this.getNodeParameter('returnAll', i, false);
+                        const options = this.getNodeParameter('options', i, {});
+                        const qs = {};
+                        if (options.include) {
+                            const clean = cleanCommaSeparated(options.include);
+                            if (clean)
+                                qs.include = clean;
+                        }
+                        if (returnAll) {
+                            const responseData = await GenericFunctions_1.zohoDeskApiRequestAllItems.call(this, 'GET', `/tickets/${ticketId}/threads`, {}, qs, i);
+                            for (const row of responseData) {
+                                returnData.push({ json: row });
+                            }
+                        }
+                        else {
+                            const limit = this.getNodeParameter('limit', i, 50);
+                            qs.limit = limit;
+                            if (options.from !== undefined && options.from !== null && options.from !== '') {
+                                qs.from = options.from;
+                            }
+                            const responseData = await GenericFunctions_1.zohoDeskApiRequest.call(this, 'GET', `/tickets/${ticketId}/threads`, {}, qs, i);
+                            const data = Array.isArray(responseData.data)
+                                ? responseData.data
+                                : Array.isArray(responseData)
+                                    ? responseData
+                                    : [responseData];
+                            for (const row of data) {
+                                returnData.push({ json: row });
+                            }
+                        }
+                    }
+                    if (operation === 'sendReply') {
+                        const ticketId = this.getNodeParameter('ticketId', i);
+                        const content = this.getNodeParameter('content', i);
+                        const contentType = this.getNodeParameter('contentType', i, 'html');
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        const body = {
+                            content,
+                            contentType,
+                        };
+                        if (additionalFields.channel) {
+                            body.channel = additionalFields.channel;
+                        }
+                        if (additionalFields.fromEmailAddress) {
+                            body.fromEmailAddress = String(additionalFields.fromEmailAddress).trim();
+                        }
+                        if (additionalFields.to) {
+                            body.to = cleanCommaSeparated(additionalFields.to);
+                        }
+                        if (additionalFields.cc) {
+                            body.cc = cleanCommaSeparated(additionalFields.cc).split(',').filter(Boolean);
+                        }
+                        if (additionalFields.bcc) {
+                            body.bcc = cleanCommaSeparated(additionalFields.bcc).split(',').filter(Boolean);
+                        }
+                        if (additionalFields.isForward !== undefined) {
+                            body.isForward = additionalFields.isForward;
+                        }
+                        const responseData = await GenericFunctions_1.zohoDeskApiRequest.call(this, 'POST', `/tickets/${ticketId}/sendReply`, body, {}, i);
+                        returnData.push({ json: responseData });
+                    }
+                }
             }
             catch (error) {
                 if (this.continueOnFail()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trg-admin/n8n-nodes-zoho-desk",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Community n8n node starter for Zoho Desk using built-in Zoho OAuth2 auth behavior",
   "license": "MIT",
   "type": "commonjs",
@@ -10,7 +10,7 @@
     "copy-assets": "cp nodes/ZohoDesk/zohodesk.png dist/nodes/ZohoDesk/",
     "lint": "echo 'No linter configured'",
     "typecheck": "tsc --noEmit",
-    "test": "node scripts.validate.js",
+    "test": "node scripts.validate.js && node test/Taxonomy.test.js",
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "files": [