@tellescope/sdk 1.255.19 → 1.256.0

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

@@ -408,8 +408,100 @@ export const custom_dashboards_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sessi
     { shouldError: true, onError: () => true }
   )
 
+  // Test 10: Dashboard mutations stream through /v1/data-sync
+  const syncFrom = new Date()
+  const dashboard_sync_records = (results: { modelName: string, recordId: string, data: string }[], recordId: string) => (
+    results.filter(r => r.modelName === 'custom_dashboards' && r.recordId === recordId)
+  )
+
+  const syncedDashboard = await sdk.api.custom_dashboards.createOne({
+    title: "Sync Create Dashboard",
+    blocks: [{ type: "Inbox", colSpan: 12 }],
+  })
+  await wait(undefined, 100) // sync_record is not awaited by the mutation handler
+
+  await async_test(
+    "Dashboard create streams to sync, admin",
+    () => sdk.sync({ from: syncFrom }),
+    {
+      onResult: ({ results }) => {
+        const records = dashboard_sync_records(results, syncedDashboard.id)
+        return (
+          records.length === 1
+          && records[0].data !== 'deleted'
+          && JSON.parse(records[0].data).title === "Sync Create Dashboard"
+        )
+      }
+    }
+  )
+
+  await sdk.api.custom_dashboards.updateOne(syncedDashboard.id, { title: "Sync Update Dashboard" })
+  await wait(undefined, 100)
+
+  await async_test(
+    "Dashboard update streams to sync, admin",
+    () => sdk.sync({ from: syncFrom }),
+    {
+      onResult: ({ results }) => {
+        const records = dashboard_sync_records(results, syncedDashboard.id)
+        return (
+          records.length === 1
+          && records[0].data !== 'deleted'
+          && JSON.parse(records[0].data).title === "Sync Update Dashboard"
+        )
+      }
+    }
+  )
+
+  await sdk.api.custom_dashboards.deleteOne(syncedDashboard.id)
+  await wait(undefined, 100)
+
+  await async_test(
+    "Dashboard delete streams to sync, admin",
+    () => sdk.sync({ from: syncFrom }),
+    {
+      onResult: ({ results }) => {
+        const records = dashboard_sync_records(results, syncedDashboard.id)
+        return records.length === 1 && records[0].data === 'deleted'
+      }
+    }
+  )
+
+  // Restricted user (read: Default) only receives org-wide and assigned dashboards
+  const restrictedSyncFrom = new Date()
+
+  // re-save each fixture so it lands in the restricted user's sync window
+  await Promise.all([
+    sdk.api.custom_dashboards.updateOne(orgWideDashboard.id, { description: "org-wide sync" }),
+    sdk.api.custom_dashboards.updateOne(assignedDashboard.id, { description: "assigned sync" }),
+    sdk.api.custom_dashboards.updateOne(hiddenDashboard.id, { description: "hidden sync" }),
+    sdk.api.custom_dashboards.updateOne(explicitFalseDashboard.id, { description: "explicit false sync" }),
+  ])
+  await wait(undefined, 100)
+
+  await async_test(
+    "Restricted user syncs org-wide and assigned dashboards only",
+    () => sdkRestricted.sync({ from: restrictedSyncFrom }),
+    {
+      onResult: ({ results }) => (
+        dashboard_sync_records(results, orgWideDashboard.id).length === 1
+        && dashboard_sync_records(results, assignedDashboard.id).length === 1
+        && dashboard_sync_records(results, hiddenDashboard.id).length === 0
+        && dashboard_sync_records(results, explicitFalseDashboard.id).length === 0
+      )
+    }
+  )
+
   // Toggling the flag on takes effect for the restricted user
+  const toggleSyncFrom = new Date()
   await sdk.api.custom_dashboards.updateOne(hiddenDashboard.id, { visibleToAllUsers: true })
