chore: pipe sorting functionality to handle missing fields (RocketChat#36444)

Author: ggazzo

apps/meteor/client/lib/cachedCollections/pipe.spec.ts

@@ -16,6 +16,36 @@ describe('pipe', () => {
 		{ _id: 5, name: 'Eve', ts: 40, date: new Date('2025-07-16T05:00:00.000Z') },
 	];
 
+	describe('missing fields', () => {
+		it('should let the rows with missing fields at the end', () => {
+			const arr = [...sampleData];
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 6, name: 'A', ts: 50 } as ITestData);
+
+			const result = pipe<ITestData>().sortByField('date', 1).apply(arr);
+			expect(result).toEqual([...sampleData, { _id: 6, name: 'A', ts: 50 }]);
+		});
+		it('should sort by fallback fields if a field is missing', () => {
+			// adds randomly an row if missing date
+			const arr = [...sampleData];
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 6, name: 'A', ts: 50 } as ITestData);
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 7, name: 'B', ts: 50 } as ITestData);
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 8, name: 'C', ts: 50 } as ITestData);
+
+			const result = pipe<ITestData>().sortByField('date', 1, ['name']).apply(arr);
+			expect(result).toEqual([...sampleData, { _id: 6, name: 'A', ts: 50 }, { _id: 7, name: 'B', ts: 50 }, { _id: 8, name: 'C', ts: 50 }]);
+		});
+		it('should sort by fallback fields if a field is missing with second signature', () => {
+			// adds randomly an row if missing date
+			const arr = [...sampleData];
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 6, name: 'A', ts: 50 } as ITestData);
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 7, name: 'B', ts: 50 } as ITestData);
+			arr.splice(Math.floor(Math.random() * arr.length), 0, { _id: 8, name: 'C', ts: 50 } as ITestData);
+
+			const result = pipe<ITestData>().sortByField(['date', 'name'], 1).apply(arr);
+			expect(result).toEqual([...sampleData, { _id: 6, name: 'A', ts: 50 }, { _id: 7, name: 'B', ts: 50 }, { _id: 8, name: 'C', ts: 50 }]);
+		});
+	});
+
 	it('should correctly slice the array with skip and limit', () => {
 		const result = pipe<ITestData>().slice(1, 2).apply(sampleData);
 		expect(result).toEqual([

apps/meteor/client/lib/cachedCollections/pipe.ts

@@ -1,13 +1,15 @@
 interface IPipeReturn<D> {
 	slice(skip: number, limit: number): IPipeReturn<D>;
-	sortByField(fieldName: keyof D, direction?: 1 | -1): IPipeReturn<D>;
+	sortByField(fieldName: keyof D, direction?: 1 | -1, fallback?: Array<keyof D>): IPipeReturn<D>;
+	sortByField(fieldName: Array<keyof D>, direction?: 1 | -1, fallback?: Array<keyof D>): IPipeReturn<D>;
 	apply(): D[];
 	pipe(p: IPipeReturn<D>): IPipeReturn<D>;
 }
 
 interface IPipeReturnNoInitialData<D> {
 	slice(skip: number, limit: number): IPipeReturnNoInitialData<D>;
-	sortByField(fieldName: keyof D, direction?: 1 | -1): IPipeReturnNoInitialData<D>;
+	sortByField(fieldName: keyof D, direction?: 1 | -1, fallback?: Array<keyof D>): IPipeReturnNoInitialData<D>;
+	sortByField(fieldName: Array<keyof D>, direction?: 1 | -1): IPipeReturnNoInitialData<D>;
 	apply(arg: D[]): D[];
 	pipe(p: IPipeReturnNoInitialData<D>): IPipeReturnNoInitialData<D>;
 }
@@ -35,29 +37,46 @@ export function pipe<D>(
 			);
 		},
 
-		sortByField(fieldName: keyof D, direction: 1 | -1 = 1) {
-			return pipe<D>(
-				initialData,
-				merge(
-					(arr: D[]) =>
-						[...arr].sort((a, b) => {
-							const aValue = a[fieldName];
-							const bValue = b[fieldName];
+		sortByField(fieldName: keyof D | Array<keyof D>, direction: 1 | -1 = 1, fallback: Array<keyof D> = []) {
+			if (Array.isArray(fieldName)) {
+				return this.sortByField(fieldName[0], direction, fieldName.slice(1));
+			}
+
+			const sort = (fieldName: keyof D, direction: 1 | -1, fallback: Array<keyof D>) => {
+				return (a: D, b: D): number => {
+					const aValue = a[fieldName];
+					const bValue = b[fieldName];
+
+					if (aValue === undefined && bValue === undefined && fallback.length > 0) {
+						const [field, ...rest] = fallback;
+						return sort(field, direction, rest)(a, b);
+					}
+
+					if (aValue === undefined) {
+						return 1;
+					}
 
-							if (aValue instanceof Date && bValue instanceof Date) {
-								return direction * (aValue.getTime() - bValue.getTime());
-							}
+					if (bValue === undefined) {
+						return -1;
+					}
 
-							if (typeof aValue === 'string' && typeof bValue === 'string') {
-								return direction * aValue.localeCompare(bValue);
-							}
-							if (typeof aValue === 'number' && typeof bValue === 'number') {
-								return direction * (aValue - bValue);
-							}
-							return 0;
-						}),
-					acc,
-				),
+					if (aValue instanceof Date && bValue instanceof Date) {
+						return direction * (aValue.getTime() - bValue.getTime());
+					}
+
+					if (typeof aValue === 'string' && typeof bValue === 'string') {
+						return direction * aValue.localeCompare(bValue);
+					}
+					if (typeof aValue === 'number' && typeof bValue === 'number') {
+						return direction * (aValue - bValue);
+					}
+					return 0;
+				};
+			};
+
+			return pipe<D>(
+				initialData,
+				merge((arr: D[]) => [...arr].sort(sort(fieldName, direction, fallback)), acc),
 			);
 		},