@tellescope/sdk 1.242.9 → 1.243.0

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

@@ -0,0 +1,103 @@
+require('source-map-support').install();
+
+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
+
+export const concurrent_build_threads_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Concurrent Build Threads Test")
+
+  const timestamp = Date.now()
+  const from = new Date(Date.now() - 1000 * 60 * 60) // 1 hour ago
+
+  // Create a test enduser with a phone number
+  const testEnduser = await sdk.api.endusers.createOne({
+    fname: "ConcurrentTest",
+    lname: "Patient",
+    email: `concurrent-test-${timestamp}@test.com`,
+    phone: "+15555550101",
+  })
+
+  const phoneNumber = "+15555550102"
+  const enduserPhoneNumber = "+15555550101"
+
+  // Create a test SMS message for the enduser
+  const sms = await sdk.api.sms_messages.createOne({
+    enduserId: testEnduser.id,
+    phoneNumber,
+    enduserPhoneNumber,
+    message: 'Test message for concurrent build test',
+    inbound: true,
+    logOnly: true,
+  })
+
+  try {
+    // Reset threads first to ensure clean state
+    await sdk.api.inbox_threads.reset_threads()
+
+    // Fire 3 concurrent load_threads requests with autobuild: true
+    console.log("Firing 3 concurrent load_threads requests with autobuild: true...")
+    const results = await Promise.all([
+      sdk.api.inbox_threads.load_threads({ autobuild: true }),
+      sdk.api.inbox_threads.load_threads({ autobuild: true }),
+      sdk.api.inbox_threads.load_threads({ autobuild: true }),
+    ])
+
+    // Also fetch all threads to see if duplicates were created
+    const allThreadsResult = await sdk.api.inbox_threads.load_threads({})
+    const allThreads = allThreadsResult.threads
+
+    // Filter for threads belonging to our test enduser
+    const enduserThreads = allThreads.filter(t =>
+      t.enduserIds?.includes(testEnduser.id) && t.type === 'SMS'
+    )
+
+    console.log(`Found ${enduserThreads.length} SMS threads for test enduser`)
+
+    // Assert: should only have 1 thread, not duplicates
+    assert(
+      enduserThreads.length === 1,
+      `Expected 1 SMS thread for enduser, found ${enduserThreads.length}. ` +
+      `Thread IDs: ${enduserThreads.map(t => t.id).join(', ')}`
+    )
+
+    console.log("✅ Concurrent build test passed - no duplicate threads created")
+  } finally {
+    // Cleanup
+    console.log("Cleaning up test data...")
+    await sdk.api.sms_messages.deleteOne(sms.id)
+    await sdk.api.endusers.deleteOne(testEnduser.id)
+    // Clean up any threads created for this enduser
+    const cleanupThreads = await sdk.api.inbox_threads.load_threads({})
+    for (const thread of cleanupThreads.threads) {
+      if (thread.enduserIds?.includes(testEnduser.id)) {
+        await sdk.api.inbox_threads.deleteOne(thread.id)
+      }
+    }
+  }
+}
+
+if (require.main === module) {
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await concurrent_build_threads_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Concurrent build threads test completed")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Concurrent build threads test failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -4,10 +4,13 @@ import { Session } from "../../sdk"
 import {
   async_test,
   log_header,
+  wait,
 } from "@tellescope/testing"
 import { setup_tests } from "../setup"
+import { PROVIDER_PERMISSIONS } from "@tellescope/constants"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
+const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.env.NON_ADMIN_PASSWORD]
 
 // Main test function that can be called independently
 export const custom_aggregation_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
@@ -110,6 +113,77 @@ export const custom_aggregation_tests = async ({ sdk, sdkNonAdmin } : { sdk: Ses
       }}
     )
 
