@tellescope/sdk 1.250.1 → 1.250.2

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

@@ -0,0 +1,339 @@
+require('source-map-support').install();
+
+import { Session, EnduserSession } from "../../sdk"
+import {
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+/**
+ * Tests for the "Outbound Chat Sent" automation trigger event.
+ *
+ * Covered cases (one shared trigger, one shared TAG):
+ *  1. Single-enduser room, inbound (enduser session)        → no trigger, no recentOutboundChatAt
+ *  2. Single-enduser room, outbound (user session)          → trigger fires, recentOutboundChatAt set + recent
+ *  3. Multi-enduser room,  inbound (one enduser's session)  → neither enduser tagged or stamped
+ *  4. Multi-enduser room,  outbound (user session)          → BOTH endusers tagged + stamped
+ *  5. User session, senderId = enduser.id (backfill case)   → treated as inbound: no trigger, no stamp
+ *
+ * Chats are NOT explicitly deleted — they cascade-delete from chat_rooms.
+ */
+
+const isRecent = (value: Date | string | undefined, sinceMs: number): boolean => {
+  if (!value) return false
+  const t = new Date(value).valueOf()
+  return t >= sinceMs - 1000 && t <= Date.now() + 1000
+}
+
+export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }) => {
+  log_header("Outbound Chat Sent Trigger Tests")
+
+  const host = process.env.API_URL || 'http://localhost:8080'
+  const TAG = `outbound-chat-sent-${Date.now()}`
+
+  let endSolo: { id: string } | undefined
+  let endA: { id: string } | undefined
+  let endB: { id: string } | undefined
+  let endBackfill: { id: string } | undefined
+  let endAutoreply: { id: string } | undefined
+
+  let trigger: { id: string } | undefined
+  let roomSolo: { id: string } | undefined
+  let roomGroup: { id: string } | undefined
+  let roomBackfill: { id: string } | undefined
+  let roomAutoreply: { id: string } | undefined
+
+  let settingsModified = false
+  let originalOutOfOfficeHours: any[] = []
+  let originalAutoReplyEnabled = false
+
+  try {
+    // ── Endusers ──────────────────────────────────────────────────────
+    endSolo = await sdk.api.endusers.createOne({ fname: 'Solo', lname: 'Patient' })
+    endA = await sdk.api.endusers.createOne({ fname: 'GroupA', lname: 'Patient' })
+    endB = await sdk.api.endusers.createOne({ fname: 'GroupB', lname: 'Patient' })
+    endBackfill = await sdk.api.endusers.createOne({ fname: 'Backfill', lname: 'Patient' })
+    console.log(`Created endusers: solo=${endSolo.id}, A=${endA.id}, B=${endB.id}, backfill=${endBackfill.id}`)
+
+    // ── Enduser sessions for inbound sends ────────────────────────────
+    const { authToken: tokenSolo } = await sdk.api.endusers.generate_auth_token({ id: endSolo.id })
+    const endSoloSDK = new EnduserSession({ host, authToken: tokenSolo, businessId: sdk.userInfo.businessId })
+
+    const { authToken: tokenA } = await sdk.api.endusers.generate_auth_token({ id: endA.id })
+    const endASDK = new EnduserSession({ host, authToken: tokenA, businessId: sdk.userInfo.businessId })
+
+    // ── Trigger ───────────────────────────────────────────────────────
+    trigger = await sdk.api.automation_triggers.createOne({
+      title: `Outbound Chat Sent Test ${Date.now()}`,
+      status: 'Active',
+      event: { type: 'Outbound Chat Sent', info: {} },
+      action: { type: 'Add Tags', info: { tags: [TAG] } },
+    })
+    console.log(`Created trigger: ${trigger.id}`)
+
+    // ── Rooms ─────────────────────────────────────────────────────────
+    roomSolo = await sdk.api.chat_rooms.createOne({
+      userIds: [sdk.userInfo.id],
+      enduserIds: [endSolo.id],
+    })
+    roomGroup = await sdk.api.chat_rooms.createOne({
+      userIds: [sdk.userInfo.id],
+      enduserIds: [endA.id, endB.id],
+    })
+    roomBackfill = await sdk.api.chat_rooms.createOne({
+      userIds: [sdk.userInfo.id],
+      enduserIds: [endBackfill.id],
+    })
+    console.log(`Created rooms: solo=${roomSolo.id}, group=${roomGroup.id}, backfill=${roomBackfill.id}`)
+
+    // ═════════════════════════════════════════════════════════════════
+    // Case 1: Single-enduser inbound (enduser session)
+    // ═════════════════════════════════════════════════════════════════
+    await endSoloSDK.api.chats.createOne({
+      roomId: roomSolo.id,
+      message: 'solo inbound from enduser',
+    })
+    await wait(undefined, 2000)
+
+    const soloAfterInbound = await sdk.api.endusers.getOne(endSolo.id)
+    const c1_notTagged = !soloAfterInbound.tags?.includes(TAG)
+    const c1_noStamp = !soloAfterInbound.recentOutboundChatAt
+    console.log(c1_notTagged
+      ? `✅ [1] Solo inbound did NOT fire trigger`
+      : `❌ [1] Solo inbound fired trigger. tags=${JSON.stringify(soloAfterInbound.tags)}`)
+    console.log(c1_noStamp
+      ? `✅ [1] Solo inbound did NOT set recentOutboundChatAt`
+      : `❌ [1] Solo inbound set recentOutboundChatAt=${soloAfterInbound.recentOutboundChatAt}`)
+
+    // ═════════════════════════════════════════════════════════════════
+    // Case 2: Single-enduser outbound (user session)
+    // ═════════════════════════════════════════════════════════════════
+    const c2_sendStart = Date.now()
+    await sdk.api.chats.createOne({
+      roomId: roomSolo.id,
+      message: 'solo outbound from user',
+      senderId: sdk.userInfo.id,
+    })
+    await wait(undefined, 2000)
+
+    const soloAfterOutbound = await sdk.api.endusers.getOne(endSolo.id)
+    const c2_tagged = !!soloAfterOutbound.tags?.includes(TAG)
+    const c2_stamped = isRecent(soloAfterOutbound.recentOutboundChatAt, c2_sendStart)
+    console.log(c2_tagged
+      ? `✅ [2] Solo outbound fired trigger`
+      : `❌ [2] Solo outbound did NOT fire trigger. tags=${JSON.stringify(soloAfterOutbound.tags)}`)
+    console.log(c2_stamped
+      ? `✅ [2] Solo outbound set recentOutboundChatAt=${soloAfterOutbound.recentOutboundChatAt}`
+      : `❌ [2] Solo outbound did not set a recent recentOutboundChatAt. got=${soloAfterOutbound.recentOutboundChatAt}`)
+
+    // ═════════════════════════════════════════════════════════════════
+    // Case 3: Multi-enduser inbound (endA sends in [A, B] room)
+    // ═════════════════════════════════════════════════════════════════
+    await endASDK.api.chats.createOne({
+      roomId: roomGroup.id,
+      message: 'group inbound from endA',
+    })
+    await wait(undefined, 2000)
+
+    const aAfterInbound = await sdk.api.endusers.getOne(endA.id)
+    const bAfterInbound = await sdk.api.endusers.getOne(endB.id)
+    const c3_aNotTagged = !aAfterInbound.tags?.includes(TAG)
+    const c3_bNotTagged = !bAfterInbound.tags?.includes(TAG)
+    const c3_neitherTagged = c3_aNotTagged && c3_bNotTagged
+    const c3_neitherStamped = !aAfterInbound.recentOutboundChatAt && !bAfterInbound.recentOutboundChatAt
+    console.log(c3_neitherTagged
+      ? `✅ [3] Group inbound did NOT fire trigger on either enduser`
+      : `❌ [3] Group inbound fired trigger. A tags=${JSON.stringify(aAfterInbound.tags)} B tags=${JSON.stringify(bAfterInbound.tags)}`)
+    console.log(c3_neitherStamped
+      ? `✅ [3] Group inbound did NOT set recentOutboundChatAt on either enduser`
+      : `❌ [3] Group inbound stamped recentOutboundChatAt. A=${aAfterInbound.recentOutboundChatAt} B=${bAfterInbound.recentOutboundChatAt}`)
+
+    // ═════════════════════════════════════════════════════════════════
+    // Case 4: Multi-enduser outbound (user sends in [A, B] room)
+    // ═════════════════════════════════════════════════════════════════
+    const c4_sendStart = Date.now()
+    await sdk.api.chats.createOne({
+      roomId: roomGroup.id,
+      message: 'group outbound from user',
+      senderId: sdk.userInfo.id,
+    })
+    await wait(undefined, 2000)
+
+    const aAfterOutbound = await sdk.api.endusers.getOne(endA.id)
+    const bAfterOutbound = await sdk.api.endusers.getOne(endB.id)
+    const c4_bothTagged = !!aAfterOutbound.tags?.includes(TAG) && !!bAfterOutbound.tags?.includes(TAG)
+    const c4_bothStamped = isRecent(aAfterOutbound.recentOutboundChatAt, c4_sendStart)
+      && isRecent(bAfterOutbound.recentOutboundChatAt, c4_sendStart)
+    console.log(c4_bothTagged
+      ? `✅ [4] Group outbound fired trigger on BOTH endusers`
+      : `❌ [4] Group outbound did not tag both. A tags=${JSON.stringify(aAfterOutbound.tags)} B tags=${JSON.stringify(bAfterOutbound.tags)}`)
+    console.log(c4_bothStamped
+      ? `✅ [4] Group outbound set recentOutboundChatAt on BOTH endusers`
+      : `❌ [4] Group outbound did not stamp both. A=${aAfterOutbound.recentOutboundChatAt} B=${bAfterOutbound.recentOutboundChatAt}`)
+
+    // ═════════════════════════════════════════════════════════════════
+    // Case 5: User session, senderId = enduser.id (backfill)
+    // ═════════════════════════════════════════════════════════════════
+    await sdk.api.chats.createOne({
+      roomId: roomBackfill.id,
+      message: 'backfilled inbound (user session, enduser senderId)',
+      senderId: endBackfill.id,
+    })
+    await wait(undefined, 2000)
+
+    const backfillAfter = await sdk.api.endusers.getOne(endBackfill.id)
+    const c5_notTagged = !backfillAfter.tags?.includes(TAG)
+    const c5_noStamp = !backfillAfter.recentOutboundChatAt
+    console.log(c5_notTagged
+      ? `✅ [5] Backfill (user-session + enduser senderId) did NOT fire trigger`
+      : `❌ [5] Backfill fired trigger. tags=${JSON.stringify(backfillAfter.tags)}`)
+    console.log(c5_noStamp
+      ? `✅ [5] Backfill did NOT set recentOutboundChatAt`
+      : `❌ [5] Backfill set recentOutboundChatAt=${backfillAfter.recentOutboundChatAt}`)
+
+    // ═════════════════════════════════════════════════════════════════
+    // Case 6: Autoreply — enduser inbound triggers an org autoreply.
+    //   The autoreply chat (isAutoreply: true) MUST NOT fire the trigger
+    //   or stamp recentOutboundChatAt.
+    //
+    // Setup requires enabling org autoreply with an OOO window covering
+    // "now" (is_out_of_office returns false on empty config).
+    // ═════════════════════════════════════════════════════════════════
+    const originalOrg = await sdk.api.organizations.getOne(sdk.userInfo.businessId)
+    originalOutOfOfficeHours = originalOrg.outOfOfficeHours ?? []
+    originalAutoReplyEnabled = !!originalOrg.settings?.endusers?.autoReplyEnabled
+
+    settingsModified = true
+    await sdk.api.organizations.updateOne(sdk.userInfo.businessId, {
+      outOfOfficeHours: [{
+        from: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+        to:   new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+        autoreplyText: 'OOO autoreply (test)',
+      }] as any,
+      settings: { endusers: { autoReplyEnabled: true } } as any,
+    }, { replaceObjectFields: true })
+
+    endAutoreply = await sdk.api.endusers.createOne({ fname: 'Autoreply', lname: 'Patient' })
+    const { authToken: tokenAR } = await sdk.api.endusers.generate_auth_token({ id: endAutoreply.id })
+    const endAutoreplySDK = new EnduserSession({ host, authToken: tokenAR, businessId: sdk.userInfo.businessId })
+
+    roomAutoreply = await sdk.api.chat_rooms.createOne({
+      userIds: [sdk.userInfo.id],
+      enduserIds: [endAutoreply.id],
+    })
+
+    await endAutoreplySDK.api.chats.createOne({
+      roomId: roomAutoreply.id,
+      message: 'trigger an autoreply',
+    })
+
+    // Autoreply path involves an extra org/user lookup + insert before
+    // handle_chat_create re-runs against the autoreply chat.
+    await wait(undefined, 4000)
+
+    const arAfter = await sdk.api.endusers.getOne(endAutoreply.id)
+    const roomChats = await sdk.api.chats.getSome({ filter: { roomId: roomAutoreply.id } })
+    const sanity_autoreplySent = roomChats.some(c => (c as any).isAutoreply === true)
+
+    const c6_notTagged = !arAfter.tags?.includes(TAG)
+    const c6_noStamp = !arAfter.recentOutboundChatAt
+
+    console.log(sanity_autoreplySent
+      ? `✅ [6] Autoreply chat was sent (sanity check)`
+      : `❌ [6] No autoreply chat found in room — test setup invalid. Cannot validate trigger skip.`)
+    console.log(c6_notTagged
+      ? `✅ [6] Autoreply did NOT fire trigger`
+      : `❌ [6] Autoreply fired trigger. tags=${JSON.stringify(arAfter.tags)}`)
+    console.log(c6_noStamp
+      ? `✅ [6] Autoreply did NOT set recentOutboundChatAt`
+      : `❌ [6] Autoreply set recentOutboundChatAt=${arAfter.recentOutboundChatAt}`)
+
+    // ── Summary ───────────────────────────────────────────────────────
+    console.log(`\n=== Outbound Chat Sent Trigger Test Results ===`)
+    console.log(`[1] Solo  inbound  — no trigger:        ${c1_notTagged ? '✅' : '❌'}`)
+    console.log(`[1] Solo  inbound  — no stamp:          ${c1_noStamp ? '✅' : '❌'}`)
+    console.log(`[2] Solo  outbound — trigger:           ${c2_tagged ? '✅' : '❌'}`)
+    console.log(`[2] Solo  outbound — stamp:             ${c2_stamped ? '✅' : '❌'}`)
+    console.log(`[3] Group inbound  — no trigger (both): ${c3_neitherTagged ? '✅' : '❌'}`)
+    console.log(`[3] Group inbound  — no stamp (both):   ${c3_neitherStamped ? '✅' : '❌'}`)
+    console.log(`[4] Group outbound — trigger (both):    ${c4_bothTagged ? '✅' : '❌'}`)
+    console.log(`[4] Group outbound — stamp (both):      ${c4_bothStamped ? '✅' : '❌'}`)
+    console.log(`[5] Backfill       — no trigger:        ${c5_notTagged ? '✅' : '❌'}`)
+    console.log(`[5] Backfill       — no stamp:          ${c5_noStamp ? '✅' : '❌'}`)
+    console.log(`[6] Autoreply      — sanity sent:       ${sanity_autoreplySent ? '✅' : '❌'}`)
+    console.log(`[6] Autoreply      — no trigger:        ${c6_notTagged ? '✅' : '❌'}`)
+    console.log(`[6] Autoreply      — no stamp:          ${c6_noStamp ? '✅' : '❌'}`)
+
+    const allPassed =
+      c1_notTagged && c1_noStamp
+      && c2_tagged && c2_stamped
+      && c3_neitherTagged && c3_neitherStamped
+      && c4_bothTagged && c4_bothStamped
+      && c5_notTagged && c5_noStamp
+      && sanity_autoreplySent && c6_notTagged && c6_noStamp
+
+    if (!allPassed) {
+      throw new Error('Outbound Chat Sent trigger tests failed')
+    }
+
+    return { success: true }
+  } finally {
+    try {
+      // Restore org settings FIRST (sequentially, before deletes), so a
+      // failure here doesn't leave autoReplyEnabled=true polluting other tests.
+      if (settingsModified) {
+        try {
+          await sdk.api.organizations.updateOne(sdk.userInfo.businessId, {
+            outOfOfficeHours: originalOutOfOfficeHours as any,
+            settings: { endusers: { autoReplyEnabled: originalAutoReplyEnabled } } as any,
+          }, { replaceObjectFields: true })
+          console.log(`Restored org settings (autoReplyEnabled=${originalAutoReplyEnabled}, outOfOfficeHours.length=${originalOutOfOfficeHours.length})`)
+        } catch (err) {
+          console.error(`❌ Failed to restore org settings — manual cleanup may be required: ${err}`)
+        }
+      }
+
+      const cleanups: Promise<any>[] = []
+
+      if (trigger?.id) cleanups.push(sdk.api.automation_triggers.deleteOne(trigger.id).catch(() => {}))
+      if (roomSolo?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomSolo.id).catch(() => {}))
+      if (roomGroup?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomGroup.id).catch(() => {}))
+      if (roomBackfill?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomBackfill.id).catch(() => {}))
+      if (roomAutoreply?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomAutoreply.id).catch(() => {}))
+      if (endSolo?.id) cleanups.push(sdk.api.endusers.deleteOne(endSolo.id).catch(() => {}))
+      if (endA?.id) cleanups.push(sdk.api.endusers.deleteOne(endA.id).catch(() => {}))
+      if (endB?.id) cleanups.push(sdk.api.endusers.deleteOne(endB.id).catch(() => {}))
+      if (endBackfill?.id) cleanups.push(sdk.api.endusers.deleteOne(endBackfill.id).catch(() => {}))
+      if (endAutoreply?.id) cleanups.push(sdk.api.endusers.deleteOne(endAutoreply.id).catch(() => {}))
+
+      await Promise.all(cleanups)
+      console.log(`Outbound Chat Sent trigger test cleanup completed`)
+    } catch (error) {
+      console.error(`Cleanup error: ${error}`)
+    }
+  }
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  const host = process.env.API_URL || 'http://localhost:8080'
+  console.log(`🌐 Using API URL: ${host}`)
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await outbound_chat_sent_trigger_tests({ sdk })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Outbound Chat Sent trigger tests completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Outbound Chat Sent trigger tests failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/tests.ts

