@reproapp/node-sdk 0.0.37 → 0.0.39

package/test/backend-live-mode.test.js

@@ -0,0 +1,403 @@
+const assert = require('assert');
+const express = require('express');
+const http = require('http');
+
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+
+const {
+  reproMiddleware,
+  __reproTestHooks,
+} = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+async function listen(server) {
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  return server.address().port;
+}
+
+async function close(server) {
+  await new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+async function request(port, path = '/untagged', options = {}) {
+  const method = options.method || 'POST';
+  const headers = {
+    ...(method === 'POST' ? { 'content-type': 'application/json' } : {}),
+    ...(options.headers || {}),
+  };
+  await new Promise((resolve, reject) => {
+    const req = http.request({
+      host: '127.0.0.1',
+      port,
+      path,
+      method,
+      headers,
+    }, (res) => {
+      res.resume();
+      res.on('end', resolve);
+    });
+    req.on('error', reject);
+    if (method === 'POST') {
+      req.end(JSON.stringify({ ok: true }));
+    } else {
+      req.end();
+    }
+  });
+}
+
+async function drainAll() {
+  await __reproTestHooks.drainSdkBackgroundQueueForTest();
+  await flushIngestQueue();
+}
+
+async function drainUntil(predicate, timeoutMs = 1000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    await drainAll();
+    if (predicate()) return true;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  await drainAll();
+  return predicate();
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main() {
+  const posts = [];
+  const claimCounts = new Map();
+  const originalFetch = global.fetch;
+  global.fetch = async (url, init = {}) => {
+    const body = init.body ? JSON.parse(String(init.body)) : null;
+    posts.push({ url: String(url), body, headers: init.headers || {} });
+    if (String(url) === 'http://repro-api.test/api/v1/live-sessions/claim') {
+      const actor = String(body?.actorId || 'unknown');
+      const count = (claimCounts.get(actor) || 0) + 1;
+      claimCounts.set(actor, count);
+      const safeActor = actor.replace(/[^A-Za-z0-9_.:-]/g, '_');
+      const childSuffix = actor === 'actor-overlap' ? `_${count}` : '';
+      const childSessionId = `S_claim_child_${safeActor}${childSuffix}`;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          parentSessionId: `S_claim_parent_${safeActor}`,
+          childSessionId,
+          sessionId: childSessionId,
+          actionId: `A_claim_${safeActor}_${count}`,
+          clockOffsetMs: 0,
+        }),
+        text: async () => '{"ok":true}',
+      };
+    }
+    return {
+      ok: true,
+      status: 202,
+      json: async () => ({ ok: true }),
+      text: async () => '{"ok":true}',
+    };
+  };
+
+  __reproTestHooks.resetSdkBackgroundQueuesForTest();
+  __reproTestHooks.setBackendLiveTimingForTest({
+    segmentIdleMs: 1,
+    sessionMaxDurationMs: 20,
+    segmentMaxDurationMs: 20,
+  });
+
+  const cfg = {
+    appId: 'APP_backend_live',
+    tenantId: 'TENANT_backend_live',
+    appSecret: 'secret',
+    appName: 'Backend Live Test',
+    serviceName: 'Backend API',
+    apiBase: 'http://repro-api.test/api',
+    ingestBase: 'http://log-collector.test',
+    liveMode: {
+      enabled: true,
+      backendOnly: true,
+      defineActorId: ({ req }) => req.headers['x-test-actor'] || 'actor-1',
+      shouldCapture: ({ path }) => path !== '/skip',
+      actorType: 'user',
+      actorLabels: { tier: 'enterprise' },
+    },
+  };
+
+  const app = express();
+  app.use(express.json());
+  app.use(reproMiddleware(cfg));
+  app.post('/untagged', (_req, res) => {
+    res.json({ ok: true });
+  });
+  const server = http.createServer(app);
+  const port = await listen(server);
+
+  try {
+    await request(port, '/preflight', {
+      method: 'OPTIONS',
+      headers: {
+        origin: 'http://client.test',
+        'access-control-request-method': 'POST',
+        'access-control-request-headers': 'x-bug-session-id,x-bug-action-id,x-bug-request-start',
+      },
+    });
+    await drainAll();
+    assert.equal(
+      posts.length,
+      0,
+      'uncorrelated OPTIONS preflight should not create live sessions or ingest events',
+    );
+
+    await request(port, '/preflight', {
+      method: 'OPTIONS',
+      headers: {
+        'x-bug-request-start': String(Date.now()),
+      },
+    });
+    await drainAll();
+    assert.equal(
+      posts.length,
+      0,
+      'OPTIONS with only Repro timing should not create backend-only live sessions',
+    );
+
+    const correlatedOptionsSid = 'S_frontend_options';
+    const correlatedOptionsAid = 'A_frontend_options';
+    await request(port, '/preflight', {
+      method: 'OPTIONS',
+      headers: {
+        'x-bug-session-id': correlatedOptionsSid,
+        'x-bug-action-id': correlatedOptionsAid,
+        'x-bug-request-start': String(Date.now()),
+      },
+    });
+    await drainUntil(() => {
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      return events.some((event) =>
+        event.event_type === 'backend_request' &&
+        event.session_id === correlatedOptionsSid &&
+        event.payload?.action_id === correlatedOptionsAid
+      );
+    }, 2000);
+    assert(
+      posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : [])
+        .some((event) =>
+          event.event_type === 'backend_request' &&
+          event.session_id === correlatedOptionsSid &&
+          event.payload?.action_id === correlatedOptionsAid
+        ),
+      'correlated OPTIONS request should still be captured',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions').length,
+      0,
+      'frontend-correlated OPTIONS should not create a backend-only live parent',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim').length,
+      0,
+      'frontend-correlated OPTIONS should not claim a backend-only live session',
+    );
+
+    posts.length = 0;
+    const correlatedPostSid = 'S_frontend_post';
+    const correlatedPostAid = 'A_frontend_post';
+    await request(port, '/untagged', {
+      headers: {
+        'x-bug-session-id': correlatedPostSid,
+        'x-bug-action-id': correlatedPostAid,
+        'x-bug-request-start': String(Date.now()),
+        'x-test-actor': 'backend-user-1',
+      },
+    });
+    await drainUntil(() => {
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      return events.some((event) =>
+        event.event_type === 'backend_event' &&
+        event.session_id === correlatedPostSid &&
+        event.payload?.sessionActor?.actorId === 'backend-user-1'
+      );
+    }, 2000);
+    const correlatedEvents = posts
+      .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+      .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+    assert(
+      correlatedEvents.some((event) =>
+        event.event_type === 'backend_event' &&
+        event.session_id === correlatedPostSid &&
+        event.actor_id === 'backend-user-1' &&
+        event.payload?.sessionActor?.actorId === 'backend-user-1'
+      ),
+      'frontend-correlated request should emit backend actor alias evidence',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions').length,
+      0,
+      'frontend-correlated request should not create backend-only live sessions',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim').length,
+      0,
+      'frontend-correlated request should not claim backend-only live sessions',
+    );
+
+    posts.length = 0;
+    await request(port);
+    await drainUntil(() => {
+      const claims = posts
+        .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim')
+        .map((post) => post.body);
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      return claims.length >= 1 &&
+        events.some((event) => event.event_type === 'backend_request') &&
+        events.some((event) => event.event_type === 'request_capture_manifest');
+    }, 2000);
+
+    const claims = posts
+      .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim')
+      .map((post) => post.body);
+    assert.equal(claims.length, 1, 'backend-only request should claim one central live session');
+    assert.equal(claims[0].captureMode, 'backend-only');
+    assert.equal(claims[0].actorId, 'actor-1');
+    assert.deepEqual(claims[0].actorIds, ['actor-1']);
+
+    const ingestEvents = posts
+      .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+      .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+    assert(
+      ingestEvents.some((event) =>
+        event.event_type === 'backend_request' &&
+        event.session_id === 'S_claim_child_actor-1' &&
+        event.actor_id === 'actor-1'
+      ),
+      'backend request event should be captured for claimed child session and actor',
+    );
+    assert(
+      ingestEvents.some((event) =>
+        event.event_type === 'request_capture_manifest' &&
+        event.session_id === 'S_claim_child_actor-1'
+      ),
+      'request capture manifest should be emitted for claimed backend session',
+    );
+    assert.equal(
+      posts.filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions').length,
+      0,
+      'SDK should not locally create backend-only sessions after central claim',
+    );
+    assert.equal(
+      posts.some((post) => String(post.url).includes('/finish')),
+      false,
+      'SDK should not locally finish centrally claimed backend-only sessions',
+    );
+
+    console.log('backend live mode capture OK');
+  } finally {
+    await close(server);
+  }
+
+  posts.length = 0;
+  __reproTestHooks.resetSdkBackgroundQueuesForTest();
+  __reproTestHooks.setBackendLiveTimingForTest({
+    sessionMaxDurationMs: 30,
+    segmentMaxDurationMs: 30,
+    segmentIdleMs: 1,
+  });
+
+  const overlapCfg = {
+    ...cfg,
+    appId: 'APP_backend_live_overlap',
+    liveMode: {
+      ...cfg.liveMode,
+      defineActorId: () => 'actor-overlap',
+      shouldCapture: ({ path }) => path !== '/skip',
+    },
+  };
+
+  const overlapApp = express();
+  overlapApp.use(express.json());
+  overlapApp.use(reproMiddleware(overlapCfg));
+  overlapApp.post('/slow', async (_req, res) => {
+    await sleep(80);
+    res.json({ ok: true, kind: 'slow' });
+  });
+  overlapApp.post('/fast', (_req, res) => {
+    res.json({ ok: true, kind: 'fast' });
+  });
+  const overlapServer = http.createServer(overlapApp);
+  const overlapPort = await listen(overlapServer);
+
+  try {
+    const slowRequest = request(overlapPort, '/slow');
+    await sleep(50);
+    await request(overlapPort, '/fast');
+    await slowRequest;
+
+    await drainUntil(() => {
+      const claims = posts
+        .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim');
+      const events = posts
+        .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+        .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+      const requestSessionIds = new Set(
+        events
+          .filter((event) =>
+            event.event_type === 'backend_request' &&
+            event.actor_id === 'actor-overlap'
+          )
+          .map((event) => event.session_id),
+      );
+      return claims.length >= 2 && requestSessionIds.size >= 2;
+    });
+
+    const claims = posts
+      .filter((post) => post.url === 'http://repro-api.test/api/v1/live-sessions/claim')
+      .map((post) => post.body);
+    assert.equal(claims.length, 2, 'each backend-only request should ask the API for ownership');
+    assert(
+      claims.every((claim) => claim.actorId === 'actor-overlap'),
+      'overlap claims should keep the actor identity',
+    );
+
+    const ingestEvents = posts
+      .filter((post) => post.url === 'http://log-collector.test/v1/ingest/events')
+      .flatMap((post) => Array.isArray(post.body?.events) ? post.body.events : []);
+    const requestSessionIds = new Set(
+      ingestEvents
+        .filter((event) =>
+          event.event_type === 'backend_request' &&
+          event.actor_id === 'actor-overlap'
+        )
+        .map((event) => event.session_id),
+    );
+    assert.deepEqual(
+      new Set(['S_claim_child_actor-overlap_1', 'S_claim_child_actor-overlap_2']),
+      requestSessionIds,
+      'backend requests should use exactly the child sessions returned by the API claim',
+    );
+
+    console.log('backend live mode central claim overlap OK');
+  } finally {
+    await close(overlapServer);
+    global.fetch = originalFetch;
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    __reproTestHooks.setBackendLiveTimingForTest(null);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/test/mongodb-integration.test.js

@@ -133,12 +133,24 @@ function execPre(hooks, name, context) {
     });
 }
 
