@objectql/driver-mongo 4.0.1 → 4.0.3

package/test/index.test.ts

@@ -62,23 +62,16 @@ describe('MongoDriver', () => {
 
     it('should find objects with query', async () => {
         const query = {
-            filters: [['age', '>', 18]],
-            sort: [['name', 'asc']],
-            skip: 10,
+            where: { age: { $gt: 18 } },
+            orderBy: [{ field: 'name', order: 'asc' as const }],
+            offset: 10,
             limit: 5
         };
         
         await driver.find('users', query);
         
-        // Debugging what was actually called
-        // console.log('Find calls:', mockCollection.find.mock.calls);
-
         expect(mockDb.collection).toHaveBeenCalledWith('users');
         
-        // We expect: find(filter, options)
-        // filter = { $and: [{ age: { $gt: 18 } }] }
-        // options = { limit: 5, skip: 10, sort: { name: 1 } }
-        
         expect(mockCollection.find).toHaveBeenCalledWith(
             { age: { $gt: 18 } },
             expect.objectContaining({ 
@@ -92,7 +85,12 @@ describe('MongoDriver', () => {
 
     it('should handle OR filters', async () => {
         const query = {
-            filters: [['age', '>', 18], 'or', ['role', '=', 'admin']]
+            where: {
+                $or: [
+                    { age: { $gt: 18 } },
+                    { role: 'admin' }
+                ]
+            }
         };
         await driver.find('users', query);
         
@@ -109,7 +107,7 @@ describe('MongoDriver', () => {
 
     it('should map "id" field to "_id" in filters', async () => {
         const query = {
-            filters: [['id', '=', '12345']]
+            where: { id: '12345' }
         };
         await driver.find('users', query);
         
@@ -121,7 +119,7 @@ describe('MongoDriver', () => {
 
     it('should map "id" to "_id" in sorting', async () => {
         const query = {
-            sort: [['id', 'desc']]
+            orderBy: [{ field: 'id', order: 'desc' as const }]
         };
         await driver.find('users', query);
         
@@ -192,7 +190,7 @@ describe('MongoDriver', () => {
     // Backward compatibility tests for legacy '_id' usage
     it('should accept "_id" field in filters for backward compatibility', async () => {
         const query = {
-            filters: [['_id', '=', '12345']]
+            where: { _id: '12345' }
         };
         await driver.find('users', query);
         
@@ -204,7 +202,7 @@ describe('MongoDriver', () => {
 
     it('should accept "_id" in sorting for backward compatibility', async () => {
         const query = {
-            sort: [['_id', 'asc']]
+            orderBy: [{ field: '_id', order: 'asc' as const }]
         };
         await driver.find('users', query);
         
@@ -237,19 +235,22 @@ describe('MongoDriver', () => {
 
     it('should handle nested filter groups', async () => {
         const query = {
-            filters: [
-                [
-                    ['status', '=', 'completed'],
-                    'and',
-                    ['amount', '>', 100]
-                ],
-                'or',
-                [
-                    ['customer', '=', 'Alice'],
-                    'and',
-                    ['status', '=', 'pending']
+            where: {
+                $or: [
+                    {
+                        $and: [
+                            { status: 'completed' },
+                            { amount: { $gt: 100 } }
+                        ]
+                    },
+                    {
+                        $and: [
+                            { customer: 'Alice' },
+                            { status: 'pending' }
+                        ]
+                    }
                 ]
-            ]
+            }
         };
         await driver.find('orders', query);
         
@@ -271,19 +272,22 @@ describe('MongoDriver', () => {
 
     it('should handle deeply nested filter groups', async () => {
         const query = {
-            filters: [
-                [
-                    [
-                        ['age', '>', 22],
-                        'and',
-                        ['status', '=', 'active']
-                    ],
-                    'or',
-                    ['role', '=', 'admin']
-                ],
-                'and',
-                ['name', '!=', 'Bob']
-            ]
+            where: {
+                $and: [
+                    {
+                        $or: [
+                            {
+                                $and: [
+                                    { age: { $gt: 22 } },
+                                    { status: 'active' }
+                                ]
+                            },
+                            { role: 'admin' }
+                        ]
+                    },
+                    { name: { $ne: 'Bob' } }
+                ]
+            }
         };
         await driver.find('users', query);
         
@@ -313,13 +317,17 @@ describe('MongoDriver', () => {
 
     it('should handle nested groups with implicit AND', async () => {
         const query = {
-            filters: [
-                [
-                    ['status', '=', 'active'],
-                    ['role', '=', 'admin']
-                ],
-                ['age', '>', 25]
-            ]
+            where: {
+                $and: [
+                    {
+                        $and: [
+                            { status: 'active' },
+                            { role: 'admin' }
+                        ]
+                    },
+                    { age: { $gt: 25 } }
+                ]
+            }
         };
         await driver.find('users', query);
         
@@ -341,14 +349,11 @@ describe('MongoDriver', () => {
                 const ast = {
                     object: 'users',
                     fields: ['name', 'email'],
-                    filters: {
-                        type: 'comparison' as const,
-                        field: 'status',
-                        operator: '=',
-                        value: 'active'
+                    where: {
+                        status: 'active'
                     },
-                    top: 10,
-                    skip: 0
+                    limit: 10,
+                    offset: 0
                 };
 
                 mockCollection.toArray.mockResolvedValue([
@@ -366,21 +371,10 @@ describe('MongoDriver', () => {
             it('should handle complex QueryAST with AND filters', async () => {
                 const ast = {
                     object: 'users',
-                    filters: {
-                        type: 'and' as const,
-                        children: [
-                            {
-                                type: 'comparison' as const,
-                                field: 'status',
-                                operator: '=',
-                                value: 'active'
-                            },
-                            {
-                                type: 'comparison' as const,
-                                field: 'age',
-                                operator: '>',
-                                value: 18
-                            }
+                    where: {
+                        $and: [
+                            { status: 'active' },
+                            { age: { $gt: 18 } }
                         ]
                     }
                 };
@@ -396,7 +390,7 @@ describe('MongoDriver', () => {
             it('should handle QueryAST with sort', async () => {
                 const ast = {
                     object: 'users',
-                    sort: [
+                    orderBy: [
                         { field: 'name', order: 'asc' as const }
                     ]
                 };

package/test/integration.test.ts

@@ -8,7 +8,7 @@
 
 import { MongoDriver } from '../src';
 import { MongoClient } from 'mongodb';
-import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoMemoryReplSet } from 'mongodb-memory-server';
 
 /**
  * Integration tests for MongoDriver with real MongoDB operations.
@@ -32,18 +32,22 @@ const skipIfMongoUnavailable = () => {
 describe('MongoDriver Integration Tests', () => {
     let driver: MongoDriver;
     let client: MongoClient;
-    let mongod: MongoMemoryServer;
+    let mongod: MongoMemoryReplSet;
     let mongoUrl: string;
     let dbName: string;
 
     beforeAll(async () => {
         try {
-            // Use existing MONGO_URL if provided (e.g. implementation in CI services)
-            // Otherwise start an in-memory instance
+            // Use existing MONGO_URL if provided (e.g. in CI services)
+            // Otherwise start an in-memory replica set
             if (process.env.MONGO_URL) {
                 mongoUrl = process.env.MONGO_URL;
             } else {
-                mongod = await MongoMemoryServer.create();
+                // Create MongoDB Memory Replica Set
+                // This is required for change streams to work
+                mongod = await MongoMemoryReplSet.create({
+                    replSet: { count: 1, storageEngine: 'wiredTiger' }
+                });
                 mongoUrl = mongod.getUri();
             }
             
@@ -716,4 +720,245 @@ describe('MongoDriver Integration Tests', () => {
             expect(results.length).toBe(2);
         });
     });
+
+    describe('Distinct Method', () => {
+        beforeEach(async () => {
+            if (skipIfMongoUnavailable()) return;
+            // Create test data
+            await driver.create('products', { name: 'Laptop', category: 'Electronics', price: 1200 });
+            await driver.create('products', { name: 'Mouse', category: 'Electronics', price: 25 });
+            await driver.create('products', { name: 'Desk', category: 'Furniture', price: 500 });
+            await driver.create('products', { name: 'Chair', category: 'Furniture', price: 300 });
+            await driver.create('products', { name: 'Monitor', category: 'Electronics', price: 400 });
+        });
+
+        test('should get distinct values for a field', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const categories = await driver.distinct('products', 'category');
+            
+            expect(categories).toBeDefined();
+            expect(Array.isArray(categories)).toBe(true);
+            expect(categories.sort()).toEqual(['Electronics', 'Furniture'].sort());
+        });
+
+        test('should get distinct values with filters', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const names = await driver.distinct('products', 'name', {
+                category: 'Electronics'
+            });
+            
+            expect(names).toBeDefined();
+            expect(names.length).toBe(3);
+            expect(names).toContain('Laptop');
+            expect(names).toContain('Mouse');
+            expect(names).toContain('Monitor');
+        });
+
+        test('should return empty array for non-matching filters', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const values = await driver.distinct('products', 'name', {
+                category: 'NonExistent'
+            });
+            
+            expect(values).toEqual([]);
+        });
+    });
+
+    describe('FindOneAndUpdate Method', () => {
+        beforeEach(async () => {
+            if (skipIfMongoUnavailable()) return;
+            // Create test data
+            await driver.create('users', { name: 'Alice', email: 'alice@example.com', status: 'active', points: 100 });
+            await driver.create('users', { name: 'Bob', email: 'bob@example.com', status: 'inactive', points: 50 });
+        });
+
+        test('should find and update a document', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const result = await driver.findOneAndUpdate(
+                'users',
+                { email: 'alice@example.com' },
+                { $set: { status: 'premium' } },
+                { returnDocument: 'after' }
+            );
+            
+            expect(result).toBeDefined();
+            expect(result.email).toBe('alice@example.com');
+            expect(result.status).toBe('premium');
+        });
+
+        test('should return document before update', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const result = await driver.findOneAndUpdate(
+                'users',
+                { email: 'bob@example.com' },
+                { $set: { status: 'active' } },
+                { returnDocument: 'before' }
+            );
+            
+            expect(result).toBeDefined();
+            expect(result.status).toBe('inactive'); // Should be the old value
+        });
+
+        test('should increment a field atomically', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const result = await driver.findOneAndUpdate(
+                'users',
+                { email: 'alice@example.com' },
+                { $inc: { points: 50 } },
+                { returnDocument: 'after' }
+            );
+            
+            expect(result).toBeDefined();
+            expect(result.points).toBe(150);
+        });
+
+        test('should upsert if document does not exist', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const result = await driver.findOneAndUpdate(
+                'users',
+                { email: 'charlie@example.com' },
+                { $set: { name: 'Charlie', email: 'charlie@example.com', status: 'active' } },
+                { returnDocument: 'after', upsert: true }
+            );
+            
+            expect(result).toBeDefined();
+            expect(result.email).toBe('charlie@example.com');
+            expect(result.name).toBe('Charlie');
+        });
+
+        test('should return null if no document matches', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const result = await driver.findOneAndUpdate(
+                'users',
+                { email: 'nonexistent@example.com' },
+                { $set: { status: 'active' } },
+                { returnDocument: 'after' }
+            );
+            
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('Change Streams (Watch)', () => {
+        test('should watch for insert operations', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const changes: any[] = [];
+            
+            // Start watching
+            const streamId = await driver.watch('users', async (change) => {
+                changes.push(change);
+            }, {
+                operationTypes: ['insert']
+            });
+            
+            expect(streamId).toBeDefined();
+            
+            // Give the change stream time to initialize
+            await new Promise(resolve => setTimeout(resolve, 500));
+            
+            // Insert a document
+            await driver.create('users', { name: 'ChangeTest', email: 'test@example.com' });
+            
+            // Wait for change to be detected
+            await new Promise(resolve => setTimeout(resolve, 500));
+            
+            // Stop watching
+            await driver.unwatchChangeStream(streamId);
+            
+            expect(changes.length).toBeGreaterThan(0);
+            expect(changes[0].operationType).toBe('insert');
+        });
+
+        test('should watch for update operations', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            // Create initial document
+            const doc = await driver.create('users', { name: 'UpdateTest', email: 'update@example.com' });
+            
+            const changes: any[] = [];
+            
+            // Start watching
+            const streamId = await driver.watch('users', async (change) => {
+                changes.push(change);
+            }, {
+                operationTypes: ['update'],
+                fullDocument: 'updateLookup'
+            });
+            
+            expect(streamId).toBeDefined();
+            
+            // Give the change stream time to initialize
+            await new Promise(resolve => setTimeout(resolve, 500));
+            
+            // Update the document
+            await driver.update('users', doc.id, { name: 'UpdatedName' });
+            
+            // Wait for change to be detected
+            await new Promise(resolve => setTimeout(resolve, 500));
+            
+            // Stop watching
+            await driver.unwatchChangeStream(streamId);
+            
+            expect(changes.length).toBeGreaterThan(0);
+            expect(changes[0].operationType).toBe('update');
+        });
+
+        test('should return list of active change streams', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const streamId1 = await driver.watch('users', async () => {});
+            const streamId2 = await driver.watch('products', async () => {});
+            
+            const activeStreams = driver.getActiveChangeStreams();
+            
+            expect(activeStreams).toContain(streamId1);
+            expect(activeStreams).toContain(streamId2);
+            expect(activeStreams.length).toBe(2);
+            
+            // Cleanup
+            await driver.unwatchChangeStream(streamId1);
+            await driver.unwatchChangeStream(streamId2);
+        });
+
+        test('should allow multiple watchers on same collection', async () => {
+            if (skipIfMongoUnavailable()) return;
+            
+            const changes1: any[] = [];
+            const changes2: any[] = [];
+            
+            const streamId1 = await driver.watch('users', async (change) => {
+                changes1.push(change);
+            });
+            
+            const streamId2 = await driver.watch('users', async (change) => {
+                changes2.push(change);
+            });
+            
+            // Give streams time to initialize
+            await new Promise(resolve => setTimeout(resolve, 500));
+            
+            // Create a document
+            await driver.create('users', { name: 'MultiWatch', email: 'multi@example.com' });
+            
+            // Wait for changes to be detected
+            await new Promise(resolve => setTimeout(resolve, 500));
+            
+            // Both watchers should have received the change
+            expect(changes1.length).toBeGreaterThan(0);
+            expect(changes2.length).toBeGreaterThan(0);
+            
+            // Cleanup
+            await driver.unwatchChangeStream(streamId1);
+            await driver.unwatchChangeStream(streamId2);
+        });
+    });
 });