@@ -78,6 +78,7 @@ import { eom_procedure_codes_tests } from "./api_tests/eom_procedure_codes.test"
 import { cross_org_api_key_tests } from "./api_tests/cross_org_api_key.test";
 import { custom_dashboards_tests } from "./api_tests/custom_dashboards.test";
 import { message_assignment_trigger_tests } from "./api_tests/message_assignment_trigger.test";
+import { outbound_chat_sent_trigger_tests } from "./api_tests/outbound_chat_sent_trigger.test";
 import { time_tracks_tests, time_tracks_historical_tests, time_tracks_correction_tests, time_tracks_review_tests, time_tracks_lock_tests, time_tracks_edge_case_tests } from "./api_tests/time_tracks.test";
 import { monthly_availability_restrictions_tests } from "./api_tests/monthly_availability_restrictions.test";
 import { calendar_event_limits_tests } from "./api_tests/calendar_event_limits.test";
@@ -95,6 +96,7 @@ import { load_team_chat_tests } from "./api_tests/load_team_chat.test";
 import { form_started_trigger_tests } from "./api_tests/form_started_trigger.test";
 import { form_submitted_trigger_tests } from "./api_tests/form_submitted_trigger.test";
 import { medication_added_trigger_tests } from "./api_tests/medication_added_trigger.test";
