@tellescope/sdk 2.0.0-beta.1 → 2.0.0-beta.3

package/lib/esm/tests/api_tests/mdb_sort.test.js

@@ -34,326 +34,381 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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));
-};
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { assert, async_test, log_header, } from "@tellescope/testing";
-import { setup_tests } from "../setup";
+import { assert_checks, setup_isolated_tenant, } from "../setup_isolated";
 var host = process.env.API_URL || 'http://localhost:8080';
-// Main test function that can be called independently
-export var mdb_sort_tests = function (_a) {
-    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var testEndusers, enduserIds, _i, enduserIds_1, enduserId, error_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    log_header("mdbSort Custom Sorting Support");
-                    return [4 /*yield*/, Promise.all([
-                            sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Smith', email: 'alice-mdbsort@tellescope.com' }),
-                            sdk.api.endusers.createOne({ fname: 'Bob', lname: 'Jones', email: 'bob-mdbsort@tellescope.com' }),
-                            sdk.api.endusers.createOne({ fname: 'Charlie', lname: 'Adams', email: 'charlie-mdbsort@tellescope.com' }),
-                            sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Zeta', email: 'alice2-mdbsort@tellescope.com' }), // Same fname for multi-field test
-                        ])];
-                case 1:
-                    testEndusers = _b.sent();
-                    enduserIds = testEndusers.map(function (e) { return e.id; });
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, , 11, 18]);
-                    // Test 1: Sort by fname ascending (alphabetical order)
-                    return [4 /*yield*/, async_test('mdbSort-fname-ascending', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            filter: { id: { _in: enduserIds } },
-                                            mdbSort: { fname: 1 },
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 4, 'Expected 4 endusers', "Got ".concat(results.length));
-                                        // Verify alphabetical order: Alice, Alice, Bob, Charlie
-                                        assert(results[0].fname === 'Alice', 'First should be Alice');
-                                        assert(results[1].fname === 'Alice', 'Second should be Alice');
-                                        assert(results[2].fname === 'Bob', 'Third should be Bob');
-                                        assert(results[3].fname === 'Charlie', 'Fourth should be Charlie');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 2: Sort by fname descending (reverse alphabetical order)
-                    ];
-                case 3:
-                    // Test 1: Sort by fname ascending (alphabetical order)
-                    _b.sent();
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
+var ALICE_EMAIL = 'alice-mdbsort@tellescope.com';
+var ALICE2_EMAIL = 'alice2-mdbsort@tellescope.com';
+var BOB_EMAIL = 'bob-mdbsort@tellescope.com';
+var CHARLIE_EMAIL = 'charlie-mdbsort@tellescope.com';
+/**
+ * getSome `mdbSort` coverage: ascending, descending, multi-field tie-breaking, combined with
+ * mdbFilter, keyset pagination through mdbFilter $or, combined with projection, for a non-admin
+ * session, and the fallback to sortBy when mdbSort is absent.
+ *
+ * Runs on its own provisioned tenant. The mdbFilter checks (tests 4 and 5) query by email with NO id
+ * scoping — `filter` is ignored when mdbFilter is present — so on the shared fixture org any leftover
+ * *-mdbsort@tellescope.com enduser from an earlier run silently changed the counts and the ordering.
+ * On a disposable tenant those four fixed addresses are unambiguous.
+ *
+ * Each former async_test's nested `assert` calls became one Check each: `assert` calls process.exit,
+ * which inside a pooled `run` would skip every concurrently running suite's teardown and strand its
+ * tenant permanently.
+ */
+export var mdb_sort_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, describe, errorMessage, names, step, tenant, sdk_1, sdkNonAdmin_1, careTeam, testEndusers, enduserIds_1, e_1, e_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                checks = [];
+                record = function (label, pass, detail) { return checks.push({ label: label, pass: pass, detail: detail }); };
+                describe = function (value) {
+                    if (value === undefined || value === null)
+                        return String(value);
+                    var stringified = JSON.stringify(value);
+                    return stringified === undefined ? String(value) : stringified;
+                };
+                errorMessage = function (e) { return (typeof (e === null || e === void 0 ? void 0 : e.message) === 'string' && e.message !== '' ? e.message : describe(e)); };
+                names = function (results) { return (describe(results.map(function (e) { return "".concat(e.fname, " ").concat(e.lname); }))); };
+                step = function (name, body) { return __awaiter(void 0, void 0, void 0, function () {
+                    var e_3;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, body()];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_3 = _a.sent();
+                                record("".concat(name, ": block ran to completion"), false, "threw: ".concat(errorMessage(e_3)));
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); };
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 15, 20]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "mdbSort ".concat(RAND()),
+                        users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _a.sent();
+                sdk_1 = tenant.sdk, sdkNonAdmin_1 = tenant.sdkNonAdmin;
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 13, , 14]);
+                careTeam = [tenant.users[1].id];
+                return [4 /*yield*/, Promise.all([
+                        sdk_1.api.endusers.createOne({ fname: 'Alice', lname: 'Smith', email: ALICE_EMAIL, assignedTo: careTeam }),
+                        sdk_1.api.endusers.createOne({ fname: 'Bob', lname: 'Jones', email: BOB_EMAIL, assignedTo: careTeam }),
+                        sdk_1.api.endusers.createOne({ fname: 'Charlie', lname: 'Adams', email: CHARLIE_EMAIL, assignedTo: careTeam }),
+                        sdk_1.api.endusers.createOne({ fname: 'Alice', lname: 'Zeta', email: ALICE2_EMAIL, assignedTo: careTeam }), // Same fname for multi-field test
+                    ])];
+            case 4:
+                testEndusers = _a.sent();
+                enduserIds_1 = testEndusers.map(function (e) { return e.id; });
+                // Test 1: Sort by fname ascending (alphabetical order)
+                return [4 /*yield*/, step('mdbSort-fname-ascending', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        var _a, _b, _c, _d;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        filter: { id: { _in: enduserIds_1 } },
+                                        mdbSort: { fname: 1 },
+                                    })];
+                                case 1:
+                                    results = _e.sent();
+                                    record('mdbSort-fname-ascending: Expected 4 endusers', results.length === 4, "Got ".concat(results.length));
+                                    // Verify alphabetical order: Alice, Alice, Bob, Charlie
+                                    record('mdbSort-fname-ascending: First should be Alice', ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fname) === 'Alice', names(results));
+                                    record('mdbSort-fname-ascending: Second should be Alice', ((_b = results[1]) === null || _b === void 0 ? void 0 : _b.fname) === 'Alice', names(results));
+                                    record('mdbSort-fname-ascending: Third should be Bob', ((_c = results[2]) === null || _c === void 0 ? void 0 : _c.fname) === 'Bob', names(results));
+                                    record('mdbSort-fname-ascending: Fourth should be Charlie', ((_d = results[3]) === null || _d === void 0 ? void 0 : _d.fname) === 'Charlie', names(results));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 2: Sort by fname descending (reverse alphabetical order)
-                    return [4 /*yield*/, async_test('mdbSort-fname-descending', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            filter: { id: { _in: enduserIds } },
-                                            mdbSort: { fname: -1 },
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 4, 'Expected 4 endusers');
-                                        // Verify reverse alphabetical order: Charlie, Bob, Alice, Alice
-                                        assert(results[0].fname === 'Charlie', 'First should be Charlie');
-                                        assert(results[1].fname === 'Bob', 'Second should be Bob');
-                                        assert(results[2].fname === 'Alice', 'Third should be Alice');
-                                        assert(results[3].fname === 'Alice', 'Fourth should be Alice');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
-                    ];
-                case 4:
-                    // Test 2: Sort by fname descending (reverse alphabetical order)
-                    _b.sent();
-                    // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
-                    return [4 /*yield*/, async_test('mdbSort-multi-field', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            filter: { id: { _in: enduserIds } },
-                                            mdbSort: { fname: 1, lname: 1 },
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 4, 'Expected 4 endusers');
-                                        // Verify multi-field sort:
-                                        // Alice Smith (fname: Alice, lname: Smith)
-                                        // Alice Zeta  (fname: Alice, lname: Zeta)
-                                        // Bob Jones   (fname: Bob)
-                                        // Charlie Adams (fname: Charlie)
-                                        assert(results[0].fname === 'Alice' && results[0].lname === 'Smith', 'First should be Alice Smith');
-                                        assert(results[1].fname === 'Alice' && results[1].lname === 'Zeta', 'Second should be Alice Zeta');
-                                        assert(results[2].fname === 'Bob', 'Third should be Bob');
-                                        assert(results[3].fname === 'Charlie', 'Fourth should be Charlie');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 4: mdbSort combined with mdbFilter
-                    ];
-                case 5:
+                ];
+            case 5:
+                // Test 1: Sort by fname ascending (alphabetical order)
+                _a.sent();
+                // Test 2: Sort by fname descending (reverse alphabetical order)
+                return [4 /*yield*/, step('mdbSort-fname-descending', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        var _a, _b, _c, _d;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        filter: { id: { _in: enduserIds_1 } },
+                                        mdbSort: { fname: -1 },
+                                    })];
+                                case 1:
+                                    results = _e.sent();
+                                    record('mdbSort-fname-descending: Expected 4 endusers', results.length === 4, "Got ".concat(results.length));
+                                    // Verify reverse alphabetical order: Charlie, Bob, Alice, Alice
+                                    record('mdbSort-fname-descending: First should be Charlie', ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fname) === 'Charlie', names(results));
+                                    record('mdbSort-fname-descending: Second should be Bob', ((_b = results[1]) === null || _b === void 0 ? void 0 : _b.fname) === 'Bob', names(results));
+                                    record('mdbSort-fname-descending: Third should be Alice', ((_c = results[2]) === null || _c === void 0 ? void 0 : _c.fname) === 'Alice', names(results));
+                                    record('mdbSort-fname-descending: Fourth should be Alice', ((_d = results[3]) === null || _d === void 0 ? void 0 : _d.fname) === 'Alice', names(results));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
-                    _b.sent();
+                ];
+            case 6:
+                // Test 2: Sort by fname descending (reverse alphabetical order)
+                _a.sent();
+                // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
+                return [4 /*yield*/, step('mdbSort-multi-field', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        var _a, _b, _c, _d, _e, _f;
+                        return __generator(this, function (_g) {
+                            switch (_g.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        filter: { id: { _in: enduserIds_1 } },
+                                        mdbSort: { fname: 1, lname: 1 },
+                                    })];
+                                case 1:
+                                    results = _g.sent();
+                                    record('mdbSort-multi-field: Expected 4 endusers', results.length === 4, "Got ".concat(results.length));
+                                    // Verify multi-field sort:
+                                    // Alice Smith (fname: Alice, lname: Smith)
+                                    // Alice Zeta  (fname: Alice, lname: Zeta)
+                                    // Bob Jones   (fname: Bob)
+                                    // Charlie Adams (fname: Charlie)
+                                    record('mdbSort-multi-field: First should be Alice Smith', ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fname) === 'Alice' && ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.lname) === 'Smith', names(results));
+                                    record('mdbSort-multi-field: Second should be Alice Zeta', ((_c = results[1]) === null || _c === void 0 ? void 0 : _c.fname) === 'Alice' && ((_d = results[1]) === null || _d === void 0 ? void 0 : _d.lname) === 'Zeta', names(results));
+                                    record('mdbSort-multi-field: Third should be Bob', ((_e = results[2]) === null || _e === void 0 ? void 0 : _e.fname) === 'Bob', names(results));
+                                    record('mdbSort-multi-field: Fourth should be Charlie', ((_f = results[3]) === null || _f === void 0 ? void 0 : _f.fname) === 'Charlie', names(results));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 4: mdbSort combined with mdbFilter
-                    return [4 /*yield*/, async_test('mdbSort-with-mdbFilter', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            mdbFilter: {
-                                                email: { $in: ['alice-mdbsort@tellescope.com', 'alice2-mdbsort@tellescope.com'] },
-                                                fname: 'Alice', // Only get Alice endusers
-                                            },
-                                            mdbSort: { lname: 1 }, // Sort by last name
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 2, 'Expected 2 Alice endusers', "Got ".concat(results.length));
-                                        // Verify both are Alice and sorted by lname: Smith, then Zeta
-                                        assert(results[0].fname === 'Alice' && results[0].lname === 'Smith', 'First Alice should be Smith');
-                                        assert(results[1].fname === 'Alice' && results[1].lname === 'Zeta', 'Second Alice should be Zeta');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 5: mdbSort keyset pagination via mdbFilter $or
-                        // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
-                        // must be expressed in mdbFilter.
-                    ];
-                case 6:
-                    // Test 4: mdbSort combined with mdbFilter
-                    _b.sent();
+                ];
+            case 7:
+                // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
+                _a.sent();
+                // Test 4: mdbSort combined with mdbFilter
+                return [4 /*yield*/, step('mdbSort-with-mdbFilter', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        var _a, _b, _c, _d;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        mdbFilter: {
+                                            email: { $in: [ALICE_EMAIL, ALICE2_EMAIL] },
+                                            fname: 'Alice', // Only get Alice endusers
+                                        },
+                                        mdbSort: { lname: 1 }, // Sort by last name
+                                    })];
+                                case 1:
+                                    results = _e.sent();
+                                    record('mdbSort-with-mdbFilter: Expected 2 Alice endusers', results.length === 2, "Got ".concat(results.length));
+                                    // Verify both are Alice and sorted by lname: Smith, then Zeta
+                                    record('mdbSort-with-mdbFilter: First Alice should be Smith', ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fname) === 'Alice' && ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.lname) === 'Smith', names(results));
+                                    record('mdbSort-with-mdbFilter: Second Alice should be Zeta', ((_c = results[1]) === null || _c === void 0 ? void 0 : _c.fname) === 'Alice' && ((_d = results[1]) === null || _d === void 0 ? void 0 : _d.lname) === 'Zeta', names(results));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 5: mdbSort keyset pagination via mdbFilter $or
                     // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
                     // must be expressed in mdbFilter.