+function execPost(hooks, name, context, args = []) {
+    return new Promise((resolve, reject) => {
+        hooks.execPost(name, context, args, {}, (error) => (error ? reject(error) : resolve()));
+    });
+}
+
 function dbChanges(events) {
     return events
         .filter((event) => event.event_type === 'db_change')
         .flatMap((event) => Array.isArray(event.payload?.db) ? event.payload.db : []);
 }
 
+function dbValueEntries(events) {
+    return events
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => Array.isArray(event.payload?.dbValues) ? event.payload.dbValues : []);
+}
+
 function requestCaptureManifests(events) {
     return events
         .filter((event) => event.event_type === 'request_capture_manifest')
@@ -146,6 +158,81 @@ function requestCaptureManifests(events) {
         .filter(Boolean);
 }
 
+function makeNotificationModuleDocument() {
+    const notificationPreferences = Array.from({ length: 24 }, (_, index) => ({
+        trigger: 'SubjectScreened',
+        enabled: true,
+        channels: [
+            {
+                type: 'email',
+                template: {
+                    subject: `Participant Screening ${index}`,
+                    html: `<p>Screening notification ${index}</p>`,
+                },
+                recipients: {
+                    to: ['noreply@korioclinical.com'],
+                    cc: [
+                        `pobrien+dev-conf-csm${index}@korioclinical.com`,
+                        `mnebot+site-monitor${index}@korioclinical.com`,
+                    ],
+                    bcc: [`audit-${index}@korioclinical.com`],
+                },
+            },
+        ],
+    }));
+    const notificationTrigger = Array.from({ length: 24 }, (_, index) => ({
+        active: true,
+        event: 'SubjectScreened',
+        visitType: 'Screening',
+        subjectType: 'Participant',
+        rules: [
+            {
+                condition: {
+                    path: 'subject.subjectStatusOption',
+                    operator: 'equals',
+                    value: 'Screened',
+                },
+                action: {
+                    module: 'NotificationGeneratorService',
+                    method: 'SubjectScreened',
+                    order: index,
+                },
+            },
+        ],
+    }));
+
+    return {
+        __t: 'NotificationModule',
+        _id: '69e77c77ab541cfac917b37a',
+        active: true,
+        environment: 'dev-configure-pulmovant',
+        notificationPreferences,
+        notification_trigger: notificationTrigger,
+        protocol: {
+            id: '69e77c77ab541cfac917b36b',
+            name: 'RVT-2301-301',
+        },
+        schema_version: 1,
+        sponsor_name: 'Pulmovant',
+        study_name: 'RVT-2301-301',
+    };
+}
+
+class NotificationModuleHostDocument {
+    constructor(value) {
+        this.$__ = {};
+        this.value = value;
+    }
+
+    toObject() {
+        return JSON.parse(JSON.stringify(this.value));
+    }
+
+    toJSON() {
+        return this.toObject();
+    }
+}
+
 async function testMongooseSuppressionDoesNotHideExplicitNativeInsertOne() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -477,6 +564,82 @@ async function testClientScreenNativeMongoInsertOneShapeIsCaptured() {
     });
 }
 
