[Due for payment 2026-02-04] [$250] [Insights] [Release 1] Top Categories - Add a limit filter to search

[neil-marcellini]

Add a limit parameter to the search query language to limit results shown in the insights we display.

1. Add limit to parser grammar - src/libs/SearchParser/baseRules.peggy - Add limit rule similar to sortBy/sortOrder
2. Generate the JS code by running these scripts
3. Add limit to parser default values - src/libs/SearchParser/searchParser.peggy, defaultKey rule - because it’s a root level parameter; it controls query execution, not data filtering.
4. Add limit to constants - src/CONST/index.ts - Add LIMIT: 'limit' to CONST.SEARCH.SYNTAX_ROOT_KEYS
5. Add limit to type definitions - src/components/Search/types.ts - Add limit?: number to SearchQueryAST type
6. Update query building functions - src/libs/SearchQueryUtils.ts - Add limit?: number to BuildQueryStringOptions type and include limit in query string building logic
7. Update the autocomplete parser and filterOutRangesWithCorrectValue so that it properly highlights the limit in the user input

Issue Owner

Current Issue Owner: @trjExpensify

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @rojiphil (External)

[melvin-bot]

Triggered auto assignment to @brianlee-expensify (NewFeature), see https://stackoverflowteams.com/c/expensify/questions/14418#:~:text=BugZero%20process%20steps%20for%20feature%20requests for more details. Please add this Feature request to a GH project, as outlined in the SO. Remember to draft any necessary HelpDot updates by following the instructions here.

[melvin-bot]

Triggered auto assignment to Design team member for new feature review - @dubielzyk-expensify (NewFeature)

[TaduJR]

🚨 Edited by proposal-police: This proposal was edited at 2026-01-20 21:56:59 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

The Insights feature needs to limit the quantity of results displayed in top categories views, but the search query language currently lacks a limit parameter to constrain results.

What is the root cause of that problem?

The search parser grammar does not define a limit rule, and the search query AST type does not include a limit field. The parser only recognizes these root-level keys: type, status, sortBy, sortOrder, groupBy, and columns.

Root cause flow:

1. baseRules.peggy defines keyword rules for recognized search keys like sortBy and sortOrder
   

   App/src/libs/SearchParser/baseRules.peggy

   Lines 56 to 61 in 72b7b46

   	sortBy
   	= "sortBy"
   	/ "sort-by"i { return "sortBy"; }
   	sortOrder
   	= "sortOrder"
   	/ "sort-order"i { return "sortOrder"; }

2. searchParser.peggy defines defaultKey which lists all root-level parameters and nonNegatableKeys for keys that cannot be prefixed with -
   

   App/src/libs/SearchParser/searchParser.peggy

   Lines 55 to 57 in 72b7b46

   	const nonNegatableKeys = new Set([
   	"type", "keyword", "groupCurrency", "groupBy", "columns"
   	]);

   
   

   App/src/libs/SearchParser/searchParser.peggy

   Line 263 in 72b7b46

   defaultKey "default key" = @(type / status / sortBy / sortOrder / policyID / groupBy / columns)

3. CONST.SEARCH.SYNTAX_ROOT_KEYS defines the constants for root keys
   

   App/src/CONST/index.ts

   Lines 7026 to 7033 in 72b7b46

   	SYNTAX_ROOT_KEYS: {
   	TYPE: 'type',
   	STATUS: 'status',
   	SORT_BY: 'sortBy',
   	SORT_ORDER: 'sortOrder',
   	GROUP_BY: 'groupBy',
   	COLUMNS: 'columns',
   	},

4. SearchQueryAST type defines the shape of parsed queries
   

   App/src/components/Search/types.ts

   Lines 236 to 246 in 72b7b46

   	type SearchQueryAST = {
   	type: SearchDataTypes;
   	status: SearchStatus;
   	sortBy: SearchColumnType;
   	sortOrder: SortOrder;
   	groupBy?: SearchGroupBy;
   	filters: ASTNode;
   	policyID?: string[];
   	rawFilterList?: RawQueryFilter[];
   	columns?: SearchCustomColumnIds | SearchCustomColumnIds[];
   	};

