snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

packages/mongo-adapter/src/sort.spec.ts

@@ -0,0 +1,210 @@
+import { createComparatorFromSort } from './sort';
+
+describe('createComparatorFromSort', () => {
+	describe('object specification format', () => {
+		it('should sort by a single field ascending', () => {
+			const sorter = createComparatorFromSort({ name: 1 });
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBeLessThan(0);
+			expect(sorter(b, a)).toBeGreaterThan(0);
+			expect(sorter(a, a)).toBe(0);
+		});
+
+		it('should sort by a single field descending', () => {
+			const sorter = createComparatorFromSort({ name: -1 });
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBeGreaterThan(0);
+			expect(sorter(b, a)).toBeLessThan(0);
+			expect(sorter(a, a)).toBe(0);
+		});
+
+		it('should handle multiple fields with different directions', () => {
+			const sorter = createComparatorFromSort({ age: 1, name: -1 });
+
+			const a = { age: 30, name: 'Alice' };
+			const b = { age: 30, name: 'Bob' };
+			const c = { age: 25, name: 'Charlie' };
+
+			expect(sorter(a, b)).toBeGreaterThan(0); // Same age, name is used (desc)
+			expect(sorter(a, c)).toBeGreaterThan(0); // Different age
+			expect(sorter(c, b)).toBeLessThan(0); // Different age
+		});
+
+		it('should handle when the first field has equal values', () => {
+			const sorter = createComparatorFromSort({ age: 1, name: 1 });
+
+			const a = { age: 30, name: 'Alice' };
+			const b = { age: 30, name: 'Bob' };
+
+			expect(sorter(a, b)).toBeLessThan(0); // Same age, name is used (asc)
+		});
+
+		it('should handle missing fields', () => {
+			const sorter = createComparatorFromSort({ age: 1 });
+
+			const a = { age: 30 };
+			const b = {}; // Missing age
+
+			expect(sorter(a, b)).toBeGreaterThan(0); // undefined is considered smaller
+			expect(sorter(b, a)).toBeLessThan(0);
+		});
+
+		it('should sort numbers correctly', () => {
+			const sorter = createComparatorFromSort({ score: 1 });
+
+			const a = { score: 100 };
+			const b = { score: 50 };
+
+			expect(sorter(a, b)).toBeGreaterThan(0);
+			expect(sorter(b, a)).toBeLessThan(0);
+		});
+
+		it('should handle nested fields', () => {
+			const sorter = createComparatorFromSort({ 'user.age': 1 });
+
+			const a = { user: { age: 30 } };
+			const b = { user: { age: 25 } };
+
+			expect(sorter(a, b)).toBeGreaterThan(0);
+			expect(sorter(b, a)).toBeLessThan(0);
+		});
+	});
+
+	describe('array specification format', () => {
+		it('should sort using string array format', () => {
+			const sorter = createComparatorFromSort(['name']);
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBeLessThan(0);
+			expect(sorter(b, a)).toBeGreaterThan(0);
+		});
+
+		it('should sort using field and direction array format', () => {
+			const sorter = createComparatorFromSort([['name', 'desc']]);
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBeGreaterThan(0);
+			expect(sorter(b, a)).toBeLessThan(0);
+		});
+
+		it('should handle mix of string and array formats', () => {
+			// @ts-expect-error - mixing string and array formats is allowed
+			const sorter = createComparatorFromSort(['age', ['name', 'desc']]);
+
+			const a = { age: 30, name: 'Alice' };
+			const b = { age: 30, name: 'Bob' };
+
+			expect(sorter(a, b)).toBeGreaterThan(0);
+		});
+
+		it('should handle ascending in array format', () => {
+			const sorter = createComparatorFromSort([['name', 'asc']]);
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBeLessThan(0);
+		});
+	});
+
+	describe('array values handling', () => {
+		it('should handle array values by selecting min value for ascending', () => {
+			const sorter = createComparatorFromSort({ scores: 1 });
+
+			const a = { scores: [10, 20, 30] };
+			const b = { scores: [5, 15, 25] };
+
+			expect(sorter(a, b)).toBe(5);
+		});
+
+		it('should handle array values by selecting max value for descending', () => {
+			const sorter = createComparatorFromSort({ scores: -1 });
+
+			const a = { scores: [10, 20, 30] };
+			const b = { scores: [5, 15, 25] };
+
+			expect(sorter(a, b)).toBe(-5);
+		});
+
+		it('should handle empty arrays', () => {
+			const sorter = createComparatorFromSort({ scores: 1 });
+
+			const a = { scores: [] };
+			const b = { scores: [5] };
+
+			expect(sorter(a, b)).toBeLessThan(0); // undefined vs 5
+		});
+
+		it('should handle nested arrays', () => {
+			const sorter = createComparatorFromSort({ 'users.scores': 1 });
+
+			const a = { users: [{ scores: [10, 5] }, { scores: [20, 15] }] };
+			const b = { users: [{ scores: [8, 3] }, { scores: [18, 13] }] };
+
+			expect(sorter(a, b)).toBeGreaterThan(0); // Should compare minimums
+		});
+	});
+
+	describe('edge cases', () => {
+		it('should handle empty sort specification', () => {
+			const sorter = createComparatorFromSort({});
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBe(0); // No sort criteria so all docs equal
+		});
+
+		it('should handle empty array sort specification', () => {
+			const sorter = createComparatorFromSort([]);
+
+			const a = { name: 'Alice' };
+			const b = { name: 'Bob' };
+
+			expect(sorter(a, b)).toBe(0); // No sort criteria so all docs equal
+		});
+
+		it('should sort by multiple fields when first fields are equal', () => {
+			const sorter = createComparatorFromSort({ lastName: 1, firstName: 1 });
+
+			const a = { lastName: 'Smith', firstName: 'Alice' };
+			const b = { lastName: 'Smith', firstName: 'Bob' };
+			const c = { lastName: 'Jones', firstName: 'Charlie' };
+
+			expect(sorter(a, b)).toBeLessThan(0); // Same last name, different first name
+			expect(sorter(a, c)).toBeGreaterThan(0); // Different last names
+		});
+
+		it('should handle objects and scalars in the same comparison', () => {
+			const sorter = createComparatorFromSort({ data: 1 });
+
+			const a = { data: { value: 10 } };
+			const b = { data: 5 };
+
+			// This tests that the BSON comparison works correctly for different types
+			expect(typeof sorter(a, b)).toBe('number'); // Should return a number without error
+		});
+
+		it('should handle null and undefined values', () => {
+			const sorter = createComparatorFromSort({ value: 1 });
+
+			const a = { value: null };
+			const b = {};
+			const c = { value: 0 };
+
+			expect(sorter(a, c)).toBeLessThan(0); // null is less than 0
+			expect(sorter(b, c)).toBeLessThan(0); // undefined is less than 0
+			expect(sorter(a, b)).toBeGreaterThan(0); // undefined is less than null
+		});
+	});
+});