-                    return [4 /*yield*/, async_test('mdbSort-keyset-pagination', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var testEmails, page1, lastFname, page2;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        testEmails = [
-                                            'alice-mdbsort@tellescope.com',
-                                            'alice2-mdbsort@tellescope.com',
-                                            'bob-mdbsort@tellescope.com',
-                                            'charlie-mdbsort@tellescope.com',
-                                        ];
-                                        return [4 /*yield*/, sdk.api.endusers.getSome({
-                                                mdbFilter: { email: { $in: testEmails } },
-                                                mdbSort: { fname: 1 },
-                                                limit: 2,
-                                            })];
-                                    case 1:
-                                        page1 = _a.sent();
-                                        assert(page1.length === 2, 'Expected 2 endusers on page 1');
-                                        assert(page1[0].fname === 'Alice', 'Page 1 first should be Alice');
-                                        assert(page1[1].fname === 'Alice', 'Page 1 second should be Alice');
-                                        lastFname = page1[page1.length - 1].fname;
-                                        return [4 /*yield*/, sdk.api.endusers.getSome({
-                                                mdbFilter: {
-                                                    email: { $in: testEmails },
-                                                    fname: { $gt: lastFname },
-                                                },
-                                                mdbSort: { fname: 1 },
-                                                limit: 2,
-                                            })];
-                                    case 2:
-                                        page2 = _a.sent();
-                                        assert(page2.length === 2, 'Expected 2 endusers on page 2');
-                                        assert(page2[0].fname === 'Bob', 'Page 2 first should be Bob');
-                                        assert(page2[1].fname === 'Charlie', 'Page 2 second should be Charlie');
-                                        return [2 /*return*/, __spreadArray(__spreadArray([], page1, true), page2, true)];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 6: mdbSort with projection (ensure both work together)
-                    ];
-                case 7:
-                    // Test 5: mdbSort keyset pagination via mdbFilter $or
-                    // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
-                    // must be expressed in mdbFilter.
-                    _b.sent();
-                    // Test 6: mdbSort with projection (ensure both work together)
-                    return [4 /*yield*/, async_test('mdbSort-with-projection', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            filter: { id: { _in: enduserIds } },
-                                            mdbSort: { fname: -1 },
-                                            projection: { fname: 1, lname: 1 },
+                ];
+            case 8:
+                // Test 4: mdbSort combined with mdbFilter
+                _a.sent();
+                // Test 5: mdbSort keyset pagination via mdbFilter $or
+                // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
+                // must be expressed in mdbFilter.
+                return [4 /*yield*/, step('mdbSort-keyset-pagination', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var testEmails, page1, lastFname, page2;
+                        var _a, _b, _c, _d, _e;
+                        return __generator(this, function (_f) {
+                            switch (_f.label) {
+                                case 0:
+                                    testEmails = [
+                                        ALICE_EMAIL,
+                                        ALICE2_EMAIL,
+                                        BOB_EMAIL,
+                                        CHARLIE_EMAIL,
+                                    ];
+                                    return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                            mdbFilter: { email: { $in: testEmails } },
+                                            mdbSort: { fname: 1 },
+                                            limit: 2,
                                         })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 4, 'Expected 4 endusers');
-                                        // Verify sort order (descending)
-                                        assert(results[0].fname === 'Charlie', 'First should be Charlie');
-                                        // Verify projection (only fname, lname, plus id and createdAt)
-                                        assert(results[0].fname !== undefined, 'fname should be present');
-                                        assert(results[0].lname !== undefined, 'lname should be present');
-                                        assert(results[0].email === undefined, 'email should NOT be present');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 7: Non-admin access with mdbSort (RBA still applies)
-                    ];
-                case 8:
-                    // Test 6: mdbSort with projection (ensure both work together)
-                    _b.sent();
-                    // Test 7: Non-admin access with mdbSort (RBA still applies)
-                    return [4 /*yield*/, async_test('non-admin-mdbSort', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, fnames;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdkNonAdmin.api.endusers.getSome({
-                                            filter: { id: { _in: enduserIds } },
+                                case 1:
+                                    page1 = _f.sent();
+                                    record('mdbSort-keyset-pagination: Expected 2 endusers on page 1', page1.length === 2, "Got ".concat(page1.length));
+                                    record('mdbSort-keyset-pagination: Page 1 first should be Alice', ((_a = page1[0]) === null || _a === void 0 ? void 0 : _a.fname) === 'Alice', names(page1));
+                                    record('mdbSort-keyset-pagination: Page 1 second should be Alice', ((_b = page1[1]) === null || _b === void 0 ? void 0 : _b.fname) === 'Alice', names(page1));
+                                    lastFname = (_c = page1[page1.length - 1]) === null || _c === void 0 ? void 0 : _c.fname;
+                                    return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                            mdbFilter: {
+                                                email: { $in: testEmails },
+                                                fname: { $gt: lastFname },
+                                            },
                                             mdbSort: { fname: 1 },
-                                        })
-                                        // Non-admin should still get results (RBA should apply)
-                                    ];
-                                    case 1:
-                                        results = _a.sent();
-                                        // Non-admin should still get results (RBA should apply)
-                                        assert(Array.isArray(results), 'Non-admin should receive an array response');
-                                        // Verify sort order
-                                        if (results.length >= 2) {
-                                            fnames = results.map(function (e) { return e.fname; });
-                                            // Should be sorted alphabetically
-                                            assert(fnames[0] <= fnames[1], 'Non-admin results should be sorted');
-                                        }
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
-                    ];
-                case 9:
-                    // Test 7: Non-admin access with mdbSort (RBA still applies)
-                    _b.sent();
-                    // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
-                    return [4 /*yield*/, async_test('no-mdbSort-fallback', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            filter: { id: { _in: enduserIds } },
-                                            sortBy: 'updatedAt',
-                                            sort: 'oldFirst',
+                                            limit: 2,
                                         })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 4, 'Expected 4 endusers');
-                                        // Verify traditional sortBy still works when mdbSort not provided
-                                        assert(results[0].id !== undefined, 'Should return valid endusers');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })];
-                case 10:
+                                case 2:
+                                    page2 = _f.sent();
+                                    record('mdbSort-keyset-pagination: Expected 2 endusers on page 2', page2.length === 2, "Got ".concat(page2.length, " (cursor fname > ").concat(describe(lastFname), ")"));
+                                    record('mdbSort-keyset-pagination: Page 2 first should be Bob', ((_d = page2[0]) === null || _d === void 0 ? void 0 : _d.fname) === 'Bob', names(page2));
+                                    record('mdbSort-keyset-pagination: Page 2 second should be Charlie', ((_e = page2[1]) === null || _e === void 0 ? void 0 : _e.fname) === 'Charlie', names(page2));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
+                    // Test 6: mdbSort with projection (ensure both work together)
+                ];
+            case 9:
+                // Test 5: mdbSort keyset pagination via mdbFilter $or
+                // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
+                // must be expressed in mdbFilter.
+                _a.sent();
+                // Test 6: mdbSort with projection (ensure both work together)
+                return [4 /*yield*/, step('mdbSort-with-projection', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        var _a, _b, _c, _d, _e, _f, _g;
+                        return __generator(this, function (_h) {
+                            switch (_h.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        filter: { id: { _in: enduserIds_1 } },
+                                        mdbSort: { fname: -1 },
+                                        projection: { fname: 1, lname: 1 },
+                                    })];
+                                case 1:
+                                    results = _h.sent();
+                                    record('mdbSort-with-projection: Expected 4 endusers', results.length === 4, "Got ".concat(results.length));
+                                    // Verify sort order (descending)
+                                    record('mdbSort-with-projection: First should be Charlie', ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fname) === 'Charlie', names(results));
+                                    // Verify projection (only fname, lname, plus id and createdAt)
+                                    record('mdbSort-with-projection: fname should be present', ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.fname) !== undefined, "fname=".concat(describe((_c = results[0]) === null || _c === void 0 ? void 0 : _c.fname)));
+                                    record('mdbSort-with-projection: lname should be present', ((_d = results[0]) === null || _d === void 0 ? void 0 : _d.lname) !== undefined, "lname=".concat(describe((_e = results[0]) === null || _e === void 0 ? void 0 : _e.lname)));
+                                    record('mdbSort-with-projection: email should NOT be present', ((_f = results[0]) === null || _f === void 0 ? void 0 : _f.email) === undefined, "email=".concat(describe((_g = results[0]) === null || _g === void 0 ? void 0 : _g.email)));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
+                    // Test 7: Non-admin access with mdbSort (RBA still applies)
+                ];
+            case 10:
+                // Test 6: mdbSort with projection (ensure both work together)
+                _a.sent();
+                // Test 7: Non-admin access with mdbSort (RBA still applies)
+                return [4 /*yield*/, step('non-admin-mdbSort', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results, fnames;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdkNonAdmin_1.api.endusers.getSome({
+                                        filter: { id: { _in: enduserIds_1 } },
+                                        mdbSort: { fname: 1 },
+                                    })
+                                    // Non-admin should still get results (RBA should apply)
+                                ];
+                                case 1:
+                                    results = _a.sent();
+                                    // Non-admin should still get results (RBA should apply)
+                                    record('non-admin-mdbSort: Non-admin should receive an array response', Array.isArray(results), "results=".concat(describe(results.map(function (e) { return e.id; }))));
+                                    fnames = results.map(function (e) { return e.fname; });
+                                    record('non-admin-mdbSort: Non-admin results should be sorted', results.length >= 2 && fnames[0] <= fnames[1], "fnames=".concat(describe(fnames)));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
-                    _b.sent();
-                    return [3 /*break*/, 18];
-                case 11:
-                    _b.trys.push([11, 16, , 17]);
-                    _i = 0, enduserIds_1 = enduserIds;
-                    _b.label = 12;
-                case 12:
-                    if (!(_i < enduserIds_1.length)) return [3 /*break*/, 15];
-                    enduserId = enduserIds_1[_i];
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserId)];
-                case 13:
-                    _b.sent();
-                    _b.label = 14;
-                case 14:
-                    _i++;
-                    return [3 /*break*/, 12];
-                case 15: return [3 /*break*/, 17];
-                case 16:
-                    error_1 = _b.sent();
-                    console.error('Cleanup error:', error_1);
-                    return [3 /*break*/, 17];
-                case 17: return [7 /*endfinally*/];
-                case 18: return [2 /*return*/];
-            }
-        });
+                ];
+            case 11:
+                // Test 7: Non-admin access with mdbSort (RBA still applies)
+                _a.sent();
+                // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
+                return [4 /*yield*/, step('no-mdbSort-fallback', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        filter: { id: { _in: enduserIds_1 } },
+                                        sortBy: 'updatedAt',
+                                        sort: 'oldFirst',
+                                    })];
+                                case 1:
+                                    results = _b.sent();
+                                    record('no-mdbSort-fallback: Expected 4 endusers', results.length === 4, "Got ".concat(results.length));
+                                    // Verify traditional sortBy still works when mdbSort not provided
+                                    record('no-mdbSort-fallback: Should return valid endusers', ((_a = results[0]) === null || _a === void 0 ? void 0 : _a.id) !== undefined, "ids=".concat(describe(results.map(function (e) { return e.id; }))));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
+                    // The shared-org version deleted its endusers here. Teardown discards the whole tenant, so the
+                    // records go with it.
+                ];
+            case 12:
+                // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
+                _a.sent();
+                return [3 /*break*/, 14];
+            case 13:
+                e_1 = _a.sent();
+                // A fixture write outside a step threw. Record it rather than letting it escape `run`, which
+                // would fail every other suite in the batch instead of just this one.
+                record('mdbSort suite ran to completion', false, "threw: ".concat(errorMessage(e_1)));
+                return [3 /*break*/, 14];
+            case 14: return [3 /*break*/, 20];
+            case 15:
+                if (!tenant) return [3 /*break*/, 19];
+                _a.label = 16;
+            case 16:
+                _a.trys.push([16, 18, , 19]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 17:
+                _a.sent();
+                return [3 /*break*/, 19];
+            case 18:
+                e_2 = _a.sent();
+                console.error('teardown failed', e_2);
+                return [3 /*break*/, 19];
+            case 19: return [7 /*endfinally*/];
+            case 20: return [2 /*return*/, checks];
+        }
+    });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var mdb_sort_tests = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = assert_checks;
+                _b = ['mdbSort'];
+                return [4 /*yield*/, mdb_sort_checks()];
+            case 1:
+                _a.apply(void 0, _b.concat([_c.sent()]));
+                return [2 /*return*/];
+        }
     });
+}); };
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export var ISOLATED_SUITE = {
+    name: 'mdbSort',
+    run: mdb_sort_checks,
 };
 // Allow running this test file independently
 if (require.main === module) {
     console.log("\uD83C\uDF10 Using API URL: ".concat(host));
-    var sdk_1 = new Session({ host: host });
-    var sdkNonAdmin_1 = new 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*/, setup_tests(sdk_1, sdkNonAdmin_1)];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, mdb_sort_tests({ sdk: sdk_1, sdkNonAdmin: sdkNonAdmin_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    mdb_sort_tests()
         .then(function () {
         console.log("✅ mdbSort test suite completed successfully");
         process.exit(0);