@reproapp/node-sdk 0.0.28 → 0.0.29

package/dist/index.js

@@ -1028,10 +1028,6 @@ function scheduleTraceMaterializerIdleShutdown() {
             catch { }
         }
     }, TRACE_MATERIALIZE_WORKER_IDLE_SHUTDOWN_MS);
-    try {
-        traceMaterializerIdleTimer.unref?.();
-    }
-    catch { }
 }
 function rejectTraceMaterializerPending(error) {
     for (const [taskId, pending] of traceMaterializerPending.entries()) {
@@ -1373,11 +1369,43 @@ function waitForSessionDrain(sessionId) {
     if (remaining <= 0)
         return Promise.resolve();
     return new Promise(resolve => {
+        let settled = false;
+        let timeout = null;
+        const removeWaiter = (waiter) => {
+            const list = sessionWaiters.get(sessionId);
+            if (!list)
+                return;
+            const next = list.filter(fn => fn !== waiter);
+            if (next.length) {
+                sessionWaiters.set(sessionId, next);
+            }
+            else {
+                sessionWaiters.delete(sessionId);
+            }
+        };
+        const done = () => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout) {
+                try {
+                    clearTimeout(timeout);
+                }
+                catch { }
+                timeout = null;
+            }
+            removeWaiter(done);
+            resolve();
+        };
         const list = sessionWaiters.get(sessionId) || [];
-        list.push(resolve);
+        list.push(done);
         sessionWaiters.set(sessionId, list);
         if (SESSION_DRAIN_TIMEOUT_MS > 0 && Number.isFinite(SESSION_DRAIN_TIMEOUT_MS)) {
-            setTimeout(resolve, SESSION_DRAIN_TIMEOUT_MS);
+            timeout = setTimeout(done, SESSION_DRAIN_TIMEOUT_MS);
+            try {
+                timeout.unref?.();
+            }
+            catch { }
         }
     });
 }