5. getQueryHashes computes hashes including root keys for caching
   

   App/src/libs/SearchQueryUtils.ts

   Lines 375 to 377 in 72b7b46

   	orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY}:${query.sortBy}`;
   	orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER}:${query.sortOrder}`;
   	orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.COLUMNS}:${Array.isArray(query.columns) ? query.columns.join(',') : query.columns}`;

6. formatDefaultRawFilterSegment skips sortBy and sortOrder from user-readable output
   

   App/src/libs/SearchQueryUtils.ts

   Lines 1157 to 1159 in 72b7b46

   	if (rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY || rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER) {
   	return;
   	}

7. filterOutRangesWithCorrectValue validates filter values for syntax highlighting
   

   App/src/libs/SearchAutocompleteUtils.ts

   Lines 147 to 243 in 72b7b46

   	function filterOutRangesWithCorrectValue(
   	range: SearchAutocompleteQueryRange,
   	substitutionMap: SubstitutionMap,
   	userLogins: SharedValue<string[]>,
   	currencyList: SharedValue<string[]>,
   	categoryList: SharedValue<string[]>,
   	tagList: SharedValue<string[]>,
   	currentType: string,
   	) {
   	'worklet';
   	const typeList = Object.values(CONST.SEARCH.DATA_TYPES) as string[];
   	const expenseTypeList = userFriendlyExpenseTypeList;
   	const withdrawalTypeList = Object.values(CONST.SEARCH.WITHDRAWAL_TYPE) as string[];
   	const statusList = userFriendlyStatusList;
   	const groupByList = userFriendlyGroupByList;
   	const booleanList = Object.values(CONST.SEARCH.BOOLEAN) as string[];
   	const actionList = Object.values(CONST.SEARCH.ACTION_FILTERS) as string[];
   	const datePresetList = Object.values(CONST.SEARCH.DATE_PRESETS) as string[];
   	const hasList = Object.values(CONST.SEARCH.HAS_VALUES) as string[];
   	const isList = Object.values(CONST.SEARCH.IS_VALUES) as string[];
   	if (range.key.startsWith(CONST.SEARCH.REPORT_FIELD.GLOBAL_PREFIX)) {
   	return range.value.length > 0;
   	}
   	switch (range.key) {
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.IN:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.TAX_RATE:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.FEED:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.CARD_ID:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.POLICY_ID:
   	return substitutionMap[`${range.key}:${range.value}`] !== undefined;
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.TO:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.FROM:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.ASSIGNEE:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.PAYER:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.EXPORTER:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.ATTENDEE:
   	return substitutionMap[`${range.key}:${range.value}`] !== undefined || userLogins.get().includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.CURRENCY:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.GROUP_CURRENCY:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.PURCHASE_CURRENCY:
   	return currencyList.get().includes(range.value);
   	case CONST.SEARCH.SYNTAX_ROOT_KEYS.TYPE:
   	return typeList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.EXPENSE_TYPE:
   	return expenseTypeList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.WITHDRAWAL_TYPE:
   	return withdrawalTypeList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_ROOT_KEYS.STATUS:
   	return statusList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.ACTION:
   	return actionList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.CATEGORY:
   	return categoryList.get().includes(range.value) || range.value === CONST.SEARCH.CATEGORY_EMPTY_VALUE;
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.TAG:
   	return tagList.get().includes(range.value);
   	case CONST.SEARCH.SYNTAX_ROOT_KEYS.GROUP_BY:
   	if (currentType !== CONST.SEARCH.DATA_TYPES.EXPENSE && currentType !== CONST.SEARCH.DATA_TYPES.INVOICE && currentType !== CONST.SEARCH.DATA_TYPES.TRIP) {
   	return false;
   	}
   	return groupByList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.BILLABLE:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.REIMBURSABLE:
   	return booleanList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.DATE:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.SUBMITTED:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.APPROVED:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.PAID:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.EXPORTED:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.WITHDRAWN:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.POSTED:
   	return datePresetList.includes(range.value) || /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.HAS:
   	return hasList.includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.MERCHANT:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.DESCRIPTION:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.TITLE:
   	return range.value.length > 0;
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.WITHDRAWAL_ID:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.REPORT_ID:
   	return !['', 'null', 'undefined', '0', '-1'].includes(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.TOTAL:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.PURCHASE_AMOUNT:
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.AMOUNT:
   	// This uses the same regex as the AmountWithoutCurrencyInput component (allowing for 3 digit decimals as some currencies support that)
   	return /^-?(?!.*[.,].*[.,])\d{0,8}(?:[.,]\d{0,2})?$/.test(range.value);
   	case CONST.SEARCH.SYNTAX_ROOT_KEYS.COLUMNS:
   	return userFriendlyColumnList.has(range.value);
   	case CONST.SEARCH.SYNTAX_FILTER_KEYS.IS:
   	return isList.includes(range.value);
   	default:
   	return false;
   	}
   	}

8. getUserFriendlyKey function signature explicitly includes SORT_BY and SORT_ORDER types
   

   App/src/libs/SearchQueryUtils.ts

   Line 96 in 72b7b46

   function getUserFriendlyKey(keyName: SearchFilterKey | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER): UserFriendlyKey {

Since limit is not defined in any of these locations, the parser cannot recognize limit:10 as a valid query parameter.

What changes do you think we should make in order to solve the problem?

1. Add limit rule to baseRules.peggy:

App/src/libs/SearchParser/baseRules.peggy

Lines 59 to 61 in 72b7b46

	sortOrder
	= "sortOrder"
	/ "sort-order"i { return "sortOrder"; }

 sortOrder
   = "sortOrder"
   / "sort-order"i { return "sortOrder"; }
+limit = "limit"i { return "limit"; }

2. Update searchParser.peggy - add limit to nonNegatableKeys:

App/src/libs/SearchParser/searchParser.peggy

Lines 55 to 57 in 72b7b46

	const nonNegatableKeys = new Set([
	"type", "keyword", "groupCurrency", "groupBy", "columns"
	]);

   const nonNegatableKeys = new Set([
-    "type", "keyword", "groupCurrency", "groupBy", "columns"
+    "type", "keyword", "groupCurrency", "groupBy", "columns", "limit"
   ]);

3. Update searchParser.peggy - add limit to defaultKey rule:

App/src/libs/SearchParser/searchParser.peggy

Line 263 in 72b7b46

defaultKey "default key" = @(type / status / sortBy / sortOrder / policyID / groupBy / columns)

-defaultKey "default key" = @(type / status / sortBy / sortOrder / policyID / groupBy / columns)
+defaultKey "default key" = @(type / status / sortBy / sortOrder / policyID / groupBy / columns / limit)

4. Update searchParser.peggy - add type coercion for limit in updateDefaultValues:

App/src/libs/SearchParser/searchParser.peggy

Lines 79 to 108 in 72b7b46

	function updateDefaultValues(field, value) {
	if (field === "status" && value === "all") {
	defaultValues[field] = "";
	return;
	}
	// Track if user explicitly provided a custom (non-default) sortBy
	if (field === "sortBy" && !isDefaultSortValue(value)) {
	userProvidedSortBy = true;
	}
	// Auto-update sortBy and sortOrder when groupBy changes
	// Only reset sortOrder if sortBy actually changes (to avoid resetting on every parse)
	if (field === "groupBy" && value) {
	if (!userProvidedSortBy) {
	const defaultSortBy = getDefaultSortByForGroupBy(value);
	// Check if sortBy is actually changing
	if (defaultSortBy && defaultValues.sortBy !== defaultSortBy) {
	defaultValues.sortBy = defaultSortBy;
	// When sortBy changes, reset the sortOrder flag and apply new default
	const defaultSortOrder = getDefaultSortOrderForGroupBy(value);
	if (defaultSortOrder) {
	defaultValues.sortOrder = defaultSortOrder;
	}
	}
	}
	}
	defaultValues[field] = value;
	}

   function updateDefaultValues(field, value) {
     if (field === "status" && value === "all") {
       defaultValues[field] = "";
       return;
     }

+    // Convert limit to number
+    if (field === "limit") {
+      const parsed = parseInt(value, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        defaultValues[field] = parsed;
+      }
+      return;
+    }
+
     // Track if user explicitly provided a custom (non-default) sortBy
     if (field === "sortBy" && !isDefaultSortValue(value)) {

5. Update autocompleteParser.peggy - add limit to nonNegatableKeys:

App/src/libs/SearchParser/autocompleteParser.peggy

Lines 25 to 27 in 72b7b46

	const nonNegatableKeys = new Set([
	"type", "keyword", "groupCurrency", "groupBy", "columns"
	]);

   const nonNegatableKeys = new Set([
-    "type", "keyword", "groupCurrency", "groupBy", "columns"
+    "type", "keyword", "groupCurrency", "groupBy", "columns", "limit"
   ]);

6. Update autocompleteParser.peggy - add limit to autocompleteKey:

App/src/libs/SearchParser/autocompleteParser.peggy

Lines 76 to 122 in 72b7b46

	autocompleteKey "key"
	= @(
	in
	/ currency
	/ groupCurrency
	/ total
	/ tag
	/ category
	/ to
	/ taxRate
	/ from
	/ attendee
	/ payer
	/ exporter
	/ createdBy
	/ assignee
	/ expenseType
	/ withdrawalType
	/ type
	/ status
	/ cardID
	/ feed
	/ groupBy
	/ reimbursable
	/ billable
	/ policyID
	/ action
	/ date
	/ submitted
	/ approved
	/ paid
	/ exported
	/ withdrawn
	/ posted
	/ has
	/ is
	/ purchaseCurrency
	/ purchaseAmount
	/ amount
	/ merchant
	/ description
	/ reportID
	/ withdrawalID
	/ title
	/ reportFieldDynamic
	/ columns
	)

 autocompleteKey "key"
   = @(
       ...
       / columns
+      / limit
     )

7. Add LIMIT to CONST.SEARCH.SYNTAX_ROOT_KEYS:

App/src/CONST/index.ts

Lines 7026 to 7033 in 72b7b46

	SYNTAX_ROOT_KEYS: {
	TYPE: 'type',
	STATUS: 'status',
	SORT_BY: 'sortBy',
	SORT_ORDER: 'sortOrder',
	GROUP_BY: 'groupBy',
	COLUMNS: 'columns',
	},

 SYNTAX_ROOT_KEYS: {
     TYPE: 'type',
     STATUS: 'status',
     SORT_BY: 'sortBy',
     SORT_ORDER: 'sortOrder',
     GROUP_BY: 'groupBy',
     COLUMNS: 'columns',
+    LIMIT: 'limit',
 },

8. Add LIMIT to CONST.SEARCH.SEARCH_USER_FRIENDLY_KEYS:

App/src/CONST/index.ts

Lines 7095 to 7100 in 72b7b46

	SEARCH_USER_FRIENDLY_KEYS: {
	TYPE: 'type',
	STATUS: 'status',
	SORT_BY: 'sort-by',
	SORT_ORDER: 'sort-order',
	POLICY_ID: 'workspace',

 SEARCH_USER_FRIENDLY_KEYS: {
     TYPE: 'type',
     STATUS: 'status',
     SORT_BY: 'sort-by',
     SORT_ORDER: 'sort-order',
+    LIMIT: 'limit',
     POLICY_ID: 'workspace',
     ...
 },

9. Add limit to SearchQueryAST type:

App/src/components/Search/types.ts

Lines 236 to 246 in 72b7b46

	type SearchQueryAST = {
	type: SearchDataTypes;
	status: SearchStatus;
	sortBy: SearchColumnType;
	sortOrder: SortOrder;
	groupBy?: SearchGroupBy;
	filters: ASTNode;
	policyID?: string[];
	rawFilterList?: RawQueryFilter[];
	columns?: SearchCustomColumnIds | SearchCustomColumnIds[];
	};

 type SearchQueryAST = {
     type: SearchDataTypes;
     status: SearchStatus;
     sortBy: SearchColumnType;
     sortOrder: SortOrder;
     groupBy?: SearchGroupBy;
     filters: ASTNode;
     policyID?: string[];
     rawFilterList?: RawQueryFilter[];
     columns?: SearchCustomColumnIds | SearchCustomColumnIds[];
+    limit?: number;
 };

10. Update getUserFriendlyKey function signature to include LIMIT:

App/src/libs/SearchQueryUtils.ts

Line 96 in 72b7b46

function getUserFriendlyKey(keyName: SearchFilterKey | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER): UserFriendlyKey {

-function getUserFriendlyKey(keyName: SearchFilterKey | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER): UserFriendlyKey {
+function getUserFriendlyKey(keyName: SearchFilterKey | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER | typeof CONST.SEARCH.SYNTAX_ROOT_KEYS.LIMIT): UserFriendlyKey {

11. Update getQueryHashes in SearchQueryUtils.ts to include limit in hash:

App/src/libs/SearchQueryUtils.ts

Lines 375 to 377 in 72b7b46

	orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY}:${query.sortBy}`;
	orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER}:${query.sortOrder}`;
	orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.COLUMNS}:${Array.isArray(query.columns) ? query.columns.join(',') : query.columns}`;

     orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY}:${query.sortBy}`;
     orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER}:${query.sortOrder}`;
     orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.COLUMNS}:${Array.isArray(query.columns) ? query.columns.join(',') : query.columns}`;
+    if (query.limit !== undefined) {
+        orderedQuery += ` ${CONST.SEARCH.SYNTAX_ROOT_KEYS.LIMIT}:${query.limit}`;
+    }

12. Update formatDefaultRawFilterSegment to skip limit from user-readable output:

App/src/libs/SearchQueryUtils.ts

Lines 1157 to 1159 in 72b7b46

	if (rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY || rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER) {
	return;
	}

-    if (rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY || rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER) {
+    if (rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_BY || rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.SORT_ORDER || rawFilter.key === CONST.SEARCH.SYNTAX_ROOT_KEYS.LIMIT) {
         return;
     }

13. Update filterOutRangesWithCorrectValue in SearchAutocompleteUtils.ts for limit validation:

App/src/libs/SearchAutocompleteUtils.ts

Lines 236 to 240 in 72b7b46

	case CONST.SEARCH.SYNTAX_ROOT_KEYS.COLUMNS:
	return userFriendlyColumnList.has(range.value);
	case CONST.SEARCH.SYNTAX_FILTER_KEYS.IS:
	return isList.includes(range.value);
	default:

Add case in switch statement before default:

         case CONST.SEARCH.SYNTAX_ROOT_KEYS.COLUMNS:
             return userFriendlyColumnList.has(range.value);
         case CONST.SEARCH.SYNTAX_FILTER_KEYS.IS:
             return isList.includes(range.value);
+        case CONST.SEARCH.SYNTAX_ROOT_KEYS.LIMIT:
+            return /^\d+$/.test(range.value) && parseInt(range.value, 10) > 0;
         default:
             return false;

14. Run parser generation scripts:

npm run generate-search-parser
npm run generate-autocomplete-parser

15. Add tests in tests/unit/SearchParserTest.ts:

{
    query: 'type:expense limit:50',
    expected: {
        type: 'expense',
        status: CONST.SEARCH.STATUS.EXPENSE.ALL,
        sortBy: 'date',
        sortOrder: 'desc',
        limit: 50,
        filters: null,
    },
},
{
    query: 'type:expense limit:invalid',
    expected: {
        type: 'expense',
        status: CONST.SEARCH.STATUS.EXPENSE.ALL,
        sortBy: 'date',
        sortOrder: 'desc',
        // limit should be undefined for invalid values
        filters: null,
    },
},

16. Add tests in tests/unit/Search/SearchQueryUtilsTest.ts:

test('should include limit in built query string', () => {
    const queryJSON = buildSearchQueryJSON('type:expense limit:100');
    expect(queryJSON?.limit).toBe(100);

    const result = buildSearchQueryString(queryJSON);
    expect(result).toContain('limit:100');
});

test('should compute different hashes for different limits', () => {
    const queryJSONa = buildSearchQueryJSON('type:expense limit:50');
    const queryJSONb = buildSearchQueryJSON('type:expense limit:100');

    expect(queryJSONa?.hash).not.toBe(queryJSONb?.hash);
});