@tellescope/sdk 1.256.11 → 1.256.12

package/lib/cjs/tests/api_tests/active_patient_count.test.d.ts

@@ -0,0 +1,15 @@
+import { Session } from "../../sdk";
+/**
+ * Locks in the behavior of getEngagedEndusers (endusers/engagement), which backs both the billing
+ * /usage endpoint and the super-admin active patient count. Every case creates exactly one
+ * qualifying (or deliberately non-qualifying) engagement record and asserts its effect on the
+ * distinct enduser count.
+ *
+ * All assertions are made inside a time window opened at the top of the test, so unrelated records
+ * left behind by other suites can't move the numbers.
+ */
+export declare const active_patient_count_tests: ({ sdk, sdkNonAdmin }: {
+    sdk: Session;
+    sdkNonAdmin: Session;
+}) => Promise<void>;
+//# sourceMappingURL=active_patient_count.test.d.ts.map

package/lib/cjs/tests/api_tests/active_patient_count.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active_patient_count.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/api_tests/active_patient_count.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAkB,MAAM,WAAW,CAAA;AAmBnD;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B;SAAwC,OAAO;iBAAe,OAAO;mBA+X3G,CAAA"}

package/lib/cjs/tests/api_tests/active_patient_count.test.js

@@ -0,0 +1,594 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.active_patient_count_tests = void 0;
+require('source-map-support').install();
+var sdk_1 = require("../../sdk");
+var testing_1 = require("@tellescope/testing");
+var setup_1 = require("../setup");
+var host = process.env.API_URL || 'http://localhost:8080';
+var businessId = '60398b1131a295e64f084ff6';
+// Second-tenant session, used to prove the active patient count never crosses tenants.
+// Same key used by the org-isolation tests in tests.ts.
+var OTHER_TENANT_API_KEY = "ba745e25162bb95a795c5fa1af70df188d93c4d3aac9c48b34a5c8c9dd7b80f7";
+// Arbitrary valid ObjectId — endusers carrying a customTypeId are excluded from the default count
+var TEST_CUSTOM_TYPE_ID = '60398b0231a295e64f084fd9';
+/**
+ * Locks in the behavior of getEngagedEndusers (endusers/engagement), which backs both the billing
+ * /usage endpoint and the super-admin active patient count. Every case creates exactly one
+ * qualifying (or deliberately non-qualifying) engagement record and asserts its effect on the
+ * distinct enduser count.
+ *
+ * All assertions are made inside a time window opened at the top of the test, so unrelated records
+ * left behind by other suites can't move the numbers.
+ */
+var active_patient_count_tests = function (_a) {
+    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var userId, windowStart, activeCount, onlyCase, onlyThisTest, _b, eEmail, eEmailOutbound, eSMS, eSMSOutbound, eCallInbound, eCallLongOutbound, eCallShortOutbound, eChat, eChatNoEnduser, eForm, eFormUnsubmitted, eFormOtherForm, eCalendar, eCalendarUserOnly, eCalendarPastStart, eGroupMMS, eGroupMMSUserSender, eDedupe, eCustomType, eInactive, createdEnduserIds, chatRoomIds, conversationIds, calendarEventIds, formIds, chatRoom, chatRoomNoEnduser, formA_1, fieldA, formB, fieldB, submitForm, calendarEvent, calendarEventUserOnly, calendarEventPastStart, conversation, dedupeRoom, EXPECTED_ACTIVE_1, expectActive, afterAll_1, enduserSDK_1, sdkOther_1, otherWindowStart_1, otherEnduser;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    (0, testing_1.log_header)("Active Patient Count Tests");
+                    userId = sdk.userInfo.id;
+                    windowStart = new Date(Date.now() - 2000);
+                    activeCount = function (args) {
+                        if (args === void 0) { args = {}; }
+                        return (sdk.api.endusers.get_engagement_statistics(__assign({ range: { from: windowStart } }, args))
+                            .then(function (r) { return r.count; }));
+                    };
+                    onlyCase = function (apcCase) { return activeCount({ enduserFields: [{ field: 'fields.apcCase', value: apcCase }] }); };
+                    onlyThisTest = function (args) {
+                        if (args === void 0) { args = {}; }
+                        return activeCount(__assign(__assign({}, args), { enduserFields: [{ field: 'fields.apcCase', value: '$exists' }] }));
+                    };
+                    return [4 /*yield*/, sdk.api.endusers.createSome([
+                            { fname: 'apc-email', fields: { apcCase: 'email', apcTag: 'yes', apcGroup: 'A' } },
+                            { fname: 'apc-email-outbound', fields: { apcCase: 'email-outbound' } },
+                            { fname: 'apc-sms', fields: { apcCase: 'sms', apcTag: 'yes', apcGroup: 'A' } },
+                            { fname: 'apc-sms-outbound', fields: { apcCase: 'sms-outbound' } },
+                            { fname: 'apc-call-inbound', fields: { apcCase: 'call-inbound', apcGroup: 'B' } },
+                            { fname: 'apc-call-long-outbound', fields: { apcCase: 'call-long-outbound', apcGroup: 'B' } },
+                            { fname: 'apc-call-short-outbound', fields: { apcCase: 'call-short-outbound' } },
+                            { fname: 'apc-chat', fields: { apcCase: 'chat', apcGroup: 'B' } },
+                            { fname: 'apc-chat-no-enduserid', fields: { apcCase: 'chat-no-enduserid' } },
+                            { fname: 'apc-form', fields: { apcCase: 'form', apcGroup: 'C' } },
+                            { fname: 'apc-form-unsubmitted', fields: { apcCase: 'form-unsubmitted' } },
+                            { fname: 'apc-form-other-form', fields: { apcCase: 'form-other-form', apcGroup: 'C' } },
+                            // deliberately has no apcGroup, so the $exists case below is narrower than the total
+                            { fname: 'apc-calendar', fields: { apcCase: 'calendar' } },
+                            { fname: 'apc-calendar-user-only', fields: { apcCase: 'calendar-user-only' } },
+                            { fname: 'apc-calendar-past-start', fields: { apcCase: 'calendar-past-start' } },
+                            { fname: 'apc-group-mms', fields: { apcCase: 'group-mms', apcGroup: 'D' } },
+                            { fname: 'apc-group-mms-user-sender', fields: { apcCase: 'group-mms-user-sender' } },
+                            { fname: 'apc-dedupe', fields: { apcCase: 'dedupe', apcTag: 'yes', apcGroup: 'D' } },
+                            { fname: 'apc-custom-type', customTypeId: TEST_CUSTOM_TYPE_ID, fields: { apcCase: 'custom-type' } },
+                            { fname: 'apc-inactive', fields: { apcCase: 'inactive' } },
+                        ])];
+                case 1:
+                    _b = (_c.sent()).created, eEmail = _b[0], eEmailOutbound = _b[1], eSMS = _b[2], eSMSOutbound = _b[3], eCallInbound = _b[4], eCallLongOutbound = _b[5], eCallShortOutbound = _b[6], eChat = _b[7], eChatNoEnduser = _b[8], eForm = _b[9], eFormUnsubmitted = _b[10], eFormOtherForm = _b[11], eCalendar = _b[12], eCalendarUserOnly = _b[13], eCalendarPastStart = _b[14], eGroupMMS = _b[15], eGroupMMSUserSender = _b[16], eDedupe = _b[17], eCustomType = _b[18], eInactive = _b[19];
+                    createdEnduserIds = [
+                        eEmail, eEmailOutbound, eSMS, eSMSOutbound, eCallInbound, eCallLongOutbound, eCallShortOutbound,
+                        eChat, eChatNoEnduser, eForm, eFormUnsubmitted, eFormOtherForm, eCalendar, eCalendarUserOnly,
+                        eCalendarPastStart, eGroupMMS, eGroupMMSUserSender, eDedupe, eCustomType, eInactive,
+                    ].map(function (e) { return e.id; });
+                    chatRoomIds = [];
+                    conversationIds = [];
+                    calendarEventIds = [];
+                    formIds = [];
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, , 75, 77]);
+                    // --- emails ---------------------------------------------------------------------------------
+                    return [4 /*yield*/, sdk.api.emails.createOne({
+                            logOnly: true, inbound: true,
+                            userId: userId,
+                            enduserId: eEmail.id, subject: 'apc inbound', textContent: 'inbound email',
+                        })
+                        // outbound with no link opens does not qualify
+                    ];
+                case 3:
+                    // --- emails ---------------------------------------------------------------------------------
+                    _c.sent();
+                    // outbound with no link opens does not qualify
+                    return [4 /*yield*/, sdk.api.emails.createOne({
+                            logOnly: true, inbound: false,
+                            userId: userId,
+                            enduserId: eEmailOutbound.id, subject: 'apc outbound', textContent: 'outbound email',
+                        })
+                        // --- sms_messages ---------------------------------------------------------------------------
+                    ];
+                case 4:
+                    // outbound with no link opens does not qualify
+                    _c.sent();
+                    // --- sms_messages ---------------------------------------------------------------------------
+                    return [4 /*yield*/, sdk.api.sms_messages.createOne({
+                            logOnly: true, inbound: true,
+                            userId: userId,
+                            enduserId: eSMS.id, message: 'apc inbound sms',
+                        })];
+                case 5:
+                    // --- sms_messages ---------------------------------------------------------------------------
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.sms_messages.createOne({
+                            logOnly: true, inbound: false,
+                            userId: userId,
+                            enduserId: eSMSOutbound.id, message: 'apc outbound sms',
+                        })
+                        // --- phone_calls ----------------------------------------------------------------------------
+                        // inbound qualifies regardless of duration
+                    ];
+                case 6:
+                    _c.sent();
+                    // --- phone_calls ----------------------------------------------------------------------------
+                    // inbound qualifies regardless of duration
+                    return [4 /*yield*/, sdk.api.phone_calls.createOne({ enduserId: eCallInbound.id, inbound: true, userId: userId })
+                        // outbound qualifies only at >= 60 seconds
+                    ];
+                case 7:
+                    // --- phone_calls ----------------------------------------------------------------------------
+                    // inbound qualifies regardless of duration
+                    _c.sent();
+                    // outbound qualifies only at >= 60 seconds
+                    return [4 /*yield*/, sdk.api.phone_calls.createOne({
+                            enduserId: eCallLongOutbound.id, inbound: false,
+                            userId: userId,
+                            callDurationInSeconds: 60,
+                        })];
+                case 8:
+                    // outbound qualifies only at >= 60 seconds
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.phone_calls.createOne({
+                            enduserId: eCallShortOutbound.id, inbound: false,
+                            userId: userId,
+                            callDurationInSeconds: 59,
+                        })
+                        // --- chats ----------------------------------------------------------------------------------
+                    ];
+                case 9:
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.chat_rooms.createOne({ enduserIds: [eChat.id], userIds: [userId] })];
+                case 10:
+                    chatRoom = _c.sent();
+                    chatRoomIds.push(chatRoom.id);
+                    return [4 /*yield*/, sdk.api.chats.createOne({
+                            roomId: chatRoom.id, message: 'apc chat', senderId: eChat.id, enduserId: eChat.id,
+                        })
+                        // a chat with no enduserId can't be attributed to a patient
+                    ];
+                case 11:
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.chat_rooms.createOne({
+                            enduserIds: [eChatNoEnduser.id], userIds: [userId],
+                        })];
+                case 12:
+                    chatRoomNoEnduser = _c.sent();
+                    chatRoomIds.push(chatRoomNoEnduser.id);
+                    return [4 /*yield*/, sdk.api.chats.createOne({
+                            roomId: chatRoomNoEnduser.id, message: 'apc chat without enduserId', senderId: userId,
+                        })
+                        // --- form_responses -------------------------------------------------------------------------
+                    ];
+                case 13:
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.forms.createOne({ title: 'Active Patient Count Form A' })];
+                case 14:
+                    formA_1 = _c.sent();
+                    formIds.push(formA_1.id);
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: formA_1.id, type: 'string', title: 'FieldA', previousFields: [{ type: 'root', info: {} }],
+                        })];
+                case 15:
+                    fieldA = _c.sent();
+                    return [4 /*yield*/, sdk.api.forms.createOne({ title: 'Active Patient Count Form B' })];
+                case 16:
+                    formB = _c.sent();
+                    formIds.push(formB.id);
+                    return [4 /*yield*/, sdk.api.form_fields.createOne({
+                            formId: formB.id, type: 'string', title: 'FieldB', previousFields: [{ type: 'root', info: {} }],
+                        })];
+                case 17:
+                    fieldB = _c.sent();
+                    submitForm = function (formId, fieldId, fieldTitle, enduserId) { return __awaiter(void 0, void 0, void 0, function () {
+                        var accessCode;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk.api.form_responses.prepare_form_response({ enduserId: enduserId, formId: formId })];
+                                case 1:
+                                    accessCode = (_a.sent()).accessCode;
+                                    return [4 /*yield*/, sdk.api.form_responses.submit_form_response({
+                                            accessCode: accessCode,
+                                            responses: [{ fieldId: fieldId, fieldTitle: fieldTitle, answer: { type: 'string', value: 'apc' } }],
+                                        })];
+                                case 2:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); };
+                    return [4 /*yield*/, submitForm(formA_1.id, fieldA.id, 'FieldA', eForm.id)];
+                case 18:
+                    _c.sent();
+                    return [4 /*yield*/, submitForm(formB.id, fieldB.id, 'FieldB', eFormOtherForm.id)
+                        // prepared but never submitted — no submittedAt, so it must not qualify
+                    ];
+                case 19:
+                    _c.sent();
+                    // prepared but never submitted — no submittedAt, so it must not qualify
+                    return [4 /*yield*/, sdk.api.form_responses.prepare_form_response({
+                            enduserId: eFormUnsubmitted.id, formId: formA_1.id,
+                        })
+                        // --- calendar_events ------------------------------------------------------------------------
+                        // starts now, not in the future — the bounded-range case below closes the window a couple of
+                        // seconds out, and calendar_events are filtered on startTimeInMS
+                    ];
+                case 20:
+                    // prepared but never submitted — no submittedAt, so it must not qualify
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.calendar_events.createOne({
+                            title: 'apc event', durationInMinutes: 30, startTimeInMS: Date.now(),
+                            attendees: [{ id: eCalendar.id, type: 'enduser' }],
+                        })];
+                case 21:
+                    calendarEvent = _c.sent();
+                    calendarEventIds.push(calendarEvent.id);
+                    return [4 /*yield*/, sdk.api.calendar_events.createOne({
+                            title: 'apc event user only', durationInMinutes: 30, startTimeInMS: Date.now(),
+                            attendees: [{ id: userId, type: 'user' }],
+                        })];
+                case 22:
+                    calendarEventUserOnly = _c.sent();
+                    calendarEventIds.push(calendarEventUserOnly.id);
+                    return [4 /*yield*/, sdk.api.calendar_events.createOne({
+                            title: 'apc event past start', durationInMinutes: 30,
+                            startTimeInMS: Date.now() - 30 * 24 * 60 * 60 * 1000,
+                            attendees: [{ id: eCalendarPastStart.id, type: 'enduser' }],
+                        })];
+                case 23:
+                    calendarEventPastStart = _c.sent();
+                    calendarEventIds.push(calendarEventPastStart.id);
+                    return [4 /*yield*/, sdk.api.group_mms_conversations.createOne({
+                            enduserIds: [eGroupMMS.id, eGroupMMSUserSender.id], userIds: [userId], userStates: [], messages: [],
+                        })];
+                case 24:
+                    conversation = _c.sent();
+                    conversationIds.push(conversation.id);
+                    return [4 /*yield*/, sdk.api.group_mms_conversations.send_message({
+                            conversationId: conversation.id, sender: eGroupMMS.id, message: 'apc group mms', logOnly: true,
+                        })];
+                case 25:
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.wait)(undefined, 250)
+                        // sent by a user, so it counts for nobody — the other enduser in the conversation included
+                    ];
+                case 26:
+                    _c.sent();
+                    // sent by a user, so it counts for nobody — the other enduser in the conversation included
+                    return [4 /*yield*/, sdk.api.group_mms_conversations.send_message({
+                            conversationId: conversation.id, sender: userId, message: 'apc group mms from user', logOnly: true,
+                        })];
+                case 27:
+                    // sent by a user, so it counts for nobody — the other enduser in the conversation included
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.wait)(undefined, 250)
+                        // --- dedupe: one enduser active across three channels ----------------------------------------
+                    ];
+                case 28:
+                    _c.sent();
+                    // --- dedupe: one enduser active across three channels ----------------------------------------
+                    return [4 /*yield*/, sdk.api.emails.createOne({
+                            logOnly: true, inbound: true,
+                            userId: userId,
+                            enduserId: eDedupe.id, subject: 'apc dedupe', textContent: 'inbound email',
+                        })];
+                case 29:
+                    // --- dedupe: one enduser active across three channels ----------------------------------------
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.sms_messages.createOne({
+                            logOnly: true, inbound: true,
+                            userId: userId,
+                            enduserId: eDedupe.id, message: 'apc dedupe sms',
+                        })];
+                case 30:
+                    _c.sent();
+                    return [4 /*yield*/, sdk.api.chat_rooms.createOne({ enduserIds: [eDedupe.id], userIds: [userId] })];
+                case 31:
+                    dedupeRoom = _c.sent();
+                    chatRoomIds.push(dedupeRoom.id);
+                    return [4 /*yield*/, sdk.api.chats.createOne({
+                            roomId: dedupeRoom.id, message: 'apc dedupe chat', senderId: eDedupe.id, enduserId: eDedupe.id,
+                        })
+                        // --- customTypeId: excluded from the default count --------------------------------------------
+                    ];
+                case 32:
+                    _c.sent();
+                    // --- customTypeId: excluded from the default count --------------------------------------------
+                    return [4 /*yield*/, sdk.api.emails.createOne({
+                            logOnly: true, inbound: true,
+                            userId: userId,
+                            enduserId: eCustomType.id, subject: 'apc custom type', textContent: 'inbound email',
+                        })];
+                case 33:
+                    // --- customTypeId: excluded from the default count --------------------------------------------
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.wait)(undefined, 1000)
+                        // Qualifying endusers: email, sms, inbound call, long outbound call, chat, form A, form B,
+                        // calendar, group mms, dedupe = 10. eCustomType is excluded by customTypeId.
+                    ]; // let side effects settle
+                case 34:
+                    _c.sent(); // let side effects settle
+                    EXPECTED_ACTIVE_1 = 10;
+                    return [4 /*yield*/, (0, testing_1.async_test)("Active count includes exactly the qualifying endusers", function () { return onlyThisTest(); }, { onResult: function (r) { return r === EXPECTED_ACTIVE_1; } })
+                        // --- dedupe ----------------------------------------------------------------------------------
+                    ];
+                case 35:
+                    _c.sent();
+                    // --- dedupe ----------------------------------------------------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("Enduser active on email + sms + chat counts once", function () { return onlyCase('dedupe'); }, { onResult: function (r) { return r === 1; } })
+                        // --- per-channel attribution -----------------------------------------------------------------
+                    ];
+                case 36:
+                    // --- dedupe ----------------------------------------------------------------------------------
+                    _c.sent();
+                    expectActive = function (label, apcCase, expected) { return (0, testing_1.async_test)(label, function () { return onlyCase(apcCase); }, { onResult: function (r) { return r === expected; } }); };
+                    return [4 /*yield*/, expectActive("Inbound email counts", 'email', 1)];
+                case 37:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Outbound email without link opens does not count", 'email-outbound', 0)];
+                case 38:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Inbound SMS counts", 'sms', 1)];
+                case 39:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Outbound SMS does not count", 'sms-outbound', 0)];
+                case 40:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Inbound phone call counts", 'call-inbound', 1)];
+                case 41:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Outbound phone call >= 60s counts", 'call-long-outbound', 1)];
+                case 42:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Outbound phone call < 60s does not count", 'call-short-outbound', 0)];
+                case 43:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Chat with enduserId counts", 'chat', 1)];
+                case 44:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Chat without enduserId does not count", 'chat-no-enduserid', 0)];
+                case 45:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Submitted form response counts", 'form', 1)];
+                case 46:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Unsubmitted form response does not count", 'form-unsubmitted', 0)];
+                case 47:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Calendar event with enduser attendee counts", 'calendar', 1)];
+                case 48:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Calendar event with only user attendees does not count", 'calendar-user-only', 0)];
+                case 49:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Inbound group MMS counts", 'group-mms', 1)];
+                case 50:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Group MMS sent by a user does not count", 'group-mms-user-sender', 0)];
+                case 51:
+                    _c.sent();
+                    return [4 /*yield*/, expectActive("Enduser with no engagement does not count", 'inactive', 0)
+                        // --- date field per collection ----------------------------------------------------------------
+                    ];
+                case 52:
+                    _c.sent();
+                    // --- date field per collection ----------------------------------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("Calendar event is filtered by startTimeInMS, not creation time", function () { return onlyCase('calendar-past-start'); }, { onResult: function (r) { return r === 0; } })
+                        // --- range boundaries -------------------------------------------------------------------------
+                    ];
+                case 53:
+                    // --- date field per collection ----------------------------------------------------------------
+                    _c.sent();
+                    afterAll_1 = new Date(Date.now() + 2000);
+                    return [4 /*yield*/, (0, testing_1.async_test)("Active count is unchanged with an explicit upper bound after all activity", function () { return sdk.api.endusers.get_engagement_statistics({
+                            range: { from: windowStart, to: afterAll_1 },
+                            enduserFields: [{ field: 'fields.apcCase', value: '$exists' }],
+                        }).then(function (r) { return r.count; }); }, { onResult: function (r) { return r === EXPECTED_ACTIVE_1; } })];
+                case 54:
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("Active count is 0 for a range that starts after all activity", function () { return sdk.api.endusers.get_engagement_statistics({ range: { from: afterAll_1 } }).then(function (r) { return r.count; }); }, { onResult: function (r) { return r === 0; } })];
+                case 55:
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("Active count is 0 for a range that ends before all activity", function () { return sdk.api.endusers.get_engagement_statistics({
+                            range: { from: new Date(windowStart.getTime() - 4000), to: windowStart },
+                            enduserFields: [{ field: 'fields.apcCase', value: '$exists' }],
+                        }).then(function (r) { return r.count; }); }, { onResult: function (r) { return r === 0; } })
+                        // --- customTypeId ------------------------------------------------------------------------------
+                    ];
+                case 56:
+                    _c.sent();
+                    // --- customTypeId ------------------------------------------------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("Endusers with a customTypeId are excluded by default", function () { return onlyCase('custom-type'); }, { onResult: function (r) { return r === 0; } })];
+                case 57:
+                    // --- customTypeId ------------------------------------------------------------------------------
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("Endusers with a customTypeId are included when that customTypeId is requested", function () { return activeCount({ customTypeId: TEST_CUSTOM_TYPE_ID }); }, { onResult: function (r) { return r === 1; } })
+                        // --- formIds ------------------------------------------------------------------------------------
+                    ];
+                case 58:
+                    _c.sent();
+                    // --- formIds ------------------------------------------------------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("formIds narrows which form responses qualify", function () { return onlyThisTest({ formIds: [formA_1.id] }); }, { onResult: function (r) { return r === EXPECTED_ACTIVE_1 - 1; } } // drops the enduser who only submitted form B
+                        )
+                        // --- endusersFilter (a separate code path from enduserFields) -------------------------------------
+                    ];
+                case 59:
+                    // --- formIds ------------------------------------------------------------------------------------
+                    _c.sent();
+                    // --- endusersFilter (a separate code path from enduserFields) -------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("endusersFilter narrows the counted endusers", function () { return activeCount({ endusersFilter: { 'fields.apcCase': 'email' } }); }, { onResult: function (r) { return r === 1; } })
+                        // --- enduserFields -------------------------------------------------------------------------------
+                    ];
+                case 60:
+                    // --- endusersFilter (a separate code path from enduserFields) -------------------------------------
+                    _c.sent();
+                    // --- enduserFields -------------------------------------------------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("enduserFields matches on a stored field value", function () { return activeCount({ enduserFields: [{ field: 'fields.apcTag', value: 'yes' }] }); }, { onResult: function (r) { return r === 3; } } // email, sms, dedupe
+                        )];
+                case 61:
+                    // --- enduserFields -------------------------------------------------------------------------------
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("enduserFields supports the $exists qualifier", function () { return activeCount({ enduserFields: [{ field: 'fields.apcGroup', value: '$exists' }] }); }, { onResult: function (r) { return r === EXPECTED_ACTIVE_1 - 1; } } // all active endusers except apc-calendar
+                        )
+                        // --- groupBy ---------------------------------------------------------------------------------------
+                    ];
+                case 62:
+                    _c.sent();
+                    // --- groupBy ---------------------------------------------------------------------------------------
+                    return [4 /*yield*/, (0, testing_1.async_test)("groupBy returns per-group counts summing to the total", function () { return sdk.api.endusers.get_engagement_statistics({
+                            range: { from: windowStart }, groupBy: 'fields.apcGroup',
+                            enduserFields: [{ field: 'fields.apcCase', value: '$exists' }],
+                        }); }, {
+                            onResult: function (r) { return (Array.isArray(r.grouped)
+                                && r.grouped.reduce(function (sum, g) { return sum + g.count; }, 0) === EXPECTED_ACTIVE_1); }
+                        })
+                        // --- endusers cannot read org-wide staff analytics ------------------------------------------------
+                    ];
+                case 63:
+                    // --- groupBy ---------------------------------------------------------------------------------------
+                    _c.sent();
+                    enduserSDK_1 = new sdk_1.EnduserSession({ host: host, businessId: businessId });
+                    return [4 /*yield*/, (0, setup_1.authenticate_enduser_via_token)(sdk, enduserSDK_1, { id: eEmail.id })];
+                case 64:
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("Endusers cannot call get_engagement_statistics", function () { return enduserSDK_1._GET('/v1/endusers/engagement', { range: { from: windowStart } }); }, testing_1.handleAnyError)
+                        // --- tenant isolation --------------------------------------------------------------------------------
+                        // The refactor drops restrictAccess in favor of a direct businessId match, so this is the one
+                        // boundary the function now enforces entirely on its own.
+                    ];
+                case 65:
+                    _c.sent();
+                    sdkOther_1 = new sdk_1.Session({ host: host, apiKey: OTHER_TENANT_API_KEY });
+                    otherWindowStart_1 = new Date(Date.now() - 2000);
+                    return [4 /*yield*/, sdkOther_1.api.endusers.createOne({ fname: 'apc-other-tenant' })];
+                case 66:
+                    otherEnduser = _c.sent();
+                    _c.label = 67;
+                case 67:
+                    _c.trys.push([67, , 72, 74]);
+                    // userId is left to its session initializer — this is an API-key session with no logged-in user
+                    return [4 /*yield*/, sdkOther_1.api.emails.createOne({
+                            logOnly: true, inbound: true,
+                            enduserId: otherEnduser.id, subject: 'apc other tenant', textContent: 'inbound email',
+                        })];
+                case 68:
+                    // userId is left to its session initializer — this is an API-key session with no logged-in user
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.wait)(undefined, 500)];
+                case 69:
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("Other tenant's engagement does not appear in this tenant's count", function () { return onlyThisTest(); }, { onResult: function (r) { return r === EXPECTED_ACTIVE_1; } })];
+                case 70:
+                    _c.sent();
+                    return [4 /*yield*/, (0, testing_1.async_test)("This tenant's engagement does not appear in the other tenant's count", function () { return sdkOther_1.api.endusers.get_engagement_statistics({ range: { from: otherWindowStart_1 } })
+                            .then(function (r) { return r.count; }); }, { onResult: function (r) { return r === 1; } })];
+                case 71:
+                    _c.sent();
+                    return [3 /*break*/, 74];
+                case 72: return [4 /*yield*/, sdkOther_1.api.endusers.deleteOne(otherEnduser.id).catch(console.error)];
+                case 73:
+                    _c.sent();
+                    return [7 /*endfinally*/];
+                case 74: return [3 /*break*/, 77];
+                case 75: return [4 /*yield*/, Promise.all(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], createdEnduserIds.map(function (id) { return sdk.api.endusers.deleteOne(id).catch(console.error); }), true), chatRoomIds.map(function (id) { return sdk.api.chat_rooms.deleteOne(id).catch(console.error); }), true), conversationIds.map(function (id) { return sdk.api.group_mms_conversations.deleteOne(id).catch(console.error); }), true), calendarEventIds.map(function (id) { return sdk.api.calendar_events.deleteOne(id).catch(console.error); }), true), formIds.map(function (id) { return sdk.api.forms.deleteOne(id).catch(console.error); }), true))];
+                case 76:
+                    _c.sent();
+                    return [7 /*endfinally*/];
+                case 77: return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.active_patient_count_tests = active_patient_count_tests;
+// Allow running this test file independently
+if (require.main === module) {
+    var sdk_2 = new sdk_1.Session({ host: host });
+    var sdkNonAdmin_1 = new sdk_1.Session({ host: host });
+    var runTests = function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, setup_1.setup_tests)(sdk_2, sdkNonAdmin_1)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, exports.active_patient_count_tests)({ sdk: sdk_2, sdkNonAdmin: sdkNonAdmin_1 })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    runTests()
+        .then(function () {
+        console.log("✅ Active patient count test suite completed successfully");
+        process.exit(0);
+    })
+        .catch(function (error) {
+        console.error("❌ Active patient count test suite failed:", error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=active_patient_count.test.js.map