@trg-admin/n8n-nodes-zoho-desk 0.1.19 → 0.1.21

package/dist/nodes/ZohoDesk/GenericFunctions.js

@@ -85,17 +85,25 @@ async function zohoDeskApiRequest(method, endpoint, body = {}, qs = {}, itemInde
 async function zohoDeskApiRequestAllItems(method, endpoint, body = {}, qs = {}, itemIndex = 0) {
     const returnData = [];
     let responseData;
-    qs.limit = 100; // Zoho Desk max limit per page
-    qs.from = 0;
+    const query = {
+        ...qs,
+        limit: qs.limit || 100,
+        from: qs.from || 0,
+    };
     do {
-        responseData = await zohoDeskApiRequest.call(this, method, endpoint, body, qs, itemIndex);
-        if (responseData.data && Array.isArray(responseData.data)) {
-            returnData.push(...responseData.data);
-            if (responseData.data.length < 100) {
+        responseData = await zohoDeskApiRequest.call(this, method, endpoint, body, query, itemIndex);
+        const items = Array.isArray(responseData?.data)
+            ? responseData.data
+            : Array.isArray(responseData)
+                ? responseData
+                : [];
+        if (items.length > 0) {
+            returnData.push(...items);
+            if (items.length < query.limit) {
                 // Last page
                 break;
             }
-            qs.from = qs.from + 100;
+            query.from = query.from + items.length;
         }
         else {
             break;

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

@@ -127,8 +127,8 @@ class ZohoDesk {
                     },
                     default: '',
                     required: true,
-                    displayOptions: { show: { resource: ['ticket'], operation: ['create', 'getAll'] } },
-                    description: 'Department to assign or filter tickets by. Make sure Organization ID is filled in first.',
+                    displayOptions: { show: { resource: ['ticket'], operation: ['create'] } },
+                    description: 'Department to assign ticket to. Make sure Organization ID is filled in first.',
                 },
                 {
                     displayName: 'Description',
@@ -241,22 +241,162 @@ class ZohoDesk {
                         },
                     ],
                 },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: { show: { resource: ['ticket'], 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: 20,
-                    displayOptions: { show: { resource: ['ticket'], operation: ['getAll'] } },
-                    description: 'Max number of results to return',
+                    default: 50,
+                    displayOptions: {
+                        show: {
+                            resource: ['ticket'],
+                            operation: ['getAll'],
+                            returnAll: [false],
+                        },
+                    },
+                    description: 'Max number of results to return (1-100)',
                 },
                 {
-                    displayName: 'Return All',
-                    name: 'returnAll',
-                    type: 'boolean',
-                    default: false,
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
                     displayOptions: { show: { resource: ['ticket'], operation: ['getAll'] } },
-                    description: 'Whether to return all results or limit to specified number',
+                    options: [
+                        {
+                            displayName: 'Assignee',
+                            name: 'assignee',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'Unassigned or Agent ID',
+                            description: 'ID of the assignee, or "Unassigned" for tickets not assigned to any agent. Multiple values can be separated with commas.',
+                        },
+                        {
+                            displayName: 'Channel',
+                            name: 'channel',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'Email, Phone, Web, Chat',
+                            description: 'Channel through which the ticket was created. Multiple values can be separated with commas.',
+                        },
+                        {
+                            displayName: 'Department',
+                            name: 'departmentId',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getDepartments',
+                                loadOptionsDependsOn: ['organizationId'],
+                            },
+                            default: '',
+                            description: 'Filter tickets by department. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                        },
+                        {
+                            displayName: 'Department IDs',
+                            name: 'departmentIds',
+                            type: 'string',
+                            default: '',
+                            placeholder: '[BR_PHONE_LANDLINE_REDACTED]5,[BR_PHONE_LANDLINE_REDACTED]6',
+                            description: 'Comma-separated department IDs to fetch tickets from (e.g. for "All Departments" view)',
+                        },
+                        {
+                            displayName: 'Fields',
+                            name: 'fields',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'statusType,webUrl,layoutId',
+                            description: 'Comma-separated list of system and custom fields to include in the response (maximum 30 fields)',
+                        },
+                        {
+                            displayName: 'From (Offset)',
+                            name: 'from',
+                            type: 'number',
+                            typeOptions: { minValue: 0 },
+                            default: 0,
+                            description: 'Index number from which the tickets should be fetched. Only applied when Return All is disabled.',
+                        },
+                        {
+                            displayName: 'Include',
+                            name: 'include',
+                            type: 'multiOptions',
+                            default: [],
+                            options: [
+                                { name: 'Assignee', value: 'assignee' },
+                                { name: 'Contacts', value: 'contacts' },
+                                { name: 'Departments', value: 'departments' },
+                                { name: 'Is Read', value: 'isRead' },
+                                { name: 'Products', value: 'products' },
+                                { name: 'Team', value: 'team' },
+                            ],
+                            description: 'Additional related information to include in the response',
+                        },
+                        {
+                            displayName: 'Priority',
+                            name: 'priority',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'Low, Medium, High',
+                            description: 'Priority of the ticket (e.g., Low, Medium, High). Multiple values can be separated with commas.',
+                        },
+                        {
+                            displayName: 'Received in Days',
+                            name: 'receivedInDays',
+                            type: 'options',
+                            default: 30,
+                            options: [
+                                { name: '15 Days', value: 15 },
+                                { name: '30 Days', value: 30 },
+                                { name: '90 Days', value: 90 },
+                            ],
+                            description: 'Time period (in days) for fetching tickets based on customerResponseTime',
+                        },
+                        {
+                            displayName: 'Sort By',
+                            name: 'sortBy',
+                            type: 'options',
+                            default: '-createdTime',
+                            options: [
+                                { name: 'Created Time (Newest First)', value: '-createdTime' },
+                                { name: 'Created Time (Oldest First)', value: 'createdTime' },
+                                { name: 'Customer Response Time (Newest First)', value: '-customerResponseTime' },
+                                { name: 'Customer Response Time (Oldest First)', value: 'customerResponseTime' },
+                                { name: 'Response Due Date (Ascending)', value: 'responseDueDate' },
+                                { name: 'Response Due Date (Descending)', value: '-responseDueDate' },
+                            ],
+                            description: 'Sort tickets by the specified attribute. Prefix with (-) for descending order.',
+                        },
+                        {
+                            displayName: 'Status',
+                            name: 'status',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'Open, On Hold, Escalated, Closed',
+                            description: 'Status of the ticket (e.g., Open, On Hold, Escalated, Closed). Multiple values can be separated with commas.',
+                        },
+                        {
+                            displayName: 'Team IDs',
+                            name: 'teamIds',
+                            type: 'string',
+                            default: '',
+                            placeholder: 'Unassigned or Team ID',
+                            description: 'ID(s) of the team, or "Unassigned". Multiple values can be separated with commas.',
+                        },
+                        {
+                            displayName: 'View ID',
+                            name: 'viewId',
+                            type: 'string',
+                            default: '',
+                            description: 'ID of the Zoho Desk view based on which tickets must be fetched',
+                        },
+                    ],
                 },
                 // ================== Contact Resource Parameters ==================
                 {
@@ -459,13 +599,9 @@ class ZohoDesk {
             loadOptions: {
                 async getDepartments() {
                     try {
-                        const responseData = await GenericFunctions_1.zohoDeskApiRequest.call(this, 'GET', '/departments', {}, {}, 0);
-                        const departments = Array.isArray(responseData.data)
-                            ? responseData.data
-                            : Array.isArray(responseData)
-                                ? responseData
-                                : [];
-                        return departments.map((department) => {
+                        const departments = (await GenericFunctions_1.zohoDeskApiRequestAllItems.call(this, 'GET', '/departments', {}, {}, 0));
+                        return departments
+                            .map((department) => {
                             const name = department.name ||
                                 department.departmentName ||
                                 String(department.id);
@@ -473,7 +609,8 @@ class ZohoDesk {
                                 name,
                                 value: department.id,
                             };
-                        });
+                        })
+                            .sort((a, b) => a.name.localeCompare(b.name));
                     }
                     catch (error) {
                         throw new Error(`Failed to load departments. Error: ${error.message}. Ensure Organization ID is correct and Desk API Base URL matches your region.`);
@@ -623,19 +760,74 @@ class ZohoDesk {
                     }
                     if (operation === 'getAll') {
                         const returnAll = this.getNodeParameter('returnAll', i, false);
-                        const departmentId = this.getNodeParameter('departmentId', i);
+                        const options = this.getNodeParameter('options', i, {});
+                        const qs = {};
+                        // Department filtering: options.departmentIds, options.departmentId, or legacy parameter
+                        const topLevelDepartmentId = this.getNodeParameter('departmentId', i, '');
+                        if (options.departmentIds) {
+                            qs.departmentIds = options.departmentIds;
+                        }
+                        else if (options.departmentId) {
+                            qs.departmentId = options.departmentId;
+                        }
+                        else if (topLevelDepartmentId) {
+                            qs.departmentId = topLevelDepartmentId;
+                        }
+                        if (options.viewId) {
+                            qs.viewId = options.viewId;
+                        }
+                        if (options.assignee) {
+                            qs.assignee = options.assignee;
+                        }
+                        if (options.teamIds) {
+                            qs.teamIds = options.teamIds;
+                        }
+                        if (options.channel) {
+                            qs.channel = options.channel;
+                        }
+                        if (options.status) {
+                            qs.status = options.status;
+                        }
+                        if (options.priority) {
+                            qs.priority = options.priority;
+                        }
+                        if (options.sortBy) {
+                            qs.sortBy = options.sortBy;
+                        }
+                        if (options.receivedInDays) {
+                            qs.receivedInDays = options.receivedInDays;
+                        }
+                        if (options.fields) {
+                            qs.fields = options.fields;
+                        }
+                        if (options.include) {
+                            if (Array.isArray(options.include)) {
+                                if (options.include.length > 0) {
+                                    qs.include = options.include.join(',');
+                                }
+                            }
+                            else if (typeof options.include === 'string' && options.include.trim()) {
+                                qs.include = options.include.trim();
+                            }
+                        }
                         if (returnAll) {
-                            const responseData = await GenericFunctions_1.zohoDeskApiRequestAllItems.call(this, 'GET', '/tickets', {}, { departmentId }, i);
+                            const responseData = await GenericFunctions_1.zohoDeskApiRequestAllItems.call(this, 'GET', '/tickets', {}, qs, i);
                             for (const row of responseData) {
                                 returnData.push({ json: row });
                             }
                         }
                         else {
-                            const limit = this.getNodeParameter('limit', i);
-                            const responseData = await GenericFunctions_1.zohoDeskApiRequest.call(this, 'GET', '/tickets', {}, { limit, departmentId }, i);
+                            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', {}, qs, i);
                             const data = Array.isArray(responseData.data)
                                 ? responseData.data
-                                : [responseData];
+                                : Array.isArray(responseData)
+                                    ? responseData
+                                    : [responseData];
                             for (const row of data) {
                                 returnData.push({ json: row });
                             }

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

@@ -27,7 +27,7 @@ function getDeskBaseUrl(tokenUrl = '', apiDomain = '', overrideBaseUrl = '') {
         return 'https://desk.zoho.com.cn';
     return 'https://desk.zoho.com';
 }
-async function deskRequest(context, method, endpoint, organizationId, body = {}) {
+async function deskRequest(context, method, endpoint, organizationId, body = {}, qs = {}) {
     const credentials = (await context.getCredentials('zohoCRMDeskOAuth2Api'));
     const { oauthTokenData, accessTokenUrl, authUrl, deskBaseUrl } = credentials;
     const baseUrl = getDeskBaseUrl(accessTokenUrl || authUrl || '', oauthTokenData?.api_domain || '', deskBaseUrl || '');
@@ -40,6 +40,9 @@ async function deskRequest(context, method, endpoint, organizationId, body = {})
         },
         json: true,
     };
+    if (Object.keys(qs).length) {
+        options.qs = qs;
+    }
     if (method !== 'GET' && method !== 'DELETE' && Object.keys(body).length) {
         options.body = body;
     }
@@ -50,6 +53,34 @@ async function deskRequest(context, method, endpoint, organizationId, body = {})
         throw new n8n_workflow_1.NodeApiError(context.getNode(), error);
     }
 }
+async function deskRequestAllItems(context, method, endpoint, organizationId, body = {}, qs = {}) {
+    const returnData = [];
+    let responseData;
+    const query = {
+        ...qs,
+        limit: qs.limit || 100,
+        from: qs.from || 0,
+    };
+    do {
+        responseData = await deskRequest(context, method, endpoint, organizationId, body, query);
+        const items = Array.isArray(responseData?.data)
+            ? responseData.data
+            : Array.isArray(responseData)
+                ? responseData
+                : [];
+        if (items.length > 0) {
+            returnData.push(...items);
+            if (items.length < query.limit) {
+                break;
+            }
+            query.from = query.from + items.length;
+        }
+        else {
+            break;
+        }
+    } while (true);
+    return returnData;
+}
 async function deskWebhookRequest(context, method, endpoint, body = {}) {
     const organizationId = context.getNodeParameter('organizationId');
     return deskRequest(context, method, endpoint, organizationId, body);
@@ -208,16 +239,13 @@ class ZohoDeskTrigger {
                 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) => ({
+                        const departments = await deskRequestAllItems(this, 'GET', '/departments', organizationId);
+                        return departments
+                            .map((dept) => ({
                             name: dept.name || dept.departmentName || String(dept.id),
                             value: dept.id,
-                        }));
+                        }))
+                            .sort((a, b) => a.name.localeCompare(b.name));
                     }
                     catch (error) {
                         throw new Error(`Failed to load departments: ${error.message}. Ensure Organization ID is set correctly.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trg-admin/n8n-nodes-zoho-desk",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Community n8n node starter for Zoho Desk using built-in Zoho OAuth2 auth behavior",
   "license": "MIT",
   "type": "commonjs",