+  await wait(undefined, 100)
+
+  await async_test(
+    "Restricted user syncs dashboard after visibleToAllUsers enabled",
+    () => sdkRestricted.sync({ from: toggleSyncFrom }),
+    { onResult: ({ results }) => dashboard_sync_records(results, hiddenDashboard.id).length === 1 }
+  )
 
   await async_test(
     "Restricted user can read dashboard after visibleToAllUsers enabled",

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

@@ -0,0 +1,223 @@
+require('source-map-support').install();
+
+import axios from "axios"
+import * as buffer from 'buffer'
+import { Session } from "../../sdk"
+import {
+  assert,
+  log_header,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+/**
+ * A presigned download URL signs response-content-disposition, which S3 validates: it rejects any
+ * value containing a character above U+00FF with 400 InvalidArgument "Header value cannot be
+ * represented using ISO-8859-1", and one with unbalanced quoting with "open quoted span". Because
+ * the parameter is part of the signature it cannot be repaired after the fact, so before the fix a
+ * file named with an em dash or a decomposed accent got a 200 from our API and a permanent 400 from
+ * S3 on every fetch.
+ *
+ * This test is the end-to-end check: it uploads files with those names and actually fetches the
+ * returned URL, which is the only thing that exercises S3's validation.
+ */
+
+// Built from code points rather than written out, so that this file stays pure ASCII and so that a
+// combining accent (which renders as a mark on the preceding character) is unambiguous in source.
+const c = (n: number) => String.fromCharCode(n)
+const EM_DASH         = c(0x2014)
+const EN_DASH         = c(0x2013)
+const RIGHT_SINGLE_Q  = c(0x2019)
+const COMBINING_ACUTE = c(0x0301)
+const CJK_BAO_GAO     = c(0x62a5) + c(0x544a)
+
+const IS_ASCII_ONLY = /^[\x20-\x7e]*$/
+
+// The first three are the real filenames from the bug report.
+const TEST_NAMES: { name: string, label: string, expectExtValue: boolean }[] = [
+  {
+    name: `First Aid Classes Information${EM_DASH}NWLI.pdf`,
+    label: 'em dash (U+2014)',
+    expectExtValue: true,
+  },
+  {
+    name: `CHA${RIGHT_SINGLE_Q}s Waitlist Portal ${EN_DASH} Apply.pdf`,
+    label: 'right single quote (U+2019) and en dash (U+2013)',
+    expectExtValue: true,
+  },
+  {
+    name: `Ren${'e' + COMBINING_ACUTE} Test  .pdf`,
+    label: 'decomposed accent (e + U+0301)',
+    expectExtValue: true,
+  },
+  {
+    name: `He said "hi".pdf`,
+    label: 'a double quote, which S3 rejects as an open quoted span',
+    expectExtValue: true,
+  },
+  {
+    name: `${CJK_BAO_GAO}.pdf`,
+    label: 'an entirely non-ASCII name, so the fallback cannot come from the name',
+    expectExtValue: true,
+  },
+  {
+    name: `plain ascii control.pdf`,
+    label: 'control: a plain ASCII name that always worked',
+    expectExtValue: true, // the space means filename* is emitted, carrying the real spaces
+  },
+]
+
+export const file_download_unicode_names_tests = async ({ sdk }: { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("File Download URL with Unicode Filenames")
+
+  const fileIds: string[] = []
+
+  const uploadFile = async (name: string) => {
+    const buff = buffer.Buffer.from(`test file content for ${JSON.stringify(name)}`)
+    const { presignedUpload, file } = await sdk.api.files.prepare_file_upload({
+      name,
+      type: 'application/pdf',
+      size: buff.byteLength,
+    })
+    await sdk.UPLOAD(presignedUpload as any, buff)
+    await sdk.api.files.confirm_file_upload({ id: file.id })
+    fileIds.push(file.id)
+    return { file, contents: buff }
+  }
+
+  // validateStatus so that a failure reports S3's actual status and XML <Message>, rather than an
+  // opaque axios throw. That is what makes this test diagnostic instead of merely red.
+  const fetchURL = (url: string) => axios.get(url, {
+    responseType: 'arraybuffer',
+    validateStatus: () => true,
+  })
+
+  try {
+    for (const { name, label, expectExtValue } of TEST_NAMES) {
+      const { file, contents } = await uploadFile(name)
+
+      const { downloadURL, name: returnedName } = await sdk.api.files.file_download_URL({
+        secureName: file.secureName,
+      })
+
+      assert(
+        returnedName === name,
+        `endpoint returned "${returnedName}" instead of the stored name for ${label}`,
+        `stored name round-trips for ${label}`,
+      )
+
+      const response = await fetchURL(downloadURL)
+
+      // the bug: our API returned 200, S3 returned 400 on every fetch of the URL it gave us
+      assert(
+        response.status === 200,
+        `S3 returned ${response.status} for ${label}: ${buffer.Buffer.from(response.data ?? '').toString().slice(0, 400)}`,
+        `S3 returns 200 for ${label}`,
+      )
+
+      assert(
+        buffer.Buffer.from(response.data).toString() === contents.toString(),
+        `downloaded bytes did not match for ${label}`,
+        `downloaded bytes match for ${label}`,
+      )
+
+      const disposition = (response.headers['content-disposition'] ?? '') as string
+
+      assert(
+        IS_ASCII_ONLY.test(disposition),
+        `Content-Disposition was not ASCII-only for ${label}: ${disposition}`,
+        `Content-Disposition is ASCII-only for ${label}`,
+      )
+      assert(
+        disposition.startsWith('attachment;'),
+        `expected an attachment disposition for ${label}, got: ${disposition}`,
+        `disposition is attachment for ${label}`,
+      )
+      assert(
+        expectExtValue === disposition.includes(`filename*=UTF-8''`),
+        `filename* presence was wrong for ${label}: ${disposition}`,
+        `filename* ${expectExtValue ? 'present' : 'absent'} for ${label}`,
+      )
+    }
+
+    /* ---------------------------------------------------------------- *
+     * The download URL is cached server-side. preferInBrowser changes
+     * whether a Content-Disposition is signed into the URL at all, so it
+     * has to be part of the cache key - otherwise whichever variant is
+     * requested first is served to everyone for ~99 minutes.
+     * ---------------------------------------------------------------- */
+    const { file: cacheFile, contents: cacheContents } = await uploadFile(
+      `Cache Test${EM_DASH}Both Variants.pdf`
+    )
+
+    const asAttachment = await sdk.api.files.file_download_URL({ secureName: cacheFile.secureName })
+    const inBrowser = await sdk.api.files.file_download_URL({
+      secureName: cacheFile.secureName,
+      preferInBrowser: true,
+    })
+
+    assert(
+      asAttachment.downloadURL !== inBrowser.downloadURL,
+      'preferInBrowser returned the cached attachment URL, so the cache key ignores it',
+      'preferInBrowser is cached separately from the attachment URL',
+    )
+    assert(
+      asAttachment.downloadURL.includes('response-content-disposition'),
+      'the default URL was signed without a content disposition',
+      'the default URL signs a content disposition',
+    )
+    assert(
+      !inBrowser.downloadURL.includes('response-content-disposition'),
+      'the preferInBrowser URL was signed with a content disposition',
+      'the preferInBrowser URL omits the content disposition',
+    )
+
+    for (const [variant, { downloadURL }] of [['attachment', asAttachment], ['inBrowser', inBrowser]] as const) {
+      const response = await fetchURL(downloadURL)
+      assert(
+        response.status === 200,
+        `S3 returned ${response.status} for the ${variant} URL: ${buffer.Buffer.from(response.data ?? '').toString().slice(0, 400)}`,
+        `S3 returns 200 for the ${variant} URL`,
+      )
+      assert(
+        buffer.Buffer.from(response.data).toString() === cacheContents.toString(),
+        `downloaded bytes did not match for the ${variant} URL`,
+        `downloaded bytes match for the ${variant} URL`,
+      )
+    }
+
+    // a repeat request with identical arguments must still hit the cache
+    const repeated = await sdk.api.files.file_download_URL({ secureName: cacheFile.secureName })
+    assert(
+      repeated.downloadURL === asAttachment.downloadURL,
+      'an identical repeat request did not hit the cache',
+      'an identical repeat request hits the cache',
+    )
+  } finally {
+    for (const id of fileIds) {
+      await sdk.api.files.deleteOne(id).catch(() => {})
+    }
+  }
+}
+
+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 file_download_unicode_names_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("File download unicode names test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("File download unicode names test suite failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -5,6 +5,7 @@ import {
   assert,
   async_test,
   log_header,
+  wait,
 } from "@tellescope/testing"
 import { setup_tests } from "../setup"
 
@@ -80,9 +81,12 @@ export const openloop_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sessi
 
   const healthieId1 = 'test-healthie-ol-1'
   const healthieId2 = 'test-healthie-ol-2'
+  const healthieId3 = 'test-healthie-ol-3'
 
   const enduser1 = await sdk.api.endusers.createOne({ source: 'Healthie', externalId: healthieId1 })
   const enduser2 = await sdk.api.endusers.createOne({ source: 'Healthie', externalId: healthieId2 })
+  // dedicated to the frequency-trigger section, so tag assertions stay isolated
+  const enduser3 = await sdk.api.endusers.createOne({ source: 'Healthie', externalId: healthieId3 })
 
   try {
     // ===== SECTION A: V1 Validation =====
@@ -272,6 +276,84 @@ export const openloop_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sessi
       { onResult: (r: boolean) => r === true }
     )
 
+    await async_test(
+      'V1: order_shipped updates frequency when weeksOrdered changes',
+      async () => {
+        const orderNum = `ol-ship-weeks-${uid()}`
+        // OLH confirms with weeksOrdered=w4
+        await postV1(makeV1Confirmation({
+          patientID: healthieId1,
+          orderNumber: orderNum,
+          weeksOrdered: 'w4',
+        }))
+
+        // ...then ships the same order with a different weeksOrdered, which is the value to trigger on
+        const res = await postV1(makeV1Shipped({
+          patientID: healthieId1,
+          orderNumber: orderNum,
+          weeksOrdered: 'w8',
+        }))
+        assert(res.status === 200, `Expected 200, got ${res.status}`)
+
+        const orders = await sdk.api.enduser_orders.getSome({
+          filter: { source: 'OpenLoop', externalId: orderNum }
+        })
+        assert(orders.length === 1, `Expected 1 order, got ${orders.length}`)
+        assert(orders[0].frequency === 'w8', `frequency should reflect the shipped event: ${orders[0].frequency}`)
+        return true
+      },
+      { onResult: (r: boolean) => r === true }
+    )
+
+    await async_test(
+      'V1: order_shipped without weeksOrdered preserves confirmed frequency',
+      async () => {
+        const orderNum = `ol-ship-noweeks-${uid()}`
+        await postV1(makeV1Confirmation({
+          patientID: healthieId1,
+          orderNumber: orderNum,
+          weeksOrdered: 'w4',
+        }))
+
+        // makeV1Shipped has no weeksOrdered default, so this ships without restating it
+        const res = await postV1(makeV1Shipped({
+          patientID: healthieId1,
+          orderNumber: orderNum,
+        }))
+        assert(res.status === 200, `Expected 200, got ${res.status}`)
+
+        const orders = await sdk.api.enduser_orders.getSome({
+          filter: { source: 'OpenLoop', externalId: orderNum }
+        })
+        assert(orders.length === 1, `Expected 1 order, got ${orders.length}`)
+        assert(orders[0].frequency === 'w4', `frequency should not be cleared: ${orders[0].frequency}`)
+        return true
+      },
+      { onResult: (r: boolean) => r === true }
+    )
+
+    await async_test(
+      'V1: order_shipped creates new order with frequency',
+      async () => {
+        const orderNum = `ol-ship-new-weeks-${uid()}`
+        // never confirmed, first seen as shipped
+        const res = await postV1(makeV1Shipped({
+          patientID: healthieId1,
+          orderNumber: orderNum,
+          weeksOrdered: 'w12',
+        }))
+        assert(res.status === 200, `Expected 200, got ${res.status}`)
+
+        const orders = await sdk.api.enduser_orders.getSome({
+          filter: { source: 'OpenLoop', externalId: orderNum }
+        })
+        assert(orders.length === 1, `Expected 1 order, got ${orders.length}`)
+        assert(orders[0].frequency === 'w12', `frequency mismatch: ${orders[0].frequency}`)
+        return true
+      },
+      { onResult: (r: boolean) => r === true }
+    )
+
     await async_test(
       'V1: order_shipped creates new order if none exists',
       async () => {
@@ -695,11 +777,67 @@ export const openloop_webhooks_tests = async ({ sdk, sdkNonAdmin }: { sdk: Sessi
       { onResult: (r: boolean) => r === true }
     )
 
+    // ===== SECTION J: V1 weeksOrdered drives Order Status Equals triggers =====
+    // The reason the shipped event's weeksOrdered matters: it is what the frequencies filter matches on.
+    log_header("V1 weeksOrdered trigger integration")
+
+    // Runs last so these OpenLoop/shipped triggers can't tag endusers used by earlier sections.
+    const shippedTrigger = await sdk.api.automation_triggers.createOne({
+      event: { type: 'Order Status Equals', info: { source: 'OpenLoop', status: 'shipped', frequencies: ['w8'] } },
+      action: { type: 'Add Tags', info: { tags: ['OLH Shipped w8'] } },
+      status: 'Active',
+      title: "OpenLoop shipped with weeksOrdered w8",
+    })
+    const staleTrigger = await sdk.api.automation_triggers.createOne({
+      event: { type: 'Order Status Equals', info: { source: 'OpenLoop', status: 'shipped', frequencies: ['w4'] } },
+      action: { type: 'Add Tags', info: { tags: ['OLH Shipped w4'] } },
+      status: 'Active',
+      title: "OpenLoop shipped with weeksOrdered w4",
+    })
+
+    try {
+      await async_test(
+        'V1: shipped weeksOrdered is what Order Status Equals matches on',
+        async () => {
+          const orderNum = `ol-ship-trigger-${uid()}`
+          await postV1(makeV1Confirmation({
+            patientID: healthieId3,
+            orderNumber: orderNum,
+            weeksOrdered: 'w4',
+          }))
+          const res = await postV1(makeV1Shipped({
+            patientID: healthieId3,
+            orderNumber: orderNum,
+            weeksOrdered: 'w8',
+          }))
+          assert(res.status === 200, `Expected 200, got ${res.status}`)
+
+          await wait(undefined, 2000) // allow triggers to happen
+
+          const updated = await sdk.api.endusers.getOne(enduser3.id)
+          assert(
+            !!updated.tags?.includes('OLH Shipped w8'),
+            `expected the shipped weeksOrdered to fire its trigger, tags: ${JSON.stringify(updated.tags)}`
+          )
+          assert(
+            !updated.tags?.includes('OLH Shipped w4'),
+            `the stale confirmed weeksOrdered should not fire, tags: ${JSON.stringify(updated.tags)}`
+          )
+          return true
+        },
+        { onResult: (r: boolean) => r === true }
+      )
+    } finally {
+      await sdk.api.automation_triggers.deleteOne(shippedTrigger.id).catch(console.error)
+      await sdk.api.automation_triggers.deleteOne(staleTrigger.id).catch(console.error)
+    }
+
     console.log("All OpenLoop webhook tests passed!")
 
   } finally {
     await sdk.api.endusers.deleteOne(enduser1.id).catch(console.error)
     await sdk.api.endusers.deleteOne(enduser2.id).catch(console.error)
+    await sdk.api.endusers.deleteOne(enduser3.id).catch(console.error)
   }
 }
 

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

@@ -6,11 +6,13 @@ import {
   handleAnyError,
   log_header,
 } from "@tellescope/testing"
+import { FULL_ACCESS, PROVIDER_PERMISSIONS } from "@tellescope/constants"
 import { setup_tests } from "../setup"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
 const NONEXISTENT_MONGO_ID = '60398b1131a295e64f084fff'
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
 // Validation-path tests for the cold transfer endpoint. All assertions below hit
 // validations that run before any Twilio access, so no Twilio config is needed.
@@ -19,6 +21,7 @@ export const phone_calls_cold_transfer_tests = async ({ sdk, sdkNonAdmin } : { s
 
   const enduser = await sdk.api.endusers.createOne({ fname: 'Cold', lname: 'Transfer' })
   const targetUsers: { id: string }[] = []
+  const createdRoleIds: string[] = []
 
   try {
     const inboundCall = await sdk.api.phone_calls.createOne({
@@ -81,11 +84,62 @@ export const phone_calls_cold_transfer_tests = async ({ sdk, sdkNonAdmin } : { s
       () => sdkNonAdmin.api.phone_calls.cold_transfer({ callSid: inboundCall.externalId, targetUserId: disabledTargetUser.id }),
       handleAnyError
     )
+
+    // ── target-user lookup must be gated by users READ access, not the endpoint's update access ──
+    // PROVIDER_PERMISSIONS already models the reported bug: users read='All', update='Default'.
+    // phone_calls gets FULL_ACCESS so the call itself is visible under update-level filtering.
+    const mkRoleUser = async (permissions: any) => {
+      const role = `cold-transfer-${RAND()}`
+      const rbap = await sdk.api.role_based_access_permissions.createOne({ role, permissions })
+      createdRoleIds.push(rbap.id)
+
+      const user = await sdk.api.users.createOne({
+        email: `cold.transfer.${RAND()}@tellescope.example`,
+        fname: 'Cold', lname: 'TransferRole',
+        notificationEmailsDisabled: true, verifiedEmail: true,
+        roles: [role],
+      } as any)
+      targetUsers.push(user)
+
+      const { authToken, user: sessionUser } = await sdk.api.users.generate_auth_token({ id: user.id })
+      const session = new Session({ host })
+      session.setAuthToken(authToken)
+      session.setUserInfo(sessionUser as any)
+      return session
+    }
+
+    const sdkUpdateDefault = await mkRoleUser({ ...PROVIDER_PERMISSIONS, phone_calls: FULL_ACCESS })
+    const sdkReadDefault = await mkRoleUser({
+      ...PROVIDER_PERMISSIONS,
+      phone_calls: FULL_ACCESS,
+      users: { create: null, read: 'Default', update: 'Default', delete: null },
+    })
+
+    // regression: previously failed with "Target user not found" because the lookup was
+    // filtered by users update='Default' (self-only); getting past it to the
+    // incoming-calls-disabled validation proves the lookup now uses read access
+    await async_test(
+      "cold_transfer: users update=Default no longer blocks the target lookup",
+      () => sdkUpdateDefault.api.phone_calls.cold_transfer({ callSid: inboundCall.externalId, targetUserId: disabledTargetUser.id }),
+      { shouldError: true, onError: (e: any) => e.message === "Target user has incoming calls disabled" }
+    )
+    // guard: the lookup is read-filtered (not org-wide) — users read='Default' still can't see the target
+    await async_test(
+      "cold_transfer: users read=Default still hides the target user",
+      () => sdkReadDefault.api.phone_calls.cold_transfer({ callSid: inboundCall.externalId, targetUserId: disabledTargetUser.id }),
+      { shouldError: true, onError: (e: any) => e.message === "Target user not found" }
+    )
+    await async_test(
+      "cold_transfer: nonexistent target still rejected for restricted role",
+      () => sdkUpdateDefault.api.phone_calls.cold_transfer({ callSid: inboundCall.externalId, targetUserId: NONEXISTENT_MONGO_ID }),
+      { shouldError: true, onError: (e: any) => e.message === "Target user not found" }
+    )
   } finally {
     // deleting the enduser cascades deletion of its phone_calls records
     await Promise.all([
       sdk.api.endusers.deleteOne(enduser.id),
       ...targetUsers.map(u => sdk.api.users.deleteOne(u.id)),
+      ...createdRoleIds.map(id => sdk.api.role_based_access_permissions.deleteOne(id)),
     ]).catch(console.error)
   }
 }