@reproapp/node-sdk 0.0.27 → 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 { }
         }
     });
 }
@@ -3997,6 +4025,7 @@ async function maybeCaptureDbValueAsync(params, sink) {
 }
 function reproMiddleware(cfg) {
     const masking = normalizeMaskingConfig(cfg.masking);
+    patchMongoDb(cfg);
     return async function (req, res, next) {
         const querySid = readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM);
         const queryAid = readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM);
@@ -4545,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) {
@@ -7941,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;
@@ -7955,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)
@@ -7979,10 +8075,6 @@ function patchMongoDb(cfg) {
     mongoDbPatchConfigs.push(cfg);
     installMongoDbRequireHook();
     const mongoModules = new Set();
-    const resolvedMongoModule = requireOptionalHostModule('mongodb');
-    if (resolvedMongoModule) {
-        mongoModules.add(resolvedMongoModule);
-    }
     for (const loadedMongoModule of getLoadedModuleExportsByPackage('mongodb')) {
         mongoModules.add(loadedMongoModule);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.27",
+  "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 {}
         }
     });
 }
@@ -4892,6 +4914,7 @@ export type ReproInitConfig = ReproMiddlewareConfig & {
 
 export function reproMiddleware(cfg: ReproMiddlewareConfig) {
     const masking = normalizeMaskingConfig(cfg.masking);
+    patchMongoDb(cfg);
     return async function (req: Request, res: Response, next: NextFunction) {
         const querySid = readRequestQueryParam(req, REPRO_QUERY_SESSION_PARAM);
         const queryAid = readRequestQueryParam(req, REPRO_QUERY_ACTION_PARAM);
@@ -5489,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) {
@@ -9184,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>();
@@ -9199,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 {
@@ -9225,10 +9314,6 @@ export function patchMongoDb(cfg: MongoDbPatchConfig): void {
     installMongoDbRequireHook();
 
     const mongoModules = new Set<any>();
-    const resolvedMongoModule = requireOptionalHostModule('mongodb');
-    if (resolvedMongoModule) {
-        mongoModules.add(resolvedMongoModule);
-    }
     for (const loadedMongoModule of getLoadedModuleExportsByPackage('mongodb')) {
         mongoModules.add(loadedMongoModule);
     }

package/test/mongodb-integration.test.js

@@ -7,6 +7,16 @@ process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
 
 const assert = require('assert');
 const { EventEmitter } = require('events');
+const mongodb = require('mongodb');
+
+const originalNativeMongoInsertOne = mongodb.Collection.prototype.insertOne;
+
+mongodb.Collection.prototype.insertOne = async function reproFakeNativeMongoInsertOne(doc, options) {
+    assert.strictEqual(options.session.id, 'native-real-session-1');
+    doc._id = doc._id ?? 'subject-real-1';
+    return { acknowledged: true, insertedId: doc._id };
+};
+
 const { flushIngestQueue } = require('../dist/ingest/client');
 const { reproMiddleware, __reproTestHooks } = require('../dist');
 
@@ -122,6 +132,127 @@ function dbChanges(events) {
         .flatMap((event) => Array.isArray(event.payload?.db) ? event.payload.db : []);
 }
 
+async function testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_mongo_real_client_insert';
+        const actionId = 'A_mongo_real_client_insert';
+        const cfg = makeConfig(sessionId, actionId);
+
+        const collection = new mongodb.MongoClient('mongodb://127.0.0.1:27017/clinical')
+            .db('clinical')
+            .collection('subjects');
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            const result = await collection.insertOne(
+                { subjectNumber: '10013038', status: 'screened' },
+                {
+                    session: {
+                        id: 'native-real-session-1',
+                        hasEnded: false,
+                        inTransaction: () => true,
+                    },
+                },
+            );
+            assert.deepStrictEqual(result, { acknowledged: true, insertedId: 'subject-real-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-real-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-real-session-1');
+        assert.strictEqual(change.after.subjectNumber, '10013038');
+        assert.strictEqual(change.resultMeta.insertedId, 'subject-real-1');
+        assert.strictEqual(change.resultMeta.acknowledged, true);
+    });
+}
+
+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();
@@ -321,6 +452,8 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
 }
 
 (async () => {
+    await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
+    await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
     await testNativeInsertOneIsCaptured();
     await testNativeUpdateOneUpsertIsCaptured();
     await testNativeFindCursorToArrayIsCaptured();
@@ -329,4 +462,6 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
 })().catch((err) => {
     console.error(err);
     process.exit(1);
+}).finally(() => {
+    mongodb.Collection.prototype.insertOne = originalNativeMongoInsertOne;
 });