@reproapp/node-sdk 0.0.35 → 0.0.36

package/package.json

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

package/test/mongodb-integration.test.js

@@ -332,6 +332,151 @@ async function testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport(
     });
 }
 
+async function testClientScreenNativeMongoInsertOneShapeIsCaptured() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_client_screen_native_insert';
+        const actionId = 'A_client_screen_native_insert';
+        const cfg = {
+            ...makeConfig(sessionId, actionId),
+            privacy: { environment: 'dev', captureRaw: true },
+        };
+
+        class FakeCollection {
+            constructor(dbName, collectionName) {
+                this.dbName = dbName;
+                this.collectionName = collectionName;
+            }
+
+            async insertOne(doc, options) {
+                assert.strictEqual(options.session.id, 'screen-transaction-session-1');
+                doc._id = doc._id ?? 'subject-screen-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 connectionDictionary = {
+            pulmovant: {
+                db: {
+                    databaseName: 'dev-configure-pulmovant',
+                },
+            },
+        };
+        const collectionNames = {
+            SUBJECTS: 'subjects',
+        };
+        const completeVisitTypeLimitChecks = async () => null;
+
+        async function screen(req, newSubjectRecord, openUserTransaction) {
+            newSubjectRecord.lastUserTransactionId = openUserTransaction._id;
+
+            const dbName = connectionDictionary[req.query.tenantId].db.databaseName;
+            const subjectsCollection = await dbClient.db(dbName).collection(collectionNames.SUBJECTS);
+
+            const checkResult = await completeVisitTypeLimitChecks();
+            if (checkResult) return { success: false, message: checkResult };
+
+            const subjectSaveResult = await subjectsCollection.insertOne(newSubjectRecord, {
+                session: req.mongoSession,
+            });
+
+            if (!subjectSaveResult.acknowledged) {
+                throw new Error('Error creating subject');
+            }
+
+            return { success: true, insertedId: subjectSaveResult.insertedId };
+        }
+
+        const newSubjectRecord = {
+            activityLog: {
+                createdBy: '678a70921acd637a6de91c1f',
+                createdByUserName: "Pat O'Brien",
+                createdOn: '2026-06-22 10:14:13.151000000',
+            },
+            demographics: [
+                { key: 'age', type: 'Number', value: '35' },
+                { key: 'dateOfBirth', type: 'String', value: '1990' },
+                { key: 'gender', type: 'String', value: 'Female' },
+            ],
+            protocolId: '69e77c77ab541cfac917b36b',
+            site: {
+                id: '69f0c10256a07ef2204a6ef6',
+                number: '1001',
+            },
+            status: 'Active',
+            subjectFlags: {
+                isRescreen: false,
+            },
+            subjectNumber: '10013060',
+            subjectStatus: 'Screened',
+            subjectStatusOption: 'Screened',
+        };
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            const result = await screen(
+                {
+                    query: { tenantId: 'pulmovant' },
+                    mongoSession: {
+                        id: 'screen-transaction-session-1',
+                        hasEnded: false,
+                        inTransaction: () => true,
+                    },
+                },
+                newSubjectRecord,
+                { _id: '6a390af395744083f43fd484' },
+            );
+            assert.deepStrictEqual(result, {
+                success: true,
+                insertedId: 'subject-screen-1',
+            });
+        });
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await waitFor(() => requestCaptureManifests(flattenEvents(capturedBodies)).length === 1);
+        await drainSdk();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        const [manifest] = requestCaptureManifests(flattenEvents(capturedBodies));
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'subjects');
+        assert.strictEqual(change.op, 'insertOne');
+        assert.strictEqual(change.pk._id, 'subject-screen-1');
+        assert.strictEqual(change.query.driver, 'mongodb');
+        assert.strictEqual(change.query.db, 'dev-configure-pulmovant');
+        assert.strictEqual(change.query.doc.subjectNumber, '10013060');
+        assert.strictEqual(change.query.doc.lastUserTransactionId, '6a390af395744083f43fd484');
+        assert.strictEqual(change.query.options.session.__kind, 'mongodb_client_session');
+        assert.strictEqual(change.query.options.session.id, 'screen-transaction-session-1');
+        assert.strictEqual(change.query.options.session.inTransaction, true);
+        assert.strictEqual(change.after.subjectNumber, '10013060');
+        assert.strictEqual(change.resultMeta.insertedId, 'subject-screen-1');
+        assert.strictEqual(change.resultMeta.acknowledged, true);
+        assert.strictEqual(manifest.expected.dbChange, 1);
+    });
+}
+
 async function testNativeInsertOneIsCaptured() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -596,6 +741,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
     await testMongooseSuppressionDoesNotHideExplicitNativeInsertOne();
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
     await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
+    await testClientScreenNativeMongoInsertOneShapeIsCaptured();
     await testNativeInsertOneIsCaptured();
     await testCaptureRawNativeInsertOneUsesJsonSafeTransportValues();
     await testNativeUpdateOneUpsertIsCaptured();