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

package/src/tests/api_tests/vitl_push.test.ts

@@ -0,0 +1,323 @@
+require('source-map-support').install();
+
+import axios from "axios"
+
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
+import { VITL_TITLE } from "@tellescope/constants"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+/**
+ * VITL eRx patient push — endpoint-level coverage (CU-86e3cua4p).
+ *
+ * Everything here is verifiable WITHOUT reaching the real vendor, which matters because the payload is
+ * patient PHI and the only endpoint we have is a live tenant webhook. The connected case points at a
+ * host in the reserved `.invalid` TLD, so DNS never resolves and no data leaves the machine — but the
+ * request is attempted, which is exactly what makes the failure path assertable.
+ *
+ * What this locks:
+ *   A. an org that has NOT connected VITL cannot push at all, and writes no integration_logs row (the
+ *      PHI-egress gate — QA step 12)
+ *   B. a patient missing a required field fails PRE-FLIGHT: the error names the field AND no
+ *      integration_logs row is written, proving no request was sent (QA step 9)
+ *   C. a complete patient produces an Error row whose stored payload has dateOfBirth in YYYY-MM-DD,
+ *      uid == the enduser id, no gender key for an unmappable gender, and no trace of the shared
+ *      secret anywhere in the row (QA steps 5, 6, 8, 10)
+ *   D. a failed push writes nothing to the enduser — no lastVITLSyncAt, no VITL reference (QA step 10)
+ *   E. the pushVITLPatient journey action reaches the same code path (QA step 11) — the automation step
+ *      round-trips through validation, and automated_actions.process runs the VITL branch rather than
+ *      falling through to `unimplemented`
+ *
+ * The 2xx path (QA steps 4 and 7) needs real VITL credentials and stays manual.
+ */
+
+// Reserved TLD (RFC 2606): guaranteed never to resolve, so the push fails at connect time.
+const UNREACHABLE_WEBHOOK_URL = 'https://vitl-push-test.invalid/api/webhooks/test'
+const SHARED_SECRET = 'vitl-shared-secret-must-never-be-logged'
+
+export const vitl_push_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let provisioned: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  const push = async (enduserId: string) => {
+    try {
+      const result = await provisioned!.sdk.api.endusers.push({ enduserId, destinations: [VITL_TITLE] })
+      return { ok: true, message: JSON.stringify(result) }
+    } catch (err: any) {
+      return { ok: false, message: err?.message || err?.toString() || '' }
+    }
+  }
+
+  const vitlLogs = async () => (
+    (await provisioned!.sdk.api.integration_logs.getSome({ filter: { integration: VITL_TITLE } as any })) ?? []
+  )
+
+  try {
+    provisioned = await setup_isolated_tenant()
+    const { sdk } = provisioned
+
+    const completeEnduser = await sdk.api.endusers.createOne({
+      fname: 'Vitl', lname: 'Push',
+      email: `vitl_push_${Date.now()}@test.tellescope.com`,
+      phone: '+15555550123',
+      dateOfBirth: '12-10-1815',
+      gender: 'Other', // deliberately unmappable — must be omitted rather than forwarded
+      addressLineOne: '1 Analytical Way',
+      city: 'London', state: 'NY',
+      zipCode: '10001-6789', // stored with a +4; only the 5 digits may reach VITL
+    })
+
+    /* ===== A: no VITL connection => no push, no PHI egress ===== */
+
+    const beforeConnect = await push(completeEnduser.id)
+    record(
+      'A1: push is rejected when the org has not connected VITL',
+      !beforeConnect.ok && /not connected/i.test(beforeConnect.message),
+      `ok=${beforeConnect.ok} message=${beforeConnect.message}`,
+    )
+    record(
+      'A2: no integration_logs row is written when VITL is not connected',
+      (await vitlLogs()).length === 0,
+      `rows=${(await vitlLogs()).length}`,
+    )
+
+    /* ===== connect VITL (URL is unreachable by construction) ===== */
+
+    const connectResponse = await sdk.api.integrations.add_api_key_integration({
+      integration: VITL_TITLE,
+      API_KEY: SHARED_SECRET,
+      environment: UNREACHABLE_WEBHOOK_URL,
+    })
+
+    // The connect response is not redacted by the generic read path — insertOne returns the inserted
+    // document verbatim, so the VITL branch runs it through redactIntegration explicitly. Asserted on the whole serialized body, not on a named field.
+    record(
+      'A0: the connect response does not echo the shared secret back to the client',
+      !JSON.stringify(connectResponse ?? {}).includes(SHARED_SECRET),
+      `response=${JSON.stringify(connectResponse)}`,
+    )
+
+    const org = await sdk.api.organizations.getOne(provisioned.businessId)
+    record(
+      'A3: connecting VITL sets hasConnectedVITL on the organization',
+      !!(org as any).hasConnectedVITL,
+      `hasConnectedVITL=${(org as any).hasConnectedVITL}`,
+    )
+
+    // The secret must not be readable back through the integrations model.
+    const redacted = await sdk.api.integrations.load_redacted({})
+    const vitlRedacted = redacted.integrations.find((i: any) => i.title === VITL_TITLE)
+    record(
+      'A4: the shared secret is not returned by load_redacted',
+      !!vitlRedacted && !JSON.stringify(vitlRedacted).includes(SHARED_SECRET),
+      `integration=${JSON.stringify(vitlRedacted)}`,
+    )
+    record(
+      'A5: the webhook URL is stored and readable (it is configuration, not a credential)',
+      vitlRedacted?.environment === UNREACHABLE_WEBHOOK_URL,
+      `environment=${vitlRedacted?.environment}`,
+    )
+
+    /* ===== B: pre-flight failure sends no request ===== */
+
+    const incompleteEnduser = await sdk.api.endusers.createOne({
+      fname: 'Vitl', lname: 'Incomplete',
+      email: `vitl_incomplete_${Date.now()}@test.tellescope.com`,
+      phone: '+15555550124',
+      dateOfBirth: '12-10-1815',
+      addressLineOne: '1 Analytical Way',
+      // city deliberately omitted
+      state: 'NY', zipCode: '10001',
+    })
+
+    const incompleteResult = await push(incompleteEnduser.id)
+    record(
+      'B1: a patient missing a required field fails with a message naming that field',
+      !incompleteResult.ok && incompleteResult.message.includes('City'),
+      `ok=${incompleteResult.ok} message=${incompleteResult.message}`,
+    )
+    record(
+      'B2: a pre-flight failure writes NO integration_logs row (no request was sent)',
+      (await vitlLogs()).length === 0,
+      `rows=${(await vitlLogs()).length} (expected 0)`,
+    )
+
+    // VITL also rejects the whole request on an unusable zip. (The matching email-shape check is
+    // asserted in the unit tests instead: endusers.email is validated by our own schema on both create
+    // and update, so a malformed address cannot be stored through the API to push in the first place.)
+    const badZipEnduser = await sdk.api.endusers.createOne({
+      fname: 'Vitl', lname: 'BadZip',
+      email: `vitl_bad_zip_${Date.now()}@test.tellescope.com`,
+      phone: '+15555550126', dateOfBirth: '12-10-1815',
+      addressLineOne: '1 Analytical Way', city: 'London', state: 'NY',
+      zipCode: 'NW1 6XE', // no 5-digit zip is derivable
+    })
+    const badZipResult = await push(badZipEnduser.id)
+    record(
+      'B3: a zip with no 5 digits fails pre-flight with a message naming ZIP',
+      !badZipResult.ok && /zip/i.test(badZipResult.message),
+      `ok=${badZipResult.ok} message=${badZipResult.message}`,
+    )
+
+    record(
+      'B4: none of the pre-flight failures sent a request',
+      (await vitlLogs()).length === 0,
+      `rows=${(await vitlLogs()).length} (expected 0)`,
+    )
+
+    /* ===== C: a real attempt is logged, correctly and without the secret ===== */
+
+    const completeResult = await push(completeEnduser.id)
+    record(
+      'C1: an unreachable webhook reports a transport failure, not a bogus field rejection',
+      !completeResult.ok && /could not reach vitl/i.test(completeResult.message),
+      `ok=${completeResult.ok} message=${completeResult.message}`,
+    )
+
+    const logs = await vitlLogs()
+    const log: any = logs[0]
+    record(
+      'C2: exactly one integration_logs row is written for the attempt',
+      logs.length === 1,
+      `rows=${logs.length}`,
+    )
+    record(
+      'C3: the row is integration=VITL, type=Create Patient, status=Error, with the enduserId',
+      !!log && log.integration === VITL_TITLE && log.type === 'Create Patient'
+        && log.status === 'Error' && log.enduserId === completeEnduser.id,
+      `row=${JSON.stringify({ integration: log?.integration, type: log?.type, status: log?.status, enduserId: log?.enduserId })}`,
+    )
+    record(
+      'C4: the logged url is the configured webhook URL',
+      log?.url === UNREACHABLE_WEBHOOK_URL,
+      `url=${log?.url}`,
+    )
+
+    let payload: any = undefined
+    try { payload = JSON.parse(log?.payload ?? '{}') } catch {}
+    record(
+      'C5: the logged payload has dateOfBirth in YYYY-MM-DD, not our stored MM-DD-YYYY',
+      payload?.dateOfBirth === '1815-12-10',
+      `dateOfBirth=${payload?.dateOfBirth} (stored value is 12-10-1815)`,
+    )
+    record(
+      'C6: the logged payload uid is the Tellescope enduser id',
+      payload?.uid === completeEnduser.id,
+      `uid=${payload?.uid} enduserId=${completeEnduser.id}`,
+    )
+    record(
+      'C6b: a stored ZIP+4 is narrowed to the 5-digit zipcode',
+      payload?.zipcode === '10001',
+      `zipcode=${payload?.zipcode} (stored zipCode is 10001-6789)`,
+    )
+    record(
+      'C7: an unmappable gender is omitted from the payload, not forwarded',
+      !!payload && !('gender' in payload),
+      `gender=${JSON.stringify(payload?.gender)} (enduser gender is 'Other')`,
+    )
+    record(
+      'C8: the x-vitl-secret value appears NOWHERE in the integration_logs row',
+      !JSON.stringify(log ?? {}).includes(SHARED_SECRET),
+      'searched the whole serialized row for the shared secret',
+    )
+
+    /* ===== D: a failed push leaves the enduser untouched ===== */
+
+    const afterFailure: any = await sdk.api.endusers.getOne(completeEnduser.id)
+    record(
+      'D1: a failed push does not set lastVITLSyncAt',
+      !afterFailure.lastVITLSyncAt,
+      `lastVITLSyncAt=${afterFailure.lastVITLSyncAt}`,
+    )
+    record(
+      'D2: a failed push does not add a VITL reference to the enduser',
+      !afterFailure.references?.find((r: any) => r.type === VITL_TITLE),
+      `references=${JSON.stringify(afterFailure.references ?? [])}`,
+    )
+
+    /* ===== E: the journey action reaches the same code path ===== */
+
+    const journey = await sdk.api.journeys.createOne({ title: 'VITL push journey' })
+    const step = await sdk.api.automation_steps.createOne({
+      journeyId: journey.id,
+      events: [{ type: 'onJourneyStart', info: {} }],
+      action: { type: 'pushVITLPatient', info: {} },
+    })
+    record(
+      'E1: a pushVITLPatient automation step round-trips through validation',
+      step.action.type === 'pushVITLPatient',
+      `action=${JSON.stringify(step.action)}`,
+    )
+
+    // processAfter is an hour out so the live worker cannot claim the row before the explicit call.
+    const automatedAction = await sdk.api.automated_actions.createOne({
+      enduserId: completeEnduser.id,
+      journeyId: journey.id,
+      automationStepId: step.id,
+      event: { type: 'onJourneyStart', info: {} },
+      action: { type: 'pushVITLPatient', info: {} },
+      status: 'active',
+      processAfter: Date.now() + 60 * 60 * 1000,
+    } as any)
+
+    const adminToken = (await sdk.api.users.generate_auth_token({ id: sdk.userInfo.id })).authToken
+    const processed = await axios.request({
+      method: 'post',
+      url: `${host}/v1/automated-actions/process`,
+      data: { automatedActionId: automatedAction.id },
+      headers: { Authorization: `Bearer ${adminToken}` },
+      validateStatus: () => true,
+    })
+
+    // `unimplemented` would mean the action type never reached a branch — i.e. the journey action is
+    // declared but not wired. It must instead fail the same way the manual push does.
+    record(
+      'E2: process runs the VITL branch (not unimplemented) and reports the vendor failure',
+      processed.status === 200
+        && processed.data?.unimplemented !== true
+        && processed.data?.success === false
+        && /VITL/i.test(processed.data?.error ?? ''),
+      `status=${processed.status} body=${JSON.stringify(processed.data)}`,
+    )
+
+    record(
+      'E3: the journey action produced a second integration_logs row, same as the manual push',
+      (await vitlLogs()).length === 2,
+      `rows=${(await vitlLogs()).length} (expected 2)`,
+    )
+
+  } finally {
+    if (provisioned) { try { await provisioned.teardown() } catch (e) { console.error('teardown failed', e) } }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const vitl_push_tests = async () => {
+  assert_checks('VITL patient push', await vitl_push_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'VITL patient push', run: vitl_push_checks }
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  vitl_push_tests()
+    .then(() => {
+      console.log("✅ VITL patient push test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ VITL patient push test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/setup_isolated.ts

@@ -1,4 +1,6 @@
 import axios from "axios"
+import fs from "fs"
+import path from "path"
 
 import { assert, log_header } from "@tellescope/testing"
 
@@ -178,3 +180,141 @@ export const run_isolated_in_parallel = async (
     assert_checks(suites[i].name, r.value)
   }
 }
+
+/* ===================== auto-discovered parallel dispatcher ===================== */
+
+/**
+ * A suite enrolled in the parallel pool. A test file enrolls itself by exporting one of these as
+ * `ISOLATED_SUITE`; nothing shared has to be edited:
+ *
+ *   export const ISOLATED_SUITE: IsolatedSuite = { name: 'Programs', run: programs_checks }
+ *
+ * `run` must obey the same contract as run_isolated_in_parallel's entries: collect Check[], tear
+ * down its OWN tenants in a finally, and never assert (assert calls process.exit, which skips every
+ * other in-flight suite's teardown and strands its tenants permanently).
+ */
+export type IsolatedSuite = {
+  /** Unique across all enrolled suites; printed as the batch header and the check-table title. */
+  name: string,
+  run: () => Promise<Check[]>,
+}
+
+/** The export name a test file uses to enroll. Exported so the discovery unit test can scan for it. */
+export const ISOLATED_SUITE_EXPORT = 'ISOLATED_SUITE'
+
+/** Suites in flight at once when TEST_PARALLELISM is unset. Past this, a local API starts returning
+ *  429s from the per-record update throttles rather than real failures. */
+export const DEFAULT_TEST_PARALLELISM = 8
+
+/** Positive integers only; anything else falls back to the default rather than failing a run (a bad
+ *  value must never mean "no limit"). */
+export const parse_test_parallelism = (raw: string | undefined): number => {
+  if (raw === undefined || raw.trim() === '') return DEFAULT_TEST_PARALLELISM
+
+  const parsed = Number(raw.trim())
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    console.warn(
+      `  TEST_PARALLELISM=${JSON.stringify(raw)} is not a positive integer — using the default of ${DEFAULT_TEST_PARALLELISM}`
+    )
+    return DEFAULT_TEST_PARALLELISM
+  }
+  return parsed
+}
+
+export type DiscoveredIsolatedSuite = IsolatedSuite & {
+  /** Path relative to the api_tests root, e.g. `security/form-logic-js-execution.test.js`. */
+  file: string,
+}
+
+/** The compiled api_tests tree. Discovery walks `lib/cjs`, never `src` — a stale build silently drops
+ *  a suite from the run, which is what `npm run check:build` (run before every suite) exists to catch. */
+export const isolated_suites_root = () => path.join(__dirname, 'api_tests')
+
+/**
+ * Relative paths of every compiled test file under `root`, recursively (so `security/` is included),
+ * sorted by a plain code-unit comparison — NOT localeCompare, so batch membership is identical on
+ * every machine.
+ */
+const compiled_test_files = (root: string): string[] => {
+  const found: string[] = []
+
+  const walk = (dir: string, prefix: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name
+
+      if (entry.isDirectory()) { walk(path.join(dir, entry.name), relative); continue }
+      // `.test.js` alone: skips `.js.map`, `.d.ts`, `.d.ts.map` and any non-test helper module
+      if (!entry.name.endsWith('.test.js')) continue
+
+      found.push(relative)
+    }
+  }
+  walk(root, '')
+
+  return found.sort()
+}
+
+/**
+ * Loads every compiled test file and returns the ones that enrolled, in path order.
+ *
+ * `require` runs each file's module scope. That is safe only because every test file keeps its
+ * standalone entrypoint behind `if (require.main === module)` — that guard is load-bearing here.
+ */
+export const discover_isolated_suites = (root = isolated_suites_root()): DiscoveredIsolatedSuite[] => {
+  const suites: DiscoveredIsolatedSuite[] = []
+  const byName: Record<string, string> = {}
+  const label = (file: string) => `${path.basename(root)}/${file}`
+
+  if (!fs.existsSync(root)) {
+    // Loud, rather than "0 suites discovered" followed by a green run.
+    throw new Error(`No compiled test directory at ${root} — build first (npx tsc -b packages/tsconfig.cjs.json --force)`)
+  }
+
+  for (const file of compiled_test_files(root)) {
+    const loaded = require(path.join(root, file))
+    const descriptor = loaded?.[ISOLATED_SUITE_EXPORT]
+    if (descriptor === undefined || descriptor === null) continue
+
+    if (typeof descriptor.name !== 'string' || descriptor.name.trim() === '' || typeof descriptor.run !== 'function') {
+      throw new Error(
+        `${label(file)} exports ${ISOLATED_SUITE_EXPORT}, but it is not { name: string, run: () => Promise<Check[]> }`
+      )
+    }
+    if (byName[descriptor.name]) {
+      throw new Error(
+        `Two isolated suites are named ${JSON.stringify(descriptor.name)}: ${label(byName[descriptor.name])} and ${label(file)}`
+      )
+    }
+
+    byName[descriptor.name] = file
+    suites.push({ name: descriptor.name, run: descriptor.run, file })
+  }
+
+  return suites
+}
+
+/**
+ * Discovers the enrolled suites and runs them through a pool of TEST_PARALLELISM (default 8).
+ *
+ * One batch at a time, asserting after each batch settles rather than once at the end: a red batch
+ * stops the run instead of burning the rest of them. Within a batch the contract is unchanged —
+ * run_isolated_in_parallel lets every suite settle and tear down before anything asserts.
+ */
+export const run_discovered_isolated_suites = async (
+  options?: { root?: string, parallelism?: number },
+): Promise<DiscoveredIsolatedSuite[]> => {
+  const root = options?.root ?? isolated_suites_root()
+  const suites = discover_isolated_suites(root)
+  const parallelism = options?.parallelism ?? parse_test_parallelism(process.env.TEST_PARALLELISM)
+
+  console.log(`\nDiscovered ${suites.length} isolated suite(s), running up to ${parallelism} at a time:`)
+  for (const s of suites) {
+    console.log(`    ${s.name}  (${path.basename(root)}/${s.file})`)
+  }
+
+  for (let i = 0; i < suites.length; i += parallelism) {
+    await run_isolated_in_parallel(suites.slice(i, i + parallelism))
+  }
+
+  return suites
+}

package/src/tests/tests.ts

@@ -142,8 +142,6 @@ import { booking_info_idor_tests } from "./api_tests/security/booking-info-idor-
 import { automated_actions_process_gate_tests } from "./api_tests/security/automated-actions-process-gate.test";
 import { schema_adminonly_enforcement_tests } from "./api_tests/security/schema-adminonly-enforcement.test";
 import { startlinktoken_escalation_tests } from "./api_tests/security/startlinktoken-enduser-staff-escalation.test";
-import { form_logic_js_execution_checks } from "./api_tests/security/form-logic-js-execution.test";
-import { rich_text_answer_sanitized_on_write_checks } from "./api_tests/security/rich-text-answer-sanitized-on-write.test";
 import { bulk_assignment_tests } from "./api_tests/bulk_assignment.test";
 import { tickets_bulk_assign_care_team_tests } from "./api_tests/tickets_bulk_assign_care_team.test";
 import { managed_content_enduser_access_tests } from "./api_tests/managed_content_enduser_access.test";
@@ -164,17 +162,9 @@ import { phone_validation_unit_tests } from "./unit_tests/phone_validation.test"
 import { openapi_spec_freshness_unit_tests } from "./unit_tests/openapi_spec_freshness.test";
 import { do_not_send_address_unit_tests } from "./unit_tests/do_not_send_address.test";
 import { trigger_title_partials_unit_tests } from "./unit_tests/trigger_title_partials.test";
-import { trigger_contains_matching_checks } from "./api_tests/trigger_contains_matching.test";
-import { organization_signup_checks } from "./api_tests/organization_signup.test";
-import { add_to_journey_foreign_enduserid_checks } from "./api_tests/security/add-to-journey-foreign-enduserid.test";
-import { tickets_bulk_assign_from_queue_checks } from "./api_tests/tickets_bulk_assign_from_queue.test";
-import { enduser_observations_auto_review_checks } from "./api_tests/enduser_observations_auto_review.test";
-import { file_link_session_confinement_checks } from "./api_tests/security/file-link-session-confinement.test";
-import { appointment_reschedule_ownership_checks } from "./api_tests/security/appointment-reschedule-ownership.test";
-import { load_threads_care_team_checks } from "./api_tests/load_threads_care_team.test";
-import { run_isolated_in_parallel } from "./setup_isolated";
-import { enduser_fields_sync_checks } from "./api_tests/enduser_fields_sync.test";
-import { user_logs_restore_deleted_checks } from "./api_tests/user_logs_restore_deleted.test";
+import { isolated_suite_discovery_unit_tests } from "./unit_tests/isolated_suite_discovery.test";
+import { programs_conditional_logic_unit_tests } from "./unit_tests/programs_conditional_logic.test";
+import { run_discovered_isolated_suites } from "./setup_isolated";
 import { elation_user_id_tests } from "./api_tests/elation_user_id.test";
 import { organization_settings_duplicates_tests } from "./api_tests/organization_settings_duplicates.test";
 import { stedi_approval_tests } from "./api_tests/stedi_approval.test";
@@ -6015,6 +6005,37 @@ const search_tests = async () => {
     handleAnyError,
   )
 
+  await async_test(
+    `Search with minimumShouldMatch 1 accepted`,
+    () => sdk.api.endusers.getSome({ search: { query: 'john', minimumShouldMatch: 1 } }),
+    { onResult: es => es.length === 1 && es[0].id === e1.id },
+  )
+  await async_test(
+    `Search with minimumShouldMatch 0 accepted`,
+    () => sdk.api.endusers.getSome({ search: { query: 'john', minimumShouldMatch: 0 } }),
+    { onResult: es => es.length === 1 && es[0].id === e1.id },
+  )
+  await async_test(
+    `Search with minimumShouldMatch and minSearchScore accepted`,
+    () => sdk.api.endusers.getSome({ search: { query: 'john', minimumShouldMatch: 1, minSearchScore: 0.5 } }),
+    { onResult: es => es.length === 1 && es[0].id === e1.id },
+  )
+  await async_test(
+    `Search with negative minimumShouldMatch rejected`,
+    () => sdk.api.endusers.getSome({ search: { query: 'john', minimumShouldMatch: -1 } }),
+    handleAnyError,
+  )
+  await async_test(
+    `Search with non-integer minimumShouldMatch rejected`,
+    () => sdk.api.endusers.getSome({ search: { query: 'john', minimumShouldMatch: 1.5 } }),
+    handleAnyError,
+  )
+  await async_test(
+    `Search with string minimumShouldMatch rejected`,
+    () => sdk.api.endusers.getSome({ search: { query: 'john', minimumShouldMatch: 'one' as any } }),
+    handleAnyError,
+  )
+
   await Promise.all([
     sdk.api.endusers.deleteOne(e1.id),
     sdk.api.endusers.deleteOne(e2.id),
@@ -6840,7 +6861,48 @@ export const databases_tests = async () => {
     'numRecords incremented',
     () => sdk.api.databases.getOne(database.id),
     { onResult: c => c.numRecords === 1 },
-  )    
+  )
+
+  await async_test(
+    'load_choices_from_database search with minimumShouldMatch accepted',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minimumShouldMatch: 1 }),
+    { onResult: ({ choices }) => choices.length === 1 && choices[0].id === databaseRecord.id },
+  )
+  await async_test(
+    'load_choices_from_database search with minimumShouldMatch and no match returns empty',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'zzzznonexistent', minimumShouldMatch: 1 }),
+    { onResult: ({ choices }) => choices.length === 0 },
+  )
+  await async_test(
+    'load_choices_from_database negative minimumShouldMatch rejected',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minimumShouldMatch: -1 }),
+    handleAnyError,
+  )
+  await async_test(
+    'load_choices_from_database non-integer minimumShouldMatch rejected',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minimumShouldMatch: 1.5 }),
+    handleAnyError,
+  )
+  await async_test(
+    'load_choices_from_database search with minSearchScore accepted',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minSearchScore: 0.5 }),
+    { onResult: ({ choices }) => choices.length === 1 && choices[0].id === databaseRecord.id },
+  )
+  await async_test(
+    'load_choices_from_database search with minSearchScore and minimumShouldMatch accepted',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minSearchScore: 0.5, minimumShouldMatch: 1 }),
+    { onResult: ({ choices }) => choices.length === 1 && choices[0].id === databaseRecord.id },
+  )
+  await async_test(
+    'load_choices_from_database negative minSearchScore rejected',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minSearchScore: -1 }),
+    handleAnyError,
+  )
+  await async_test(
+    'load_choices_from_database string minSearchScore rejected',
+    () => sdk.api.form_fields.load_choices_from_database({ fieldId: database.id, databaseId: database.id, search: 'value', minSearchScore: 'high' as any }),
+    handleAnyError,
+  )
 
   await async_test(
     'Non admin can access correctly',
@@ -14571,6 +14633,46 @@ const inbox_threads_loading_tests = async () => {
     () => sdk.api.inbox_threads.load_threads({ search: 'ab' }),
     { onResult: ({ threads }) => threads.length === 5 }
   )
+  await async_test(
+    'search with minimumShouldMatch accepted',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Email', minimumShouldMatch: 1 }),
+    { onResult: ({ threads }) => threads.length === 1 && threads[0].type === 'Email' }
+  )
+  await async_test(
+    'search with minimumShouldMatch and no match returns empty',
+    () => sdk.api.inbox_threads.load_threads({ search: 'zzzznonexistent', minimumShouldMatch: 1 }),
+    { onResult: ({ threads }) => threads.length === 0 }
+  )
+  await async_test(
+    'search with negative minimumShouldMatch rejected',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Test', minimumShouldMatch: -1 }),
+    handleAnyError,
+  )
+  await async_test(
+    'search with non-integer minimumShouldMatch rejected',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Test', minimumShouldMatch: 1.5 }),
+    handleAnyError,
+  )
+  await async_test(
+    'search with minSearchScore accepted',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Email', minSearchScore: 0.5 }),
+    { onResult: ({ threads }) => threads.length === 1 && threads[0].type === 'Email' }
+  )
+  await async_test(
+    'search with minSearchScore and minimumShouldMatch accepted',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Email', minSearchScore: 0.5, minimumShouldMatch: 1 }),
+    { onResult: ({ threads }) => threads.length === 1 && threads[0].type === 'Email' }
+  )
+  await async_test(
+    'search with negative minSearchScore rejected',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Test', minSearchScore: -1 }),
+    handleAnyError,
+  )
+  await async_test(
+    'search with string minSearchScore rejected',
+    () => sdk.api.inbox_threads.load_threads({ search: 'Test', minSearchScore: 'high' as any }),
+    handleAnyError,
+  )
 
   // adding to care team of e2 who belongs to only the phone thread
   await sdk.api.endusers.updateOne(e2.id, { assignedTo: [sdkNonAdmin.userInfo.id] }, { replaceObjectFields: true })
@@ -15402,6 +15504,8 @@ const ip_address_form_tests = async () => {
     await openapi_spec_freshness_unit_tests()
     await do_not_send_address_unit_tests()
     await trigger_title_partials_unit_tests()
+    await isolated_suite_discovery_unit_tests()
+    await programs_conditional_logic_unit_tests()
     await replace_enduser_template_values_tests()
     await safe_json_parse_template_tests()
     await replace_form_field_template_values_tests()
@@ -15409,22 +15513,12 @@ const ip_address_form_tests = async () => {
     await setup_tests(sdk, sdkNonAdmin)
     // Isolated, tenant-provisioned suites run first and CONCURRENTLY: each provisions its own
     // throwaway tenant via /test-support, so they cannot collide with each other or with the
-    // shared fixture. Both collect Check[] and tear down before anything asserts — assert calls
-    // process.exit, which would otherwise strand the other suite's tenants.
-    await run_isolated_in_parallel([
-      { name: 'Organization signup', run: organization_signup_checks },
-      { name: 'add_to_journey foreign enduserId', run: add_to_journey_foreign_enduserid_checks },
-      { name: 'Tickets bulk assign from queue', run: tickets_bulk_assign_from_queue_checks },
-      { name: 'Vital auto-review on create', run: enduser_observations_auto_review_checks },
-      { name: '$JS in stored conditional logic', run: form_logic_js_execution_checks },
-      { name: 'Rich Text answers sanitized on write', run: rich_text_answer_sanitized_on_write_checks },
-      { name: 'Shared file link session confinement', run: file_link_session_confinement_checks },
-      { name: 'book_appointment reschedule ownership', run: appointment_reschedule_ownership_checks },
-      { name: 'Enduser fields sync schema round-trip', run: enduser_fields_sync_checks },
-      { name: 'Trigger contains title matching', run: trigger_contains_matching_checks },
-      { name: 'user_logs restore_deleted', run: user_logs_restore_deleted_checks },
-      { name: 'Load threads care team', run: load_threads_care_team_checks },
-    ])
+    // shared fixture. There is no list to maintain here — a suite enrolls itself by exporting
+    // ISOLATED_SUITE from its own file, and the dispatcher discovers it by walking the compiled
+    // api_tests tree. Width is TEST_PARALLELISM (default 8); each batch tears down and asserts
+    // before the next one starts, because assert calls process.exit, which would otherwise strand
+    // a concurrent suite's tenants.
+    await run_discovered_isolated_suites()
     await embeddables_auth_token_tests({ sdk, sdkNonAdmin })
     await proxy_image_ssrf_tests({ sdk, sdkNonAdmin })
     await webhook_outbound_ssrf_tests({ sdk, sdkNonAdmin })