+import { conditional_logic_medication_unit_tests } from "./unit_tests/conditional_logic_medication.test";
 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 { calendar_events_bulk_update_tests } from "./api_tests/calendar_events_bulk_update.test";
@@ -14303,10 +14305,13 @@ const ip_address_form_tests = async () => {
 
 
     await enduser_conditional_logic_tests()
+    await conditional_logic_medication_unit_tests()
     await replace_enduser_template_values_tests()
     await replace_form_field_template_values_tests()
     await mfa_tests()
     await setup_tests(sdk, sdkNonAdmin)
+    await outbound_chat_sent_trigger_tests({ sdk })
+    await automation_trigger_tests()
     await enduser_cross_access_isolation_tests({ sdk, sdkNonAdmin })
     await eom_procedure_codes_tests({ sdk, sdkNonAdmin })
     await cross_org_api_key_tests({ sdk, sdkNonAdmin })
@@ -14317,7 +14322,6 @@ const ip_address_form_tests = async () => {
     await form_submitted_trigger_tests({ sdk, sdkNonAdmin })
     await date_string_validation_tests({ sdk, sdkNonAdmin })
     await openloop_webhooks_tests({ sdk, sdkNonAdmin })
-    await automation_trigger_tests()
     await integrations_redacted_tests({ sdk, sdkNonAdmin })
     await mdb_sort_tests({ sdk, sdkNonAdmin })
     await search_tests()

package/src/tests/unit_tests/conditional_logic_medication.test.ts

@@ -0,0 +1,133 @@
+import {
+  evaluate_conditional_logic_for_medication_title,
+  evaluate_string_field_comparison,
+} from "@tellescope/utilities"
+import { CompoundFilter } from "@tellescope/types-models"
+
+let failures = 0
+let passed = 0
+
+const assert = (name: string, actual: boolean, expected: boolean) => {
+  if (actual === expected) {
+    passed++
+    console.log(`  ✓ ${name}`)
+  } else {
+    failures++
+    console.error(`  ✗ ${name} — expected ${expected}, got ${actual}`)
+  }
+}
+
+const run_string_comparison_tests = () => {
+  console.log("\n[evaluate_string_field_comparison]")
+
+  // Plain-string equals (implicit operator)
+  assert("equals plain string match", evaluate_string_field_comparison('Aspirin', 'Aspirin'), true)
+  assert("equals plain string mismatch", evaluate_string_field_comparison('Aspirin', 'Lisinopril'), false)
+  assert("equals empty string against empty title", evaluate_string_field_comparison('', ''), true)
+  assert("equals empty string against undefined title", evaluate_string_field_comparison(undefined, ''), true)
+
+  // $ne
+  assert("$ne matches when different", evaluate_string_field_comparison('Aspirin', { $ne: 'Lisinopril' }), true)
+  assert("$ne fails when equal", evaluate_string_field_comparison('Aspirin', { $ne: 'Aspirin' }), false)
+
+  // $contains (case sensitive — consistent with enduser/form-response evaluators)
+  assert("$contains substring match", evaluate_string_field_comparison('Semaglutide GLP-1', { $contains: 'GLP' }), true)
+  assert("$contains case sensitive miss", evaluate_string_field_comparison('Lisinopril 10MG', { $contains: 'mg' }), false)
+  assert("$contains case sensitive match", evaluate_string_field_comparison('Lisinopril 10mg', { $contains: 'mg' }), true)
+  assert("$contains no match", evaluate_string_field_comparison('Aspirin', { $contains: 'GLP' }), false)
+  assert("$contains empty string is always true", evaluate_string_field_comparison('Aspirin', { $contains: '' }), true)
+
+  // $doesNotContain
+  assert("$doesNotContain mismatch true", evaluate_string_field_comparison('Aspirin', { $doesNotContain: 'GLP' }), true)
+  assert("$doesNotContain match false", evaluate_string_field_comparison('Semaglutide', { $doesNotContain: 'Sema' }), false)
+  assert("$doesNotContain case sensitive (different case = no match)", evaluate_string_field_comparison('Placebo', { $doesNotContain: 'PLACEBO' }), true)
+
+  // $exists
+  assert("$exists:true on present", evaluate_string_field_comparison('Aspirin', { $exists: true }), true)
+  assert("$exists:true on empty", evaluate_string_field_comparison('', { $exists: true }), false)
+  assert("$exists:true on undefined", evaluate_string_field_comparison(undefined, { $exists: true }), false)
+  assert("$exists:false on present", evaluate_string_field_comparison('Aspirin', { $exists: false }), false)
+  assert("$exists:false on undefined", evaluate_string_field_comparison(undefined, { $exists: false }), true)
+
+  // null operator → treated as "no value set"
+  assert("null operator on undefined title", evaluate_string_field_comparison(undefined, null), true)
+  assert("null operator on present title", evaluate_string_field_comparison('Aspirin', null), false)
+
+  // Unknown operator → returns true (don't suppress triggers on bad data)
+  assert("unknown operator returns true", evaluate_string_field_comparison('Aspirin', { $weirdOp: 'x' } as any), true)
+}
+
+const run_conditional_logic_tests = () => {
+  console.log("\n[evaluate_conditional_logic_for_medication_title]")
+
+  // Single condition (case-sensitive)
+  const c1: CompoundFilter<'title'> = { condition: { title: { $contains: 'GLP' } } }
+  assert("single $contains true", evaluate_conditional_logic_for_medication_title('Semaglutide GLP-1', c1), true)
+  assert("single $contains false", evaluate_conditional_logic_for_medication_title('Aspirin', c1), false)
+  assert("single $contains case-sensitive miss", evaluate_conditional_logic_for_medication_title('Semaglutide glp-1', c1), false)
+
+  // Plain string default-equals
+  const c2: CompoundFilter<'title'> = { condition: { title: 'Aspirin' } }
+  assert("plain equals true", evaluate_conditional_logic_for_medication_title('Aspirin', c2), true)
+  assert("plain equals false", evaluate_conditional_logic_for_medication_title('Lisinopril', c2), false)
+
+  // $and (both true)
+  const cAnd: CompoundFilter<'title'> = {
+    $and: [
+      { condition: { title: { $contains: 'mg' } } },
+      { condition: { title: { $doesNotContain: 'Placebo' } } },
+    ],
+  }
+  assert("$and both pass", evaluate_conditional_logic_for_medication_title('Lisinopril 10mg', cAnd), true)
+  assert("$and first fails", evaluate_conditional_logic_for_medication_title('Lisinopril', cAnd), false)
+  assert("$and second fails", evaluate_conditional_logic_for_medication_title('Placebo 5mg', cAnd), false)
+
+  // $or
+  const cOr: CompoundFilter<'title'> = {
+    $or: [
+      { condition: { title: 'Aspirin' } },
+      { condition: { title: { $contains: 'pril' } } },
+    ],
+  }
+  assert("$or first matches", evaluate_conditional_logic_for_medication_title('Aspirin', cOr), true)
+  assert("$or second matches", evaluate_conditional_logic_for_medication_title('Lisinopril', cOr), true)
+  assert("$or neither matches", evaluate_conditional_logic_for_medication_title('Metformin', cOr), false)
+
+  // Mixed compound: $and containing $or — the canonical "compound" case
+  const cMixed: CompoundFilter<'title'> = {
+    $and: [
+      { condition: { title: { $contains: 'mg' } } },
+      {
+        $or: [
+          { condition: { title: { $contains: 'Lisin' } } },
+          { condition: { title: { $contains: 'Metform' } } },
+        ],
+      },
+    ],
+  }
+  assert("$and+$or first or-branch matches", evaluate_conditional_logic_for_medication_title('Lisinopril 10mg', cMixed), true)
+  assert("$and+$or second or-branch matches", evaluate_conditional_logic_for_medication_title('Metformin 500mg', cMixed), true)
+  assert("$and+$or and-branch fails", evaluate_conditional_logic_for_medication_title('Lisinopril', cMixed), false)
+  assert("$and+$or or-branch fails", evaluate_conditional_logic_for_medication_title('Aspirin 81mg', cMixed), false)
+
+  // Empty / no-op
+  assert("empty conditions returns true", evaluate_conditional_logic_for_medication_title('Aspirin', {}), true)
+
+  // Unknown operator inside condition → returns true (safe)
+  const cUnknown: CompoundFilter<'title'> = { condition: { title: { $regex: 'foo' } as any } }
+  assert("unknown operator is permissive", evaluate_conditional_logic_for_medication_title('Aspirin', cUnknown), true)
+}
+
+const run_all = () => {
+  console.log("Running conditional_logic_medication unit tests")
+  run_string_comparison_tests()
+  run_conditional_logic_tests()
+  console.log(`\nResults: ${passed} passed, ${failures} failed`)
+  if (failures > 0) process.exit(1)
+}
+
+if (require.main === module) {
+  run_all()
+}
+
+export { run_all as conditional_logic_medication_unit_tests }