@objectql/driver-mongo 4.0.2 → 4.0.4

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();
             }
             
@@ -295,12 +299,12 @@ describe('MongoDriver Integration Tests', () => {
             await driver.create('users', { name: 'Bob', status: 'pending' });
             await driver.create('users', { name: 'Charlie', status: 'active' });
 
-            const modifiedCount = await driver.updateMany('users',
+            const result = await driver.updateMany('users',
                 [['status', '=', 'pending']],
                 { status: 'active' }
             );
 
-            expect(modifiedCount).toBe(2);
+            expect(result.modifiedCount).toBe(2);
 
             const results = await driver.find('users', {
                 filters: [['status', '=', 'active']]
@@ -314,12 +318,12 @@ describe('MongoDriver Integration Tests', () => {
             await driver.create('users', { name: 'Bob', score: 20, active: true });
             await driver.create('users', { name: 'Charlie', score: 30, active: false });
 
-            const modifiedCount = await driver.updateMany('users',
+            const result = await driver.updateMany('users',
                 [['active', '=', true]],
                 { $inc: { score: 5 } }
             );
 
-            expect(modifiedCount).toBe(2);
+            expect(result.modifiedCount).toBe(2);
 
             const alice = await driver.findOne('users', null as any, {
                 filters: [['name', '=', 'Alice']]
@@ -333,11 +337,11 @@ describe('MongoDriver Integration Tests', () => {
             await driver.create('users', { name: 'Bob', status: 'inactive' });
             await driver.create('users', { name: 'Charlie', status: 'active' });
 
-            const deletedCount = await driver.deleteMany('users',
+            const result = await driver.deleteMany('users',
                 [['status', '=', 'inactive']]
             );
 
-            expect(deletedCount).toBe(2);
+            expect(result.deletedCount).toBe(2);
 
             const remaining = await driver.count('users', []);
             expect(remaining).toBe(1);
@@ -348,16 +352,16 @@ describe('MongoDriver Integration Tests', () => {
             const result = await driver.createMany('users', []);
             expect(result).toBeDefined();
 
-            const updated = await driver.updateMany('users',
+            const updateResult = await driver.updateMany('users',
                 [['name', '=', 'nonexistent']],
                 { status: 'updated' }
             );
-            expect(updated).toBe(0);
+            expect(updateResult.modifiedCount).toBe(0);
 
-            const deleted = await driver.deleteMany('users',
+            const deleteResult = await driver.deleteMany('users',
                 [['name', '=', 'nonexistent']]
             );
-            expect(deleted).toBe(0);
+            expect(deleteResult.deletedCount).toBe(0);
         });
     });
 
@@ -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);
+        });
+    });
 });

package/test/tck.test.ts

@@ -0,0 +1,73 @@
+/**
+ * ObjectQL MongoDB Driver TCK Tests
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * MongoDB Driver TCK (Technology Compatibility Kit) Tests
+ * 
+ * This test suite verifies that the MongoDB driver passes all TCK requirements.
+ */
+
+import { runDriverTCK } from '@objectql/driver-tck';
+import { MongoDriver } from '../src';
+import { MongoMemoryReplSet } from 'mongodb-memory-server';
+
+describe('MongoDriver TCK Compliance', () => {
+    let mongoServer: MongoMemoryReplSet;
+    let driver: MongoDriver;
+    
+    beforeAll(async () => {
+        // Start MongoDB Memory Server with replica set (required for transactions)
+        mongoServer = await MongoMemoryReplSet.create({
+            replSet: { count: 1, storageEngine: 'wiredTiger' }
+        });
+    }, 120000);
+    
+    afterAll(async () => {
+        if (driver) {
+            await driver.disconnect();
+        }
+        if (mongoServer) {
+            await mongoServer.stop();
+        }
+    }, 60000);
+    
+    runDriverTCK(
+        () => {
+            const uri = mongoServer.getUri();
+            driver = new MongoDriver({
+                url: uri,
+                dbName: 'tck_test'
+            });
+            return driver;
+        },
+        {
+            // MongoDB supports most features
+            skip: {
+                // No features to skip - MongoDB now supports transactions
+            },
+            timeout: 30000,
+            hooks: {
+                beforeEach: async () => {
+                    // Wait for driver to connect
+                    await driver['connected'];
+                    
+                    // Clear all collections
+                    if (driver && driver['db']) {
+                        const collections = await driver['db'].listCollections().toArray();
+                        for (const collection of collections) {
+                            await driver['db'].collection(collection.name).deleteMany({});
+                        }
+                    }
+                },
+                afterEach: async () => {
+                    // Cleanup handled in beforeEach
+                }
+            }
+        }
+    );
+});