+async function testLargeMongooseFindOneResultStoresFullResultMetaSidecar() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const sessionId = 'S_mongoose_large_result_meta';
+        const actionId = 'A_mongoose_large_result_meta';
+        const cfg = {
+            ...makeConfig(sessionId, actionId),
+            privacy: { environment: 'dev', captureRaw: true },
+        };
+
+        const schema = new mongoose.Schema({}, { strict: false });
+        reproMongoosePlugin(cfg)(schema);
+
+        const notificationModule = makeNotificationModuleDocument();
+        const rawResult = new NotificationModuleHostDocument(notificationModule);
+        const queryContext = {
+            model: {
+                collection: {
+                    name: 'configStudy',
+                },
+            },
+            getFilter: () => ({
+                __t: 'NotificationModule',
+                active: true,
+                protocol: {
+                    id: '69e77c77ab541cfac917b36b',
+                },
+            }),
+            getUpdate: () => undefined,
+            projection: () => undefined,
+            getOptions: () => ({ lean: false }),
+        };
+
+        await runCapturedRequest(cfg, sessionId, actionId, async () => {
+            await execPre(schema.s.hooks, 'findOne', queryContext);
+            await execPost(schema.s.hooks, 'findOne', queryContext, [rawResult]);
+        });
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await waitFor(() => dbValueEntries(flattenEvents(capturedBodies)).some((entry) => entry.target === 'db.resultMeta'));
+        await drainSdk();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        const values = dbValueEntries(flattenEvents(capturedBodies));
+        const resultMetaValue = values.find((entry) => entry.id === change.resultMetaValueCapture?.valueId);
+
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'configStudy');
+        assert.strictEqual(change.op, 'findOne');
+        assert.strictEqual(change.query.filter.__t, 'NotificationModule');
+        assert.strictEqual(change.resultMeta.docsCount, 1);
+        assert.deepStrictEqual(change.resultMeta.result.notificationPreferences[0], {
+            __kind: 'omitted',
+            reason: 'depth>3',
+        });
+        assert.deepStrictEqual(change.resultMeta.result.notification_trigger[0], {
+            __kind: 'omitted',
+            reason: 'depth>3',
+        });
+        assert.strictEqual(change.resultMetaValueCapture.status, 'stored');
+        assert.ok(change.resultMetaValueCapture.valueId, 'expected resultMeta value id');
+        assert.ok(resultMetaValue, 'expected matching db.resultMeta sidecar');
+        assert.strictEqual(resultMetaValue.target, 'db.resultMeta');
+        assert.strictEqual(resultMetaValue.value.__t, 'NotificationModule');
+        assert.strictEqual(resultMetaValue.value.notificationPreferences.length, 24);
+        assert.strictEqual(
+            resultMetaValue.value.notificationPreferences[0].channels[0].recipients.cc[0],
+            'pobrien+dev-conf-csm0@korioclinical.com',
+        );
+        assert.strictEqual(
+            resultMetaValue.value.notification_trigger[0].rules[0].action.method,
+            'SubjectScreened',
+        );
+    });
+}
+
 async function testNativeInsertOneIsCaptured() {
     await withCapturedFetch(async (capturedBodies) => {
         __reproTestHooks.resetSdkBackgroundQueuesForTest();
@@ -742,6 +905,7 @@ async function testNativeOperationFailureIsCapturedAndRethrown() {
     await testReproMiddlewarePatchesPreloadedNativeMongoClientInsertOne();
     await testMongoClientDbCollectionChainIsPatchedWithoutCollectionExport();
     await testClientScreenNativeMongoInsertOneShapeIsCaptured();
+    await testLargeMongooseFindOneResultStoresFullResultMetaSidecar();
     await testNativeInsertOneIsCaptured();
     await testCaptureRawNativeInsertOneUsesJsonSafeTransportValues();
     await testNativeUpdateOneUpsertIsCaptured();