@objectql/driver-excel 4.0.1 → 4.0.3

package/test/index.test.ts

@@ -233,7 +233,7 @@ describe('ExcelDriver', () => {
 
         it('should filter records with equality operator', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                filters: [['role', '=', 'user']]
+                where: { role: { $eq: 'user' } }
             });
             expect(results.length).toBe(2);
             expect(results.every(r => r.role === 'user')).toBe(true);
@@ -241,7 +241,7 @@ describe('ExcelDriver', () => {
 
         it('should filter records with greater than operator', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                filters: [['age', '>', 25]]
+                where: { age: { $gt: 25 } }
             });
             expect(results.length).toBe(2);
             expect(results.every(r => r.age > 25)).toBe(true);
@@ -249,25 +249,26 @@ describe('ExcelDriver', () => {
 
         it('should filter records with contains operator', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                filters: [['name', 'contains', 'li']]
+                where: { name: { $regex: 'li' } }
             });
             expect(results.length).toBe(2); // Alice and Charlie
         });
 
         it('should support OR filters', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                filters: [
-                    ['name', '=', 'Alice'],
-                    'or',
-                    ['name', '=', 'Bob']
-                ]
+                where: {
+                    $or: [
+                        { name: { $eq: 'Alice' } },
+                        { name: { $eq: 'Bob' } }
+                    ]
+                }
             });
             expect(results.length).toBe(2);
         });
 
         it('should sort records ascending', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                sort: [['age', 'asc']]
+                orderBy: [{ field: 'age', order: 'asc' }]
             });
             expect(results[0].age).toBe(25);
             expect(results[1].age).toBe(30);
@@ -276,7 +277,7 @@ describe('ExcelDriver', () => {
 
         it('should sort records descending', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                sort: [['age', 'desc']]
+                orderBy: [{ field: 'age', order: 'desc' }]
             });
             expect(results[0].age).toBe(35);
             expect(results[1].age).toBe(30);
@@ -292,7 +293,7 @@ describe('ExcelDriver', () => {
 
         it('should support pagination with skip', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                skip: 1,
+                offset: 1,
                 limit: 2
             });
             expect(results.length).toBe(2);
@@ -315,7 +316,7 @@ describe('ExcelDriver', () => {
 
         it('should count filtered records', async () => {
             const count = await driver.count(TEST_OBJECT, {
-                filters: [['role', '=', 'user']]
+                where: { role: { $eq: 'user' } }
             });
             expect(count).toBe(2);
         });
@@ -354,7 +355,7 @@ describe('ExcelDriver', () => {
             expect(result.modifiedCount).toBe(2);
             
             const users = await driver.find(TEST_OBJECT, {
-                filters: [['role', '=', 'member']]
+                where: { role: { $eq: 'member' } }
             });
             expect(users).toHaveLength(2);
         });
@@ -465,7 +466,7 @@ describe('ExcelDriver', () => {
 
         it('should handle filters on empty data', async () => {
             const results = await driver.find(TEST_OBJECT, {
-                filters: [['name', '=', 'Alice']]
+                where: { name: { $eq: 'Alice' } }
             });
             expect(results).toEqual([]);
         });
@@ -582,15 +583,12 @@ describe('ExcelDriver', () => {
                 const result = await driver.executeQuery({
                     object: TEST_OBJECT,
                     fields: ['name', 'age'],
-                    filters: {
-                        type: 'comparison',
-                        field: 'age',
-                        operator: '>',
-                        value: 25
+                    where: {
+                        age: { $gt: 25 }
                     },
-                    sort: [{ field: 'age', order: 'asc' }],
-                    top: 10,
-                    skip: 0
+                    orderBy: [{ field: 'age', order: 'asc' }],
+                    limit: 10,
+                    offset: 0
                 });
 
                 expect(result.value).toHaveLength(2);
@@ -606,11 +604,10 @@ describe('ExcelDriver', () => {
 
                 const result = await driver.executeQuery({
                     object: TEST_OBJECT,
-                    filters: {
-                        type: 'and',
-                        children: [
-                            { type: 'comparison', field: 'age', operator: '>', value: 25 },
-                            { type: 'comparison', field: 'city', operator: '=', value: 'NYC' }
+                    where: {
+                        $and: [
+                            { age: { $gt: 25 } },
+                            { city: { $eq: 'NYC' } }
                         ]
                     }
                 });
@@ -626,9 +623,9 @@ describe('ExcelDriver', () => {
 
                 const result = await driver.executeQuery({
                     object: TEST_OBJECT,
-                    sort: [{ field: 'name', order: 'asc' }],
-                    skip: 1,
-                    top: 1
+                    orderBy: [{ field: 'name', order: 'asc' }],
+                    offset: 1,
+                    limit: 1
                 });
 
                 expect(result.value).toHaveLength(1);
@@ -747,4 +744,59 @@ describe('ExcelDriver', () => {
             });
         });
     });
+    
+    describe('Aggregation Operations', () => {
+        beforeEach(async () => {
+            // Create sample data for aggregation tests
+            await driver.create('orders', { id: '1', customer: 'Alice', product: 'Phone', amount: 500, quantity: 2, status: 'completed' });
+            await driver.create('orders', { id: '2', customer: 'Bob', product: 'Tablet', amount: 300, quantity: 1, status: 'pending' });
+            await driver.create('orders', { id: '3', customer: 'Alice', product: 'Laptop', amount: 700, quantity: 1, status: 'completed' });
+            await driver.create('orders', { id: '4', customer: 'Charlie', product: 'Monitor', amount: 250, quantity: 2, status: 'completed' });
+            await driver.create('orders', { id: '5', customer: 'Bob', product: 'Keyboard', amount: 100, quantity: 1, status: 'cancelled' });
+        });
+
+        test('should aggregate with $match stage', async () => {
+            const results = await driver.aggregate('orders', [
+                { $match: { status: 'completed' } }
+            ]);
+
+            expect(results).toBeDefined();
+            expect(results.length).toBe(3);
+            expect(results.every((r: any) => r.status === 'completed')).toBe(true);
+        });
+
+        test('should aggregate with $group and $sum', async () => {
+            const results = await driver.aggregate('orders', [
+                { $match: { status: 'completed' } },
+                { 
+                    $group: { 
+                        _id: '$customer', 
+                        totalAmount: { $sum: '$amount' } 
+                    } 
+                }
+            ]);
+
+            expect(results).toBeDefined();
+            expect(results.length).toBeGreaterThan(0);
+            
+            const alice = results.find((r: any) => r._id === 'Alice');
+            expect(alice).toBeDefined();
+            expect(alice.totalAmount).toBe(1200);
+        });
+
+        test('should aggregate with $group and $avg', async () => {
+            const results = await driver.aggregate('orders', [
+                { 
+                    $group: { 
+                        _id: null, 
+                        avgAmount: { $avg: '$amount' } 
+                    } 
+                }
+            ]);
+
+            expect(results).toBeDefined();
+            expect(results.length).toBe(1);
+            expect(results[0].avgAmount).toBeCloseTo(370, 0);
+        });
+    });
 });