@@ -4546,6 +4574,7 @@ function nativeMongoOpsForMongooseOp(op) {
     return [op];
 }
 function reproMongoosePlugin(cfg) {
+    patchMongoDb(cfg);
     return function (schema) {
         // -------- pre/post save (unchanged) --------
         schema.pre('save', { document: true }, function (next) {
@@ -7942,6 +7971,50 @@ function patchMongoCollectionPrototype(proto, cfg) {
         patchMongoCollectionMethod(proto, op, true, cfg);
     }
 }
+function patchMongoCollectionInstance(collection, cfg) {
+    if (!collection || typeof collection !== 'object')
+        return collection;
+    patchMongoCollectionPrototype(Object.getPrototypeOf(collection), cfg);
+    patchMongoCollectionPrototype(collection, cfg);
+    return collection;
+}
+function patchMongoDbPrototype(proto, cfg) {
+    if (!proto)
+        return;
+    const marker = '__repro_mongodb_db_collection_patched';
+    if (proto[marker])
+        return;
+    const original = proto.collection;
+    if (typeof original !== 'function')
+        return;
+    proto[marker] = true;
+    proto.collection = function reproPatchedMongoDbCollection(...args) {
+        const collection = original.apply(this, args);
+        return patchMongoCollectionInstance(collection, cfg);
+    };
+}
+function patchMongoDbInstance(db, cfg) {
+    if (!db || typeof db !== 'object')
+        return db;
+    patchMongoDbPrototype(Object.getPrototypeOf(db), cfg);
+    patchMongoDbPrototype(db, cfg);
+    return db;
+}
+function patchMongoClientPrototype(proto, cfg) {
+    if (!proto)
+        return;
+    const marker = '__repro_mongodb_client_db_patched';
+    if (proto[marker])
+        return;
+    const original = proto.db;
+    if (typeof original !== 'function')
+        return;
+    proto[marker] = true;
+    proto.db = function reproPatchedMongoClientDb(...args) {
+        const db = original.apply(this, args);
+        return patchMongoDbInstance(db, cfg);
+    };
+}
 function patchMongoDbFromModuleExports(mongoModule, cfg) {
     if (!mongoModule)
         return;
@@ -7956,6 +8029,28 @@ function patchMongoDbFromModuleExports(mongoModule, cfg) {
     for (const ctor of constructors) {
         patchMongoCollectionPrototype(ctor.prototype, cfg);
     }
+    const dbConstructors = new Set();
+    const clientConstructors = new Set();
+    const addDbCtor = (candidate) => {
+        if (typeof candidate === 'function' && candidate.prototype) {
+            dbConstructors.add(candidate);
+        }
+    };
+    const addClientCtor = (candidate) => {
+        if (typeof candidate === 'function' && candidate.prototype) {
+            clientConstructors.add(candidate);
+        }
+    };
+    addDbCtor(mongoModule?.Db);
+    addDbCtor(mongoModule?.default?.Db);
+    addClientCtor(mongoModule?.MongoClient);
+    addClientCtor(mongoModule?.default?.MongoClient);
+    for (const ctor of dbConstructors) {
+        patchMongoDbPrototype(ctor.prototype, cfg);
+    }
+    for (const ctor of clientConstructors) {
+        patchMongoClientPrototype(ctor.prototype, cfg);
+    }
 }
 function installMongoDbRequireHook() {
     if (mongoDbRequireHookInstalled)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1429,7 +1429,6 @@ function scheduleTraceMaterializerIdleShutdown(): void {
             try { void worker.terminate?.(); } catch {}
         }
     }, TRACE_MATERIALIZE_WORKER_IDLE_SHUTDOWN_MS);
-    try { (traceMaterializerIdleTimer as any).unref?.(); } catch {}
 }
 
 function rejectTraceMaterializerPending(error: Error): void {
@@ -1745,11 +1744,34 @@ function waitForSessionDrain(sessionId: string): Promise<void> {
     if (remaining <= 0) return Promise.resolve();
 
     return new Promise(resolve => {
+        let settled = false;
+        let timeout: NodeJS.Timeout | null = null;
+        const removeWaiter = (waiter: () => void) => {
+            const list = sessionWaiters.get(sessionId);
+            if (!list) return;
+            const next = list.filter(fn => fn !== waiter);
+            if (next.length) {
+                sessionWaiters.set(sessionId, next);
+            } else {
+                sessionWaiters.delete(sessionId);
+            }
+        };
+        const done = () => {
+            if (settled) return;
+            settled = true;
+            if (timeout) {
+                try { clearTimeout(timeout); } catch {}
+                timeout = null;
+            }
+            removeWaiter(done);
+            resolve();
+        };
         const list = sessionWaiters.get(sessionId) || [];
-        list.push(resolve);
+        list.push(done);
         sessionWaiters.set(sessionId, list);
         if (SESSION_DRAIN_TIMEOUT_MS > 0 && Number.isFinite(SESSION_DRAIN_TIMEOUT_MS)) {
-            setTimeout(resolve, SESSION_DRAIN_TIMEOUT_MS);
+            timeout = setTimeout(done, SESSION_DRAIN_TIMEOUT_MS);
+            try { (timeout as any).unref?.(); } catch {}
         }
     });
 }
@@ -5490,6 +5512,7 @@ function nativeMongoOpsForMongooseOp(op: string): string[] {
 }
 
 export function reproMongoosePlugin(cfg: ReproMiddlewareConfig) {
+    patchMongoDb(cfg);
     return function (schema: Schema) {
         // -------- pre/post save (unchanged) --------
         schema.pre('save', { document: true }, function (next) {
@@ -9185,6 +9208,46 @@ function patchMongoCollectionPrototype(proto: any, cfg: MongoDbPatchConfig): voi
     }
 }
 
+function patchMongoCollectionInstance(collection: any, cfg: MongoDbPatchConfig): any {
+    if (!collection || typeof collection !== 'object') return collection;
+    patchMongoCollectionPrototype(Object.getPrototypeOf(collection), cfg);
+    patchMongoCollectionPrototype(collection, cfg);
+    return collection;
+}
+
+function patchMongoDbPrototype(proto: any, cfg: MongoDbPatchConfig): void {
+    if (!proto) return;
+    const marker = '__repro_mongodb_db_collection_patched';
+    if (proto[marker]) return;
+    const original = proto.collection;
+    if (typeof original !== 'function') return;
+    proto[marker] = true;
+    proto.collection = function reproPatchedMongoDbCollection(this: any, ...args: any[]) {
+        const collection = original.apply(this, args);
+        return patchMongoCollectionInstance(collection, cfg);
+    };
+}
+
+function patchMongoDbInstance(db: any, cfg: MongoDbPatchConfig): any {
+    if (!db || typeof db !== 'object') return db;
+    patchMongoDbPrototype(Object.getPrototypeOf(db), cfg);
+    patchMongoDbPrototype(db, cfg);
+    return db;
+}
+
+function patchMongoClientPrototype(proto: any, cfg: MongoDbPatchConfig): void {
+    if (!proto) return;
+    const marker = '__repro_mongodb_client_db_patched';
+    if (proto[marker]) return;
+    const original = proto.db;
+    if (typeof original !== 'function') return;
+    proto[marker] = true;
+    proto.db = function reproPatchedMongoClientDb(this: any, ...args: any[]) {
+        const db = original.apply(this, args);
+        return patchMongoDbInstance(db, cfg);
+    };
+}
+
 function patchMongoDbFromModuleExports(mongoModule: any, cfg: MongoDbPatchConfig): void {
     if (!mongoModule) return;
     const constructors = new Set<any>();
@@ -9200,6 +9263,31 @@ function patchMongoDbFromModuleExports(mongoModule: any, cfg: MongoDbPatchConfig
     for (const ctor of constructors) {
         patchMongoCollectionPrototype(ctor.prototype, cfg);
     }
+
+    const dbConstructors = new Set<any>();
+    const clientConstructors = new Set<any>();
+    const addDbCtor = (candidate: any) => {
+        if (typeof candidate === 'function' && candidate.prototype) {
+            dbConstructors.add(candidate);
+        }
+    };
+    const addClientCtor = (candidate: any) => {
+        if (typeof candidate === 'function' && candidate.prototype) {
+            clientConstructors.add(candidate);
+        }
+    };
+
+    addDbCtor(mongoModule?.Db);
+    addDbCtor(mongoModule?.default?.Db);
+    addClientCtor(mongoModule?.MongoClient);
+    addClientCtor(mongoModule?.default?.MongoClient);
+
+    for (const ctor of dbConstructors) {
+        patchMongoDbPrototype(ctor.prototype, cfg);
+    }
+    for (const ctor of clientConstructors) {
+        patchMongoClientPrototype(ctor.prototype, cfg);
+    }
 }
 
 function installMongoDbRequireHook(): void {

package/test/mongodb-integration.test.js

@@ -176,6 +176,83 @@ async function testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne() {
     });
 }
 
+async function testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_mongo_client_chain';
+        const actionId = 'A_mongo_client_chain';
+        const cfg = makeConfig(sessionId, actionId);
+
+        class FakeCollection {
+            constructor(dbName, collectionName) {
+                this.dbName = dbName;
+                this.collectionName = collectionName;
+            }
+
+            async insertOne(doc, options) {
+                assert.strictEqual(options.session.id, 'native-chain-session-1');
+                doc._id = doc._id ?? 'subject-chain-1';
+                return { acknowledged: true, insertedId: doc._id };
+            }
+        }
+
+        class FakeDb {
+            constructor(dbName) {
+                this.databaseName = dbName;
+            }
+
+            collection(collectionName) {
+                return new FakeCollection(this.databaseName, collectionName);
+            }
+        }
+
+        class FakeMongoClient {
+            db(dbName) {
+                return new FakeDb(dbName);
+            }
+        }
+
+        __reproTestHooks.patchMongoDbModuleForTest({
+            MongoClient: FakeMongoClient,
+            Db: FakeDb,
+        }, cfg);
+
+        const dbClient = new FakeMongoClient();
+        const subjectsCollection = dbClient.db('clinical').collection('subjects');
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            const result = await subjectsCollection.insertOne(
+                { subjectNumber: '10013038', status: 'screened' },
+                {
+                    session: {
+                        id: 'native-chain-session-1',
+                        hasEnded: false,
+                        inTransaction: () => true,
+                    },
+                },
+            );
+            assert.deepStrictEqual(result, { acknowledged: true, insertedId: 'subject-chain-1' });
+        });
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await drainSdk();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'subjects');
+        assert.strictEqual(change.op, 'insertOne');
+        assert.strictEqual(change.pk._id, 'subject-chain-1');
+        assert.strictEqual(change.query.driver, 'mongodb');
+        assert.strictEqual(change.query.db, 'clinical');
+        assert.strictEqual(change.query.doc.subjectNumber, '10013038');
+        assert.strictEqual(change.query.options.session.__kind, 'mongodb_client_session');
+        assert.strictEqual(change.query.options.session.id, 'native-chain-session-1');
+        assert.strictEqual(change.after.subjectNumber, '10013038');
+        assert.strictEqual(change.resultMeta.insertedId, 'subject-chain-1');
+        assert.strictEqual(change.resultMeta.acknowledged, true);
+    });
+}
+
 async function testNativeInsertOneIsCaptured() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -376,6 +453,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
 
 (async () => {
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
+    await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
     await testNativeInsertOneIsCaptured();
     await testNativeUpdateOneUpsertIsCaptured();
     await testNativeFindCursorToArrayIsCaptured();