+    // ===== Role-Based Access Permission Tests =====
+    log_header("Custom Aggregation - Role-Based Access Tests")
+
+    // Create a role with No Access for engagement_events but full access for endusers
+    const noEngagementAccessRole = 'no-engagement-access-test'
+    const rbap = await sdk.api.role_based_access_permissions.createOne({
+      role: noEngagementAccessRole,
+      permissions: {
+        ...PROVIDER_PERMISSIONS,
+        // Override endusers to have full read access so we can test aggregation
+        endusers: {
+          create: 'All',
+          read: 'All',
+          update: 'All',
+          delete: 'All',
+        },
+        engagement_events: {
+          create: null,
+          read: null,
+          update: null,
+          delete: null,
+        },
+      },
+    })
+
+    // Save original role to restore later
+    const originalRoles = sdkNonAdmin.userInfo.roles
+
+    try {
+      // Assign the restricted role to non-admin user
+      await sdk.api.users.updateOne(sdkNonAdmin.userInfo.id, { roles: [noEngagementAccessRole] }, { replaceObjectFields: true })
+      await wait(undefined, 1500) // wait for role change to propagate
+      await sdkNonAdmin.authenticate(nonAdminEmail!, nonAdminPassword!)
+
+      // Test 6: Non-admin can still aggregate models they have access to (endusers)
+      await async_test(
+        "Custom aggregation - non-admin can access permitted models",
+        () => sdkNonAdmin.api.analytics_frames.custom_aggregation({
+          modelName: 'endusers',
+          aggregation: [
+            { $match: { fname: 'CustomAgg' } },
+            { $count: 'total' }
+          ]
+        }),
+        { onResult: r => r.result[0]?.total === 1 }
+      )
+
+      // Test 7: Non-admin is blocked from aggregating models with No Access
+      await async_test(
+        "Custom aggregation - non-admin blocked from No Access models",
+        () => sdkNonAdmin.api.analytics_frames.custom_aggregation({
+          modelName: 'engagement_events',
+          aggregation: [
+            { $match: {} },
+            { $count: 'total' }
+          ]
+        }),
+        { shouldError: true, onError: (e: any) => e.message === "You do not have access to this resource" }
+      )
+
+      console.log("✅ All custom aggregation role-based access tests passed")
+    } finally {
+      // Restore original role
+      await sdk.api.users.updateOne(sdkNonAdmin.userInfo.id, { roles: originalRoles }, { replaceObjectFields: true })
+      await wait(undefined, 1000)
+      await sdkNonAdmin.authenticate(nonAdminEmail!, nonAdminPassword!)
+
+      // Cleanup role
+      await sdk.api.role_based_access_permissions.deleteOne(rbap.id)
+    }
+
     console.log("✅ All custom aggregation tests passed")
   } finally {
     // Cleanup

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

@@ -0,0 +1,258 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  async_test,
+  log_header,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+export const custom_dashboards_tests = async ({ sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Custom Dashboards")
+
+  // Test 1: Create basic dashboard with minimal fields
+  const basicDashboard = await sdk.api.custom_dashboards.createOne({
+    title: "Test Dashboard",
+    blocks: [{ type: "Inbox", colSpan: 4 }],
+  })
+
+  await async_test(
+    "Basic dashboard created correctly",
+    async () => basicDashboard,
+    {
+      onResult: r => (
+        r.title === "Test Dashboard"
+        && r.blocks.length === 1
+        && r.blocks[0].type === "Inbox"
+        && r.blocks[0].colSpan === 4
+      )
+    }
+  )
+
+  // Test 1b: Duplicate titles are allowed
+  const duplicateTitleDashboard = await sdk.api.custom_dashboards.createOne({
+    title: "Test Dashboard",
+    blocks: [{ type: "Tickets", colSpan: 6 }],
+  })
+
+  await async_test(
+    "Duplicate title dashboard created successfully",
+    async () => duplicateTitleDashboard,
+    {
+      onResult: r => (
+        r.title === "Test Dashboard"
+        && r.id !== basicDashboard.id
+      )
+    }
+  )
+
+  // Test 2: Create dashboard with all fields
+  const fullDashboard = await sdk.api.custom_dashboards.createOne({
+    title: "Full Dashboard",
+    description: "A complete dashboard with all options",
+    blocks: [
+      { type: "Inbox", info: { showUnread: true }, colSpan: 4, rowSpan: 2 },
+      { type: "Tickets", info: { status: "open" }, colSpan: 4, rowSpan: 1 },
+      {
+        type: "CustomWidget",
+        info: { widgetId: "xyz", nestedConfig: { foo: "bar" } },
+        colSpan: 4,
+        responsive: {
+          sm: { colSpan: 12, hidden: false },
+          md: { colSpan: 6 },
+          lg: { colSpan: 4 }
+        },
+        style: { backgroundColor: "#ffffff", borderRadius: 8 }
+      },
+    ],
+    defaultForRoles: ["Admin", "Manager"],
+    hiddenFromRoles: ["Guest"],
+    defaultForUserIds: [],
+    gridConfig: { columns: 12, gap: 16, rowHeight: 100 },
+  })
+
+  await async_test(
+    "Full dashboard with all fields created correctly",
+    async () => fullDashboard,
+    {
+      onResult: r => (
+        r.blocks.length === 3
+        && r.gridConfig !== undefined && r.gridConfig.columns === 12
+        && r.gridConfig !== undefined && r.gridConfig.gap === 16
+        && r.defaultForRoles !== undefined && r.defaultForRoles.includes("Admin")
+        && r.blocks[2].responsive !== undefined && r.blocks[2].responsive.sm !== undefined && r.blocks[2].responsive.sm.colSpan === 12
+        && r.blocks[0].info !== undefined && r.blocks[0].info.showUnread === true
+      )
+    }
+  )
+
+  // Test 2b: Create dashboard with userIds
+  const dashboardWithUserIds = await sdk.api.custom_dashboards.createOne({
+    title: "Dashboard With UserIds",
+    blocks: [{ type: "Inbox", colSpan: 12 }],
+    userIds: [sdk.userInfo.id],
+  })
+
+  await async_test(
+    "Dashboard with userIds created correctly",
+    async () => dashboardWithUserIds,
+    {
+      onResult: r => (
+        r.userIds !== undefined
+        && r.userIds.length === 1
+        && r.userIds[0] === sdk.userInfo.id
+      )
+    }
+  )
+
+  // Test 3: Update dashboard title only (blocks array updates append by default)
+  const updatedTitle = await sdk.api.custom_dashboards.updateOne(basicDashboard.id, {
+    title: "Updated Dashboard",
+  })
+
+  await async_test(
+    "Dashboard title updated correctly",
+    async () => updatedTitle,
+    {
+      onResult: r => (
+        r.title === "Updated Dashboard"
+        && r.blocks.length === 1
+        && r.blocks[0].type === "Inbox"
+      )
+    }
+  )
+
+  // Test 3b: Create a new dashboard to test blocks with new block types
+  const dashboardWithNewTypes = await sdk.api.custom_dashboards.createOne({
+    title: "Dashboard With Custom Types",
+    blocks: [
+      { type: "Inbox", colSpan: 6 },
+      { type: "NewBlockType", info: { custom: "data", nested: { value: 123 } }, colSpan: 6 },
+    ],
+  })
+
+  await async_test(
+    "Dashboard with new block types created correctly",
+    async () => dashboardWithNewTypes,
+    {
+      onResult: r => (
+        r.blocks.length === 2
+        && r.blocks[1].type === "NewBlockType"
+        && r.blocks[1].info !== undefined && r.blocks[1].info.custom === "data"
+      )
+    }
+  )
+
+  // Test 4: Read dashboard by ID
+  const read = await sdk.api.custom_dashboards.getOne(dashboardWithNewTypes.id)
+
+  await async_test(
+    "Dashboard read by ID correctly",
+    async () => read,
+    {
+      onResult: r => (
+        r.id === dashboardWithNewTypes.id
+        && r.title === "Dashboard With Custom Types"
+      )
+    }
+  )
+
+  // Test 5: List dashboards
+  const list = await sdk.api.custom_dashboards.getSome({ filter: {} })
+
+  await async_test(
+    "Dashboard list returned",
+    async () => list,
+    { onResult: r => r.length >= 2 }
+  )
+
+  // Test 6: Create dashboard with complex/arbitrary block info to verify permissive validation
+  const dashboardWithComplexBlocks = await sdk.api.custom_dashboards.createOne({
+    title: "Complex Blocks Dashboard",
+    blocks: [
+      {
+        type: "ChartWidget",
+        info: {
+          chartType: "bar",
+          dataSource: "appointments",
+          dateRange: "30d",
+          colors: ["#ff0000", "#00ff00"],
+          aggregation: { field: "status", method: "count" }
+        },
+        colSpan: 8,
+        rowSpan: 2,
+      },
+    ],
+  })
+
+  await async_test(
+    "Dashboard with complex block info created correctly",
+    async () => dashboardWithComplexBlocks,
+    {
+      onResult: r => (
+        r.blocks[0].type === "ChartWidget"
+        && r.blocks[0].info !== undefined && r.blocks[0].info.chartType === "bar"
+        && r.blocks[0].info !== undefined && Array.isArray(r.blocks[0].info.colors) && r.blocks[0].info.colors.length === 2
+      )
+    }
+  )
+
+  // Test 7: Update gridConfig only
+  const updatedGridConfig = await sdk.api.custom_dashboards.updateOne(dashboardWithNewTypes.id, {
+    gridConfig: { columns: 24, gap: 8 },
+  })
+
+  await async_test(
+    "GridConfig updated correctly",
+    async () => updatedGridConfig,
+    {
+      onResult: r => (
+        r.gridConfig !== undefined && r.gridConfig.columns === 24
+        && r.gridConfig !== undefined && r.gridConfig.gap === 8
+      )
+    }
+  )
+
+  // Test 8: Non-admin can read all dashboards by default
+  const nonAdminList = await sdkNonAdmin.api.custom_dashboards.getSome({ filter: {} })
+
+  await async_test(
+    "Non-admin can read all dashboards",
+    async () => nonAdminList,
+    { onResult: r => r.length >= 2 }
+  )
+
+  // Cleanup
+  await Promise.all([
+    sdk.api.custom_dashboards.deleteOne(basicDashboard.id),
+    sdk.api.custom_dashboards.deleteOne(duplicateTitleDashboard.id),
+    sdk.api.custom_dashboards.deleteOne(fullDashboard.id),
+    sdk.api.custom_dashboards.deleteOne(dashboardWithUserIds.id),
+    sdk.api.custom_dashboards.deleteOne(dashboardWithNewTypes.id),
+    sdk.api.custom_dashboards.deleteOne(dashboardWithComplexBlocks.id),
+  ])
+}
+
+// Allow running this test file independently
+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 custom_dashboards_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Custom dashboards test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Custom dashboards test suite failed:", error)
+      process.exit(1)
+    })
+}