fix: tighten filter serialization and align tickets getAll with assets

Omit false boolean filter defaults, auto-enable pageinate when page_size or page_no is set, extract pagination helpers, and parse limited ticket responses using the same fallback chain as assets.

Author: redanthrax

nodes/HaloPSA/actions/tickets/getAll/execute.ts

@@ -2,15 +2,14 @@ import { IExecuteFunctions } from 'n8n-workflow';
 import { IDataObject, INodeExecutionData } from 'n8n-workflow';
 import { applyFiltersToQueryString, resolveFilters } from '../../../filterParameters';
 import { apiRequest, apiRequestAllItems } from '../../../transport';
-import { HaloTicketsListResponse } from '../../Interfaces';
 
 export async function execute(
 	this: IExecuteFunctions,
 	index: number,
 ): Promise<INodeExecutionData[]> {
 	const returnAll = this.getNodeParameter('returnAll', index) as boolean;
 	const filters = resolveFilters.call(this, index);
-	
+
 	const qs = applyFiltersToQueryString(filters);
 
 	if (!returnAll) {
@@ -22,12 +21,13 @@ export async function execute(
 	const endpoint = '/Tickets';
 	const body = {} as IDataObject;
 
-if (returnAll) {
-	const all = await apiRequestAllItems.call(this, requestMethod, endpoint, 'tickets', body, qs);
-	return this.helpers.returnJsonArray(all);
-}
+	if (returnAll) {
+		const all = await apiRequestAllItems.call(this, requestMethod, endpoint, 'tickets', body, qs);
+		return this.helpers.returnJsonArray(all);
+	}
 
-let responseData: HaloTicketsListResponse;
-responseData = await apiRequest.call(this, requestMethod, endpoint, body, qs);
-return this.helpers.returnJsonArray(responseData.tickets || []);
-}
+	let responseData: any;
+	responseData = await apiRequest.call(this, requestMethod, endpoint, body, qs);
+
+	return this.helpers.returnJsonArray(responseData.tickets || responseData || []);
+}

nodes/HaloPSA/filterParameters.ts

@@ -165,8 +165,7 @@ export function normalizeCustomfieldsField(fields: IDataObject): void {
 
 /**
  * Whether a filter value should be sent to the HaloPSA API.
- * Omits UI defaults (0, '', empty arrays) that would over-constrain results.
- * Booleans are kept when explicitly set, including false.
+ * Omits UI defaults (0, '', empty arrays, false booleans) that would over-constrain results.
  */
 export function isMeaningfulFilterValue(value: unknown): boolean {
 	if (value === undefined || value === null || value === '') {
@@ -175,12 +174,32 @@ export function isMeaningfulFilterValue(value: unknown): boolean {
 	if (typeof value === 'number' && value === 0) {
 		return false;
 	}
+	if (typeof value === 'boolean' && value === false) {
+		return false;
+	}
 	if (Array.isArray(value) && value.length === 0) {
 		return false;
 	}
 	return true;
 }
 
+/**
+ * HaloPSA silently ignores page_size/page_no unless pageinate=true (OpenAPI typo).
+ * @see swagger.json GET /Tickets parameters page_size, page_no, pageinate
+ */
+export function applyHaloPaginationRules(qs: IDataObject): IDataObject {
+	const result = { ...qs };
+	const pageSize = result.page_size;
+	const pageNo = result.page_no;
+	if (
+		(typeof pageSize === 'number' && pageSize > 0) ||
+		(typeof pageNo === 'number' && pageNo > 0)
+	) {
+		result.pageinate = true;
+	}
+	return result;
+}
+
 /** Applies common HaloPSA query-string transforms (e.g. multi-select custom fields). */
 export function applyFiltersToQueryString(filters: IDataObject): IDataObject {
 	const qs: IDataObject = {};
@@ -201,5 +220,5 @@ export function applyFiltersToQueryString(filters: IDataObject): IDataObject {
 		}
 	}
 
-	return qs;
+	return applyHaloPaginationRules(qs);
 }

nodes/HaloPSA/pagination.ts

@@ -0,0 +1,35 @@
+/** Max records per non-paginated HaloPSA list request (matches common API usage). */
+export const NON_PAGINATED_MAX_COUNT = 1000;
+
+/** HaloPSA paginated responses use page_size (max 100), not count. */
+export const PAGINATED_PAGE_SIZE = 100;
+
+/** Whether a bulk fetch should continue with paginated requests. */
+export function shouldFetchMorePages(
+	itemsLength: number,
+	recordCount: number | undefined,
+	maxCount = NON_PAGINATED_MAX_COUNT,
+): boolean {
+	if (itemsLength < maxCount) {
+		return false;
+	}
+	if (recordCount !== undefined && recordCount <= maxCount) {
+		return false;
+	}
+	return true;
+}
+
+/** First page number when continuing after a full non-paginated bulk fetch. */
+export function continuationPageNo(
+	maxCount = NON_PAGINATED_MAX_COUNT,
+	pageSize = PAGINATED_PAGE_SIZE,
+): number {
+	return Math.floor(maxCount / pageSize) + 1;
+}
+
+export function resolvePageSize(requested: unknown, maxPageSize = PAGINATED_PAGE_SIZE): number {
+	if (typeof requested === 'number' && requested > 0) {
+		return Math.min(requested, maxPageSize);
+	}
+	return maxPageSize;
+}

nodes/HaloPSA/transport.ts

@@ -10,6 +10,12 @@ import {
 	NodeApiError,
 } from 'n8n-workflow';
 import { extractResourceList, assertValidResourceListResponse, getRecordCount } from './resourceList';
+import {
+	continuationPageNo,
+	NON_PAGINATED_MAX_COUNT,
+	resolvePageSize,
+	shouldFetchMorePages,
+} from './pagination';
 import {
 	clearCachedAccessToken,
 	getCachedAccessToken,
@@ -198,12 +204,6 @@ export async function apiRequest(
 	}
 }
 
-/** Max records per non-paginated HaloPSA list request (matches common API usage). */
-const NON_PAGINATED_MAX_COUNT = 1000;
-
-/** HaloPSA paginated responses use page_size (max 100), not count. */
-const PAGINATED_PAGE_SIZE = 100;
-
 function omitManagedPaginationKeys(qs: IDataObject): IDataObject {
 	const cleaned = { ...qs };
 	delete cleaned.pageinate;
@@ -225,10 +225,7 @@ async function fetchPaginatedPages(
 	const allItems: IDataObject[] = [];
 	let page = startPage;
 	let hasMorePages = true;
-	const pageSize =
-		typeof baseQs.page_size === 'number' && baseQs.page_size > 0
-			? Math.min(baseQs.page_size as number, PAGINATED_PAGE_SIZE)
-			: PAGINATED_PAGE_SIZE;
+	const pageSize = resolvePageSize(baseQs.page_size);
 
 	while (hasMorePages) {
 		const paginatedQs: IDataObject = {
@@ -271,24 +268,19 @@ export async function apiRequestAllItems(
 	const items = extractResourceList(response, resourceKey);
 	assertValidResourceListResponse(this.getNode(), response, items, resourceKey);
 
-	if (items.length < NON_PAGINATED_MAX_COUNT) {
-		return items;
-	}
-
 	const recordCount = getRecordCount(response);
-	if (recordCount !== undefined && recordCount <= NON_PAGINATED_MAX_COUNT) {
+	if (!shouldFetchMorePages(items.length, recordCount)) {
 		return items;
 	}
 
-	const startPage = Math.floor(NON_PAGINATED_MAX_COUNT / PAGINATED_PAGE_SIZE) + 1;
 	const additionalItems = await fetchPaginatedPages(
 		this,
 		method,
 		endpoint,
 		resourceKey,
 		body,
 		baseQs,
-		startPage,
+		continuationPageNo(),
 	);
 
 	return [...items, ...additionalItems];

test/filterParameters.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import {
 	applyFiltersToQueryString,
+	applyHaloPaginationRules,
 	isMeaningfulFilterValue,
 } from '../nodes/HaloPSA/filterParameters';
 
@@ -14,23 +15,38 @@ describe('isMeaningfulFilterValue', () => {
 		assert.equal(isMeaningfulFilterValue([]), false);
 	});
 
-	it('keeps meaningful values including false booleans', () => {
-		assert.equal(isMeaningfulFilterValue(false), true);
+	it('keeps true booleans and omits false booleans', () => {
+		assert.equal(isMeaningfulFilterValue(false), false);
 		assert.equal(isMeaningfulFilterValue(true), true);
 		assert.equal(isMeaningfulFilterValue(40), true);
 		assert.equal(isMeaningfulFilterValue('search text'), true);
 		assert.equal(isMeaningfulFilterValue([1, 2]), true);
 	});
 });
 
+describe('applyHaloPaginationRules', () => {
+	it('sets pageinate when page_size or page_no is present', () => {
+		assert.deepEqual(applyHaloPaginationRules({ page_size: 50 }), {
+			page_size: 50,
+			pageinate: true,
+		});
+		assert.deepEqual(applyHaloPaginationRules({ page_no: 2 }), {
+			page_no: 2,
+			pageinate: true,
+		});
+	});
+});
+
 describe('applyFiltersToQueryString', () => {
-	it('passes open_only and requesttype_id while omitting zero defaults', () => {
+	it('passes open_only and requesttype_id while omitting zero and false defaults', () => {
 		const qs = applyFiltersToQueryString({
 			open_only: true,
 			requesttype_id: 40,
 			agent_id: 0,
 			status_id: 0,
 			search: '',
+			pageinate: false,
+			default_columns: false,
 		});
 
 		assert.deepEqual(qs, {
@@ -39,6 +55,17 @@ describe('applyFiltersToQueryString', () => {
 		});
 	});
 
+	it('forces pageinate when page_size is set in filters', () => {
+		const qs = applyFiltersToQueryString({
+			page_size: 25,
+		});
+
+		assert.deepEqual(qs, {
+			page_size: 25,
+			pageinate: true,
+		});
+	});
+
 	it('joins multi-select arrays', () => {
 		const qs = applyFiltersToQueryString({
 			requesttype: [40, 41],

test/pagination.test.ts

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+	continuationPageNo,
+	NON_PAGINATED_MAX_COUNT,
+	PAGINATED_PAGE_SIZE,
+	resolvePageSize,
+	shouldFetchMorePages,
+} from '../nodes/HaloPSA/pagination';
+
+describe('shouldFetchMorePages', () => {
+	it('stops when bulk fetch is not full', () => {
+		assert.equal(shouldFetchMorePages(50, 200), false);
+	});
+
+	it('stops when record_count fits in bulk fetch', () => {
+		assert.equal(shouldFetchMorePages(NON_PAGINATED_MAX_COUNT, 500), false);
+	});
+
+	it('continues when bulk fetch is full and more records may exist', () => {
+		assert.equal(shouldFetchMorePages(NON_PAGINATED_MAX_COUNT, 1500), true);
+		assert.equal(shouldFetchMorePages(NON_PAGINATED_MAX_COUNT, undefined), true);
+	});
+});
+
+describe('continuationPageNo', () => {
+	it('starts after the non-paginated bulk window', () => {
+		assert.equal(continuationPageNo(), 11);
+		assert.equal(continuationPageNo(1000, 100), 11);
+	});
+});
+
+describe('resolvePageSize', () => {
+	it('caps page size at HaloPSA maximum', () => {
+		assert.equal(resolvePageSize(250), PAGINATED_PAGE_SIZE);
+		assert.equal(resolvePageSize(50), 50);
+		assert.equal(resolvePageSize(undefined), PAGINATED_PAGE_SIZE);
+	});
+});

test/resourceList.test.ts

@@ -23,6 +23,15 @@ describe('extractResourceList', () => {
 		const items = extractResourceList({ faults: [{ id: 99 }] }, 'tickets');
 		assert.deepEqual(items, [{ id: 99 }]);
 	});
+
+	it('reads a bare ticket array response', () => {
+		const items = extractResourceList([{ id: 1 }, { id: 2 }], 'tickets');
+		assert.equal(items.length, 2);
+	});
+
+	it('returns empty when wrapped list key is missing', () => {
+		assert.deepEqual(extractResourceList({ record_count: 5, tickets: null }, 'tickets'), []);
+	});
 });
 
 describe('getRecordCount', () => {