@tellescope/sdk 1.256.6 → 1.256.7

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

@@ -0,0 +1,205 @@
+require('source-map-support').install();
+
+import { Session, EnduserSession } from "../../sdk"
+import {
+  assert,
+  async_test,
+  handleAnyError,
+  log_header,
+} from "@tellescope/testing"
+import {
+  decodeTranslationMapFromStorage,
+  encodeTranslationMapForStorage,
+  objects_equivalent,
+} from "@tellescope/utilities"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+// Modular test for AI form translations (display-language maps for v2 forms).
+//
+// Covers:
+// 1. Storage round-trip: encodeTranslationMapForStorage survives the configurations.value escapeHTML
+//    validator (sanitize_html strips tags and entity-encodes & < >) for maps containing HTML, & < >,
+//    quotes, {{placeholders}}, and non-ASCII text.
+// 2. Form.translationConfigurations (language -> configurationId) persistence.
+// 3. public_form_details language param: returns the map only for a publicRead-flagged configuration
+//    on a form that allows a public URL.
+// 4. submit_form_response viewedInLanguage: persisted as metadata while stored answers stay English.
+//
+// NOTE: this test deliberately does NOT invoke the AI translation endpoint (ai_conversations.send_message) —
+// that path consumes AI credits. Map generation is exercised via manual map fixtures.
+export const form_translations_tests = async ({ sdk } : { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Form Translations Tests")
+
+  const ENGLISH_CHOICES = ['Salt & Pepper', '<b>Bold</b> choice', `It's "quoted"`, 'Résumé 中文']
+
+  // keys AND values include the characters sanitize_html would otherwise mangle
+  const TRANSLATION_MAP: Record<string, string> = {
+    'What is your favorite seasoning?': '¿Cuál es tu condimento favorito?',
+    'Salt & Pepper': 'Sal & Pimienta',
+    '<b>Bold</b> choice': '<b>Negrita</b> elección',
+    [`It's "quoted"`]: `Está "citado"`,
+    'Résumé 中文': 'Currículum 中文',
+    'Hello {{enduser.fname}} <br/> welcome': 'Hola {{enduser.fname}} <br/> bienvenido',
+  }
+
+  const createdConfigurationIds: string[] = []
+  let formId: string | undefined
+  let fieldId: string | undefined
+  let enduserId: string | undefined
+
+  try {
+    // --- 1. escapeHTML-safe storage round-trip (run first: it guards the whole storage design) ---
+    const encoded = encodeTranslationMapForStorage(TRANSLATION_MAP)
+    const configuration = await sdk.api.configurations.createOne({
+      type: 'form-translations:test:es',
+      value: encoded,
+      publicRead: true,
+    })
+    createdConfigurationIds.push(configuration.id)
+
+    const storedConfiguration = await sdk.api.configurations.getOne(configuration.id)
+    const decoded = decodeTranslationMapFromStorage(storedConfiguration.value)
+    assert(
+      objects_equivalent(decoded, TRANSLATION_MAP),
+      `translation map corrupted by storage: ${JSON.stringify(decoded)}`,
+      'translation map with & < > quotes HTML and non-ASCII survives storage round-trip',
+    )
+
+    // an unflagged configuration, to verify the publicRead gate on public_form_details
+    const unflaggedConfiguration = await sdk.api.configurations.createOne({
+      type: 'form-translations:test:fr-unflagged',
+      value: encodeTranslationMapForStorage({ Hello: 'Bonjour' }),
+    })
+    createdConfigurationIds.push(unflaggedConfiguration.id)
+
+    // --- 2. form mapping persistence ---
+    const form = await sdk.api.forms.createOne({
+      title: 'Form Translations Test Form',
+      version: 'v2',
+      allowPublicURL: true,
+    })
+    formId = form.id
+
+    const field = await sdk.api.form_fields.createOne({
+      formId: form.id,
+      title: 'What is your favorite seasoning?',
+      type: 'multiple_choice',
+      options: { choices: ENGLISH_CHOICES, radio: true },
+      previousFields: [{ type: 'root', info: {} }],
+    })
+    fieldId = field.id
+
+    await sdk.api.forms.updateOne(form.id, {
+      translationConfigurations: [
+        { language: 'es', configurationId: configuration.id },
+        { language: 'fr', configurationId: unflaggedConfiguration.id },
+      ],
+    }, { replaceObjectFields: true })
+
+    const updatedForm = await sdk.api.forms.getOne(form.id)
+    assert(
+      updatedForm.translationConfigurations?.length === 2
+      && updatedForm.translationConfigurations.some(t => t.language === 'es' && t.configurationId === configuration.id),
+      `translationConfigurations not persisted: ${JSON.stringify(updatedForm.translationConfigurations)}`,
+      'form translationConfigurations mapping persists',
+    )
+
+    // --- 3. public_form_details language param (unauthenticated) ---
+    const publicSDK = new EnduserSession({ host, businessId: sdk.userInfo.businessId })
+
+    await async_test(
+      'public_form_details returns translations for a mapped language with a flagged configuration',
+      () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'es' }),
+      { onResult: r => objects_equivalent(r.translations, TRANSLATION_MAP) },
+    )
+    await async_test(
+      'public_form_details returns no translations without a language param',
+      () => publicSDK.api.forms.public_form_details({ formId: form.id }),
+      { onResult: r => !r.translations || Object.keys(r.translations).length === 0 },
+    )
+    await async_test(
+      'public_form_details returns no translations for an unmapped language',
+      () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'de' }),
+      { onResult: r => !r.translations || Object.keys(r.translations).length === 0 },
+    )
+    await async_test(
+      'public_form_details returns no translations for an UNFLAGGED configuration (publicRead gate)',
+      () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'fr' }),
+      { onResult: r => !r.translations || Object.keys(r.translations).length === 0 },
+    )
+
+    // a form without allowPublicURL still rejects public_form_details entirely
+    await sdk.api.forms.updateOne(form.id, { allowPublicURL: false })
+    await async_test(
+      'public_form_details still rejects forms without allowPublicURL',
+      () => publicSDK.api.forms.public_form_details({ formId: form.id, language: 'es' }),
+      handleAnyError,
+    )
+    await sdk.api.forms.updateOne(form.id, { allowPublicURL: true })
+
+    // --- 4. viewedInLanguage persists; stored answers remain English ---
+    const enduser = await sdk.api.endusers.createOne({
+      email: `form_translations_${Date.now()}@test.tellescope.com`,
+    })
+    enduserId = enduser.id
+
+    const { accessCode } = await sdk.api.form_responses.prepare_form_response({
+      formId: form.id, enduserId: enduser.id,
+    })
+
+    const { formResponse } = await sdk.api.form_responses.submit_form_response({
+      accessCode,
+      viewedInLanguage: 'es',
+      responses: [{
+        fieldId: field.id,
+        fieldTitle: field.title, // English snapshot, as the client submits it
+        answer: { type: 'multiple_choice', value: ['Salt & Pepper'] }, // English source value, never the translation
+      }],
+    })
+
+    const storedResponse = await sdk.api.form_responses.getOne(formResponse.id)
+    assert(
+      storedResponse.viewedInLanguage === 'es',
+      `viewedInLanguage not persisted: ${storedResponse.viewedInLanguage}`,
+      'viewedInLanguage persists on the submitted form response',
+    )
+    const storedAnswer = storedResponse.responses?.find(r => r.fieldId === field.id)
+    assert(
+      Array.isArray(storedAnswer?.answer?.value)
+      && (storedAnswer!.answer.value as string[])[0] === 'Salt & Pepper'
+      && storedAnswer!.fieldTitle === 'What is your favorite seasoning?',
+      `stored response not English: ${JSON.stringify(storedAnswer)}`,
+      'stored answer value and fieldTitle remain the English source strings',
+    )
+  } finally {
+    if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(() => {})
+    if (fieldId) await sdk.api.form_fields.deleteOne(fieldId).catch(() => {})
+    if (formId) await sdk.api.forms.deleteOne(formId).catch(() => {})
+    for (const id of createdConfigurationIds) {
+      await sdk.api.configurations.deleteOne(id).catch(() => {})
+    }
+  }
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await form_translations_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Form translations test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Form translations test suite failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -54,6 +54,11 @@ export const group_event_attendee_status_triggers_tests = async ({ sdk } : { sdk
     }, { replaceObjectFields: true })
   )
 
+  // Replicates the webapp "Mark Completed" action on the whole event (Calendar.tsx)
+  const markEventCompleted = async (eventId: string) => (
+    sdk.api.calendar_events.updateOne(eventId, { completedAt: new Date(), completedBy: sdk.userInfo.id })
+  )
+
   const tagsOf = async (enduserId: string) => (await sdk.api.endusers.getOne(enduserId)).tags || []
 
   try {
@@ -345,6 +350,136 @@ export const group_event_attendee_status_triggers_tests = async ({ sdk } : { sdk
       { onResult: (tags: string[]) => tags.length === 1 && tags.includes(TAG['No-showed']) }
     )
 
+    // ============================================================
+    // Marking the WHOLE event Complete must not fan "Appointment Completed" out to attendees who
+    // already have an explicit per-attendee status — they were resolved individually (and already
+    // fired their own trigger via handle_attendee_status_change_triggers). Attendees with no status,
+    // or 'Confirmed', are still active participants and must still fire.
+    //
+    // Each case uses fresh endusers and a fresh event: triggers are throttled for 60s per
+    // trigger-per-enduser, and the completion handler early-returns once completedAt is already set.
+    //
+    // Not covered here: per-attendee 'Completed' followed by event-wide completion. That duplicate
+    // fire is already swallowed by the 60s throttle (which is applied before the action, and Add Tags
+    // is idempotent), so the assertion would pass with or without the filter.
+    // ============================================================
+    log_header("Event-wide completion respects per-attendee statuses")
+
+    // status -> tag that must NOT appear on the target after the event is completed
+    for (const status of ['No-showed', 'Cancelled', 'Rescheduled'] as const) {
+      const target = await createEnduser()
+      const active = await createEnduser()
+      const event = await createGroupEvent([target.id, active.id])
+
+      await setAttendeeStatuses(event.id, [{ id: target.id, status }])
+      await wait(undefined, 750)
+
+      // pre-condition: the per-attendee status fired its own trigger
+      await async_test(
+        `event-wide completion setup: '${status}' attendee has the '${status}' tag`,
+        () => tagsOf(target.id),
+        { onResult: (tags: string[]) => tags.includes(TAG[status]) }
+      )
+
+      await markEventCompleted(event.id)
+      await wait(undefined, 1000)
+
+      await async_test(
+        `event-wide completion does NOT fire Completed for the '${status}' attendee`,
+        () => tagsOf(target.id),
+        { onResult: (tags: string[]) => !tags.includes(TAG['Completed']) }
+      )
+      await async_test(
+        `event-wide completion leaves the '${status}' attendee with only its own tag`,
+        () => tagsOf(target.id),
+        { onResult: (tags: string[]) => tags.length === 1 && tags.includes(TAG[status]) }
+      )
+      // guard against over-filtering: the un-statused attendee must still be completed
+      await async_test(
+        `event-wide completion still fires Completed for the active attendee (alongside '${status}')`,
+        () => tagsOf(active.id),
+        { onResult: (tags: string[]) => tags.includes(TAG['Completed']) }
+      )
+    }
+
+    // cancelledGroupAttendees with no attendeeStatuses entry — the shape written by the patient
+    // portal when an enduser cancels themselves out of a group event.
+    log_header("Event-wide completion respects legacy cancelledGroupAttendees")
+
+    const portalCancelled = await createEnduser()
+    const portalActive = await createEnduser()
+    const portalEvent = await createGroupEvent([portalCancelled.id, portalActive.id])
+
+    await sdk.api.calendar_events.updateOne(portalEvent.id, {
+      cancelledGroupAttendees: [{ id: portalCancelled.id, at: new Date() }],
+    }, { replaceObjectFields: true })
+    await wait(undefined, 750)
+
+    // pre-condition: the legacy branch fires Cancelled for them
+    await async_test(
+      "legacy cancelledGroupAttendees setup: attendee has the Cancelled tag",
+      () => tagsOf(portalCancelled.id),
+      { onResult: (tags: string[]) => tags.includes(TAG['Cancelled']) }
+    )
+
+    await markEventCompleted(portalEvent.id)
+    await wait(undefined, 1000)
+
+    await async_test(
+      "event-wide completion does NOT fire Completed for a cancelledGroupAttendees attendee",
+      () => tagsOf(portalCancelled.id),
+      { onResult: (tags: string[]) => !tags.includes(TAG['Completed']) }
+    )
+    await async_test(
+      "event-wide completion still fires Completed for the active attendee (legacy cancel case)",
+      () => tagsOf(portalActive.id),
+      { onResult: (tags: string[]) => tags.includes(TAG['Completed']) }
+    )
+
+    // ============================================================
+    // Over-filtering guards: 'Confirmed' and no-status attendees must still complete.
+    // ============================================================
+    log_header("Event-wide completion still fires for Confirmed / un-statused attendees")
+
+    const confirmed = await createEnduser()
+    const confirmedBystander = await createEnduser()
+    const confirmedEvent = await createGroupEvent([confirmed.id, confirmedBystander.id])
+
+    await setAttendeeStatuses(confirmedEvent.id, [{ id: confirmed.id, status: 'Confirmed' }])
+    await wait(undefined, 750)
+    await markEventCompleted(confirmedEvent.id)
+    await wait(undefined, 1000)
+
+    await async_test(
+      "event-wide completion fires Completed for a 'Confirmed' attendee",
+      () => tagsOf(confirmed.id),
+      { onResult: (tags: string[]) => tags.includes(TAG['Completed']) }
+    )
+    await async_test(
+      "event-wide completion fires Completed for the bystander alongside 'Confirmed'",
+      () => tagsOf(confirmedBystander.id),
+      { onResult: (tags: string[]) => tags.includes(TAG['Completed']) }
+    )
+
+    // baseline: a group event with no per-attendee statuses completes for everyone
+    const plain1 = await createEnduser()
+    const plain2 = await createEnduser()
+    const plain3 = await createEnduser()
+    const plainEvent = await createGroupEvent([plain1.id, plain2.id, plain3.id])
+
+    await markEventCompleted(plainEvent.id)
+    await wait(undefined, 1000)
+
+    const plainAttendees = [plain1, plain2, plain3]
+    for (let i = 0; i < plainAttendees.length; i++) {
+      const enduserId = plainAttendees[i].id
+      await async_test(
+        `event-wide completion fires Completed for un-statused attendee #${i + 1}`,
+        () => tagsOf(enduserId),
+        { onResult: (tags: string[]) => tags.includes(TAG['Completed']) }
+      )
+    }
+
   } finally {
     for (const id of createdEventIds) {
       try { await sdk.api.calendar_events.deleteOne(id) } catch (_) {}

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

@@ -0,0 +1,184 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  async_test,
+  log_header,
+  passOnAnyResult,
+} from "@tellescope/testing"
+import { MD_INTEGRATIONS_TITLE } from "@tellescope/constants"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+// MDI Trigger Refill journey action tests.
+//
+// Validator-acceptance plus handler-guard coverage: verifies that automation steps configured
+// with the new mdiTriggerRefill action pass validation (and invalid shapes are rejected), and
+// exercises the process endpoint's guard branches that return BEFORE any live MDI call (missing
+// integration, missing patient reference) — no sandbox credentials needed. The happy path
+// (fetch cases -> find scheduled orders -> submit) requires an MDI sandbox with a
+// Direct-to-Pharmacy refill sequence and is covered by manual QA.
+export const mdi_trigger_refill_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("MDI Trigger Refill Journey Action Tests")
+
+  let journeyId: string | undefined
+  const stepIds: string[] = []
+  const automatedActionIds: string[] = []
+  let enduserId: string | undefined
+  let createdMDIIntegrationId: string | undefined
+
+  try {
+    const journey = await sdk.api.journeys.createOne({ title: 'MDI Trigger Refill Test Journey' })
+    journeyId = journey.id
+
+    // Full config accepted
+    await async_test(
+      "mdiTriggerRefill step accepted (onlySubmitWhenDue)",
+      () => sdk.api.automation_steps.createOne({
+        journeyId: journey.id,
+        events: [{ type: 'onJourneyStart', info: {} }],
+        action: {
+          type: 'mdiTriggerRefill',
+          info: { onlySubmitWhenDue: true },
+        },
+      }).then(s => { stepIds.push(s.id); return s }),
+      passOnAnyResult,
+    )
+
+    // Empty info accepted (all fields optional)
+    await async_test(
+      "mdiTriggerRefill step accepted (empty info)",
+      () => sdk.api.automation_steps.createOne({
+        journeyId: journey.id,
+        events: [{ type: 'onJourneyStart', info: {} }],
+        action: {
+          type: 'mdiTriggerRefill',
+          info: {},
+        },
+      }).then(s => { stepIds.push(s.id); return s }),
+      passOnAnyResult,
+    )
+
+    // Wrong type for onlySubmitWhenDue rejected
+    await async_test(
+      "mdiTriggerRefill step rejected (non-boolean onlySubmitWhenDue)",
+      () => sdk.api.automation_steps.createOne({
+        journeyId: journey.id,
+        events: [{ type: 'onJourneyStart', info: {} }],
+        action: {
+          type: 'mdiTriggerRefill',
+          info: { onlySubmitWhenDue: 'yes' },
+        } as any,
+      }),
+      { shouldError: true, onError: () => true },
+    )
+
+    // Unexpected info fields are stripped by objectValidator, not rejected — assert they never
+    // reach the stored config (the step itself is accepted)
+    await async_test(
+      "mdiTriggerRefill step strips unexpected info field",
+      () => sdk.api.automation_steps.createOne({
+        journeyId: journey.id,
+        events: [{ type: 'onJourneyStart', info: {} }],
+        action: {
+          type: 'mdiTriggerRefill',
+          info: { onlySubmitWhenDue: false, formId: 'not-allowed' },
+        } as any,
+      }).then(s => { stepIds.push(s.id); return s }),
+      {
+        onResult: s => (
+          (s.action.info as any).onlySubmitWhenDue === false
+          && (s.action.info as any).formId === undefined
+        ),
+      },
+    )
+
+    // ── Handler guards (process endpoint) ────────────────────────────────────────
+    const enduser = await sdk.api.endusers.createOne({ fname: 'MDI', lname: 'RefillPatient' })
+    enduserId = enduser.id
+
+    // processAfter is set in the future so no background worker picks these up before the explicit call
+    const createAutomatedAction = () => sdk.api.automated_actions.createOne({
+      journeyId: journey!.id,
+      automationStepId: stepIds[0],
+      enduserId: enduser.id,
+      event: { type: 'onJourneyStart', info: {} },
+      action: { type: 'mdiTriggerRefill', info: {} },
+      status: 'active',
+      processAfter: new Date().getTime() + 60 * 60 * 1000,
+    } as any).then(a => { automatedActionIds.push(a.id); return a })
+
+    let mdiIntegrationExists = false
+    try {
+      const existing = await sdk.api.integrations.load_redacted({})
+      mdiIntegrationExists = !!existing.integrations.find((i: any) => i.title === MD_INTEGRATIONS_TITLE)
+    } catch { /* load not permitted — assume absent */ }
+
+    if (!mdiIntegrationExists) {
+      const noIntegrationAction = await createAutomatedAction()
+      await async_test(
+        "mdiTriggerRefill fails cleanly without an MDI integration",
+        () => sdk.api.automated_actions.process({ automatedActionId: noIntegrationAction.id }),
+        { onResult: (r: any) => r?.success === false && /MD Integrations integration not found/i.test(r?.error || '') },
+      )
+
+      try {
+        const created = await sdk.api.integrations.createOne({
+          title: MD_INTEGRATIONS_TITLE,
+          authentication: {
+            type: 'oauth2',
+            info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
+          },
+        } as any)
+        createdMDIIntegrationId = created.id
+        mdiIntegrationExists = true
+      } catch (e) {
+        console.log("Could not create an MDI integration; skipping patient-reference guard test:", e)
+      }
+    } else {
+      console.log("⏭️  Skipping mdiTriggerRefill missing-integration guard test (an MDI integration already exists)")
+    }
+
+    if (mdiIntegrationExists) {
+      // enduser has no MD Integrations reference — the guard returns before any outbound MDI call
+      const noReferenceAction = await createAutomatedAction()
+      await async_test(
+        "mdiTriggerRefill fails cleanly for an enduser with no MDI patient reference",
+        () => sdk.api.automated_actions.process({ automatedActionId: noReferenceAction.id }),
+        { onResult: (r: any) => r?.success === false && /no MD Integrations patient reference/i.test(r?.error || '') },
+      )
+    }
+  } finally {
+    for (const id of automatedActionIds) {
+      await sdk.api.automated_actions.deleteOne(id).catch(console.error)
+    }
+    if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(console.error)
+    if (createdMDIIntegrationId) await sdk.api.integrations.deleteOne(createdMDIIntegrationId).catch(console.error)
+    for (const id of stepIds) {
+      await sdk.api.automation_steps.deleteOne(id).catch(console.error)
+    }
+    if (journeyId) await sdk.api.journeys.deleteOne(journeyId).catch(console.error)
+  }
+}
+
+if (require.main === module) {
+  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 mdi_trigger_refill_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ MDI trigger refill test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ MDI trigger refill test suite failed:", error)
+      process.exit(1)
+    })
+}