@tellescope/sdk 1.237.2 → 1.237.4

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

@@ -0,0 +1,193 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  async_test,
+  handleAnyError,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+// Main test function that can be called independently or from main test suite
+export const database_cascade_delete_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Database Cascade Delete Tests")
+
+  // Test 1: Create database and records, then delete database and verify records are cascade deleted
+  await async_test(
+    'cascade delete - deleting database deletes all database_records',
+    async () => {
+      // Create a test database
+      const database = await sdk.api.databases.createOne({
+        title: `__Test__CascadeDelete_${Date.now()}`,
+        fields: [
+          { type: 'Text', label: "Name" },
+          { type: 'Number', label: "Age" },
+        ],
+      })
+
+      // Create multiple database records
+      const records = await sdk.api.database_records.createSome([
+        {
+          databaseId: database.id,
+          values: [
+            { type: 'Text', value: 'Alice', label: 'Name' },
+            { type: 'Number', value: 25, label: 'Age' },
+          ],
+        },
+        {
+          databaseId: database.id,
+          values: [
+            { type: 'Text', value: 'Bob', label: 'Name' },
+            { type: 'Number', value: 30, label: 'Age' },
+          ],
+        },
+        {
+          databaseId: database.id,
+          values: [
+            { type: 'Text', value: 'Charlie', label: 'Name' },
+            { type: 'Number', value: 35, label: 'Age' },
+          ],
+        },
+      ])
+
+      const recordIds = records.created.map(r => r.id)
+      console.log(`Created database ${database.id} with ${recordIds.length} records`)
+
+      // Verify records exist before deletion
+      const recordsBefore = await sdk.api.database_records.getSome({ filter: { databaseId: database.id } })
+      if (recordsBefore.length !== 3) {
+        throw new Error(`Expected 3 records before delete, got ${recordsBefore.length}`)
+      }
+      console.log(`Verified ${recordsBefore.length} records exist before deletion`)
+
+      // Delete the database
+      await sdk.api.databases.deleteOne(database.id)
+      console.log(`Deleted database ${database.id}`)
+
+      // Wait a moment for cascade delete to propagate
+      await wait(undefined, 500)
+
+      // Verify all records were cascade deleted
+      const recordsAfter = await sdk.api.database_records.getSome({ filter: { databaseId: database.id } })
+
+      if (recordsAfter.length !== 0) {
+        throw new Error(`Expected 0 records after cascade delete, got ${recordsAfter.length}`)
+      }
+      console.log(`✓ Verified all records were cascade deleted`)
+
+      // Also verify individual record fetches return 404
+      for (const recordId of recordIds) {
+        try {
+          await sdk.api.database_records.getOne(recordId)
+          throw new Error(`Record ${recordId} should have been deleted but was still found`)
+        } catch (err: any) {
+          if (!err.message?.includes('Could not find') && !err.message?.includes('404')) {
+            throw new Error(`Unexpected error fetching deleted record: ${err.message}`)
+          }
+          // Expected: record not found
+        }
+      }
+      console.log(`✓ Verified individual record fetches return not found`)
+
+      return true
+    },
+    { onResult: (result) => result === true }
+  )
+
+  // Test 2: Verify database with no records can be deleted without error
+  await async_test(
+    'cascade delete - deleting empty database works',
+    async () => {
+      const database = await sdk.api.databases.createOne({
+        title: `__Test__EmptyDB_${Date.now()}`,
+        fields: [{ type: 'Text', label: "Field" }],
+      })
+
+      // Delete immediately without adding records
+      await sdk.api.databases.deleteOne(database.id)
+
+      // Verify database is gone
+      try {
+        await sdk.api.databases.getOne(database.id)
+        throw new Error('Database should have been deleted')
+      } catch (err: any) {
+        if (!err.message?.includes('Could not find') && !err.message?.includes('404')) {
+          throw new Error(`Unexpected error: ${err.message}`)
+        }
+      }
+
+      return true
+    },
+    { onResult: (result) => result === true }
+  )
+
+  // Test 3: Verify records from other databases are not affected
+  await async_test(
+    'cascade delete - only affects records from deleted database',
+    async () => {
+      // Create two databases
+      const database1 = await sdk.api.databases.createOne({
+        title: `__Test__DB1_${Date.now()}`,
+        fields: [{ type: 'Text', label: "Value" }],
+      })
+      const database2 = await sdk.api.databases.createOne({
+        title: `__Test__DB2_${Date.now()}`,
+        fields: [{ type: 'Text', label: "Value" }],
+      })
+
+      // Create records in both databases
+      await sdk.api.database_records.createOne({
+        databaseId: database1.id,
+        values: [{ type: 'Text', value: 'DB1 Record', label: 'Value' }],
+      })
+      const db2Record = await sdk.api.database_records.createOne({
+        databaseId: database2.id,
+        values: [{ type: 'Text', value: 'DB2 Record', label: 'Value' }],
+      })
+
+      // Delete database1
+      await sdk.api.databases.deleteOne(database1.id)
+      await wait(undefined, 500)
+
+      // Verify database2's record still exists
+      const db2RecordAfter = await sdk.api.database_records.getOne(db2Record.id)
+      if (!db2RecordAfter) {
+        throw new Error('Database2 record should still exist')
+      }
+      console.log(`✓ Verified database2 record was not affected by database1 deletion`)
+
+      // Cleanup database2
+      await sdk.api.databases.deleteOne(database2.id)
+
+      return true
+    },
+    { onResult: (result) => result === true }
+  )
+
+  console.log("✅ All Database Cascade Delete tests passed!")
+}
+
+// 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 database_cascade_delete_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Database cascade delete test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Database cascade delete test suite failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -503,6 +503,164 @@ export const inbox_thread_assignment_updates_tests = async ({ sdk, sdkNonAdmin }
     assert(emptyIdsResult.threads.length >= 3, 'Empty ids array should not filter (return all threads)')
     console.log("✅ ids filter empty array test passed")
 
+    // Test 24: sortBy parameter - default behavior (timestamp)
+    console.log("Testing sortBy parameter - default behavior...")
+
+    // Create threads with controlled timestamps for sort testing
+    const sortTestBaseTime = Date.now()
+    const sortThread1 = await sdk.api.inbox_threads.createOne({
+      ...defaultThreadFields,
+      type: "SMS",
+      title: "Sort Test Thread 1",
+      threadId: `sort-test-1-${timestamp}`,
+      phoneNumber: "+15555550001",
+      enduserPhoneNumber: "+15555550002",
+      timestamp: new Date(sortTestBaseTime - 3000), // oldest timestamp
+      outboundTimestamp: new Date(sortTestBaseTime), // newest outboundTimestamp
+    })
+
+    const sortThread2 = await sdk.api.inbox_threads.createOne({
+      ...defaultThreadFields,
+      type: "SMS",
+      title: "Sort Test Thread 2",
+      threadId: `sort-test-2-${timestamp}`,
+      phoneNumber: "+15555550003",
+      enduserPhoneNumber: "+15555550004",
+      timestamp: new Date(sortTestBaseTime - 1000), // newest timestamp
+      outboundTimestamp: new Date(sortTestBaseTime - 3000), // oldest outboundTimestamp
+    })
+
+    const sortThread3 = await sdk.api.inbox_threads.createOne({
+      ...defaultThreadFields,
+      type: "SMS",
+      title: "Sort Test Thread 3",
+      threadId: `sort-test-3-${timestamp}`,
+      phoneNumber: "+15555550005",
+      enduserPhoneNumber: "+15555550006",
+      timestamp: new Date(sortTestBaseTime - 2000), // middle timestamp
+      outboundTimestamp: new Date(sortTestBaseTime - 2000), // middle outboundTimestamp
+    })
+
+    // Test default sort (should be by timestamp descending)
+    const defaultSortResult = await sdk.api.inbox_threads.load_threads({
+      ids: [sortThread1.id, sortThread2.id, sortThread3.id]
+    })
+    assert(defaultSortResult.threads.length === 3, 'Should return 3 sort test threads')
+    assert(defaultSortResult.threads[0].id === sortThread2.id, 'Default sort: newest timestamp should be first')
+    assert(defaultSortResult.threads[1].id === sortThread3.id, 'Default sort: middle timestamp should be second')
+    assert(defaultSortResult.threads[2].id === sortThread1.id, 'Default sort: oldest timestamp should be last')
+    console.log("✅ sortBy default behavior test passed")
+
+    // Test 25: sortBy='timestamp' explicit
+    console.log("Testing sortBy='timestamp' explicit...")
+    const timestampSortResult = await sdk.api.inbox_threads.load_threads({
+      ids: [sortThread1.id, sortThread2.id, sortThread3.id],
+      sortBy: 'timestamp'
+    })
+    assert(timestampSortResult.threads[0].id === sortThread2.id, 'Explicit timestamp sort: newest should be first')
+    assert(timestampSortResult.threads[1].id === sortThread3.id, 'Explicit timestamp sort: middle should be second')
+    assert(timestampSortResult.threads[2].id === sortThread1.id, 'Explicit timestamp sort: oldest should be last')
+    console.log("✅ sortBy='timestamp' test passed")
+
+    // Test 26: sortBy='outboundTimestamp'
+    console.log("Testing sortBy='outboundTimestamp'...")
+    const outboundSortResult = await sdk.api.inbox_threads.load_threads({
+      ids: [sortThread1.id, sortThread2.id, sortThread3.id],
+      sortBy: 'outboundTimestamp'
+    })
+    assert(outboundSortResult.threads[0].id === sortThread1.id, 'OutboundTimestamp sort: newest outbound should be first')
+    assert(outboundSortResult.threads[1].id === sortThread3.id, 'OutboundTimestamp sort: middle outbound should be second')
+    assert(outboundSortResult.threads[2].id === sortThread2.id, 'OutboundTimestamp sort: oldest outbound should be last')
+    console.log("✅ sortBy='outboundTimestamp' test passed")
+
+    // Cleanup sort test threads
+    await Promise.all([
+      sdk.api.inbox_threads.deleteOne(sortThread1.id),
+      sdk.api.inbox_threads.deleteOne(sortThread2.id),
+      sdk.api.inbox_threads.deleteOne(sortThread3.id),
+    ])
+
+    // ========== InboxStatus Preservation Tests ==========
+    // These tests verify that outbound messages do NOT reset inboxStatus
+
+    // Test 27: Outbound SMS should NOT reset inboxStatus
+    console.log("Testing outbound SMS should NOT reset inboxStatus...")
+
+    const statusTestSMS1 = await sdk.api.sms_messages.createOne({
+      message: "Inbound test message for status test",
+      enduserId: testEnduser.id,
+      inbound: true,
+      phoneNumber: "+15555559999",
+      enduserPhoneNumber: "+15555559876",
+      logOnly: true,
+    })
+
+    // Build threads using reset_threads + build_threads pattern
+    const statusTestFrom = new Date(Date.now() - 60000)
+    await sdk.api.inbox_threads.reset_threads()
+    await sdk.api.inbox_threads.build_threads({ from: statusTestFrom, to: new Date() })
+
+    const statusTestThreads = await sdk.api.inbox_threads.load_threads({})
+    const statusTestThread = statusTestThreads.threads.find(t =>
+      t.type === 'SMS' && t.enduserIds.includes(testEnduser.id) && t.phoneNumber === "+15555559999"
+    )
+    assert(!!statusTestThread, "Status test SMS thread should be created")
+    assert(statusTestThread!.inboxStatus === 'New', `Initial status should be 'New', got '${statusTestThread!.inboxStatus}'`)
+
+    // Update thread status to "Resolved"
+    await sdk.api.inbox_threads.updateOne(statusTestThread!.id, { inboxStatus: "Resolved" })
+
+    // Create outbound SMS (should NOT reset status)
+    const statusTestSMS2 = await sdk.api.sms_messages.createOne({
+      message: "Outbound reply - should not reset status",
+      enduserId: testEnduser.id,
+      inbound: false,
+      phoneNumber: "+15555559999",
+      enduserPhoneNumber: "+15555559876",
+      logOnly: true,
+    })
+
+    // Rebuild threads - status should remain "Resolved"
+    await sdk.api.inbox_threads.build_threads({ from: statusTestFrom, to: new Date() })
+
+    const threadAfterOutbound = (await sdk.api.inbox_threads.load_threads({ ids: [statusTestThread!.id] })).threads[0]
+    assert(threadAfterOutbound.inboxStatus === 'Resolved', `Status should remain 'Resolved' after outbound message, got '${threadAfterOutbound.inboxStatus}'`)
+    assert(!!threadAfterOutbound.outboundTimestamp, "outboundTimestamp should be set after outbound message")
+
+    console.log("✅ Outbound SMS does NOT reset inboxStatus test passed")
+
+    // Test 28: New inbound SMS SHOULD update inboxStatus
+    console.log("Testing new inbound SMS SHOULD update inboxStatus...")
+
+    // Wait to ensure ObjectId timestamps are in different seconds (MongoDB ObjectIds have second-level precision)
+    await new Promise(resolve => setTimeout(resolve, 1100))
+
+    const statusTestSMS3 = await sdk.api.sms_messages.createOne({
+      message: "New inbound - should update status",
+      enduserId: testEnduser.id,
+      inbound: true,
+      phoneNumber: "+15555559999",
+      enduserPhoneNumber: "+15555559876",
+      inboxStatus: "New",
+      logOnly: true,
+    })
+
+    // Rebuild threads - status SHOULD be updated from new inbound
+    await sdk.api.inbox_threads.build_threads({ from: statusTestFrom, to: new Date() })
+
+    const threadAfterNewInbound = (await sdk.api.inbox_threads.load_threads({ ids: [statusTestThread!.id] })).threads[0]
+    assert(threadAfterNewInbound.inboxStatus === 'New', `Status SHOULD be 'New' after new inbound message, got '${threadAfterNewInbound.inboxStatus}'`)
+
+    console.log("✅ New inbound SMS DOES update inboxStatus test passed")
+
+    // Cleanup status preservation test resources
+    await Promise.all([
+      sdk.api.sms_messages.deleteOne(statusTestSMS1.id),
+      sdk.api.sms_messages.deleteOne(statusTestSMS2.id),
+      sdk.api.sms_messages.deleteOne(statusTestSMS3.id),
+      sdk.api.inbox_threads.deleteOne(statusTestThread!.id),
+    ])
+
     console.log("🎉 All InboxThread assignment update tests passed!")
 
   } finally {

package/src/tests/tests.ts

@@ -77,6 +77,7 @@ import { custom_aggregation_tests } from "./api_tests/custom_aggregation.test";
 import { bulk_assignment_tests } from "./api_tests/bulk_assignment.test";
 import { managed_content_enduser_access_tests } from "./api_tests/managed_content_enduser_access.test";
 import { auto_merge_form_submission_tests } from "./api_tests/auto_merge_form_submission.test";
+import { database_cascade_delete_tests } from "./api_tests/database_cascade_delete.test";
 
 const UniquenessViolationMessage = 'Uniqueness Violation'
 
@@ -5835,6 +5836,9 @@ export const databases_tests = async () => {
     sdk.api.databases.deleteOne(database.id),
     sdk.api.databases.deleteOne(databaseNoRead.id),
   ])
+
+  // Run cascade delete tests
+  await database_cascade_delete_tests({ sdk, sdkNonAdmin })
 }
 
 export const filter_by_date_tests = async () => {
@@ -12364,6 +12368,25 @@ const replace_enduser_template_values_tests = async () => {
   const d = Date.now()
   assert(replace_enduser_template_values(d as any, enduser) === d as any, 'fail non-string', 'non-string')
 
+  // Test height/weight subfields with values present
+  const enduserWithVitals = await sdk.api.endusers.createOne({
+    fname: "Vitals",
+    height: { value: 72, unit: 'inches' },
+    weight: { value: 180, unit: 'lbs' }
+  })
+
+  assert(replace_enduser_template_values('{{enduser.height.value}}', enduserWithVitals) === '72', 'fail height.value', 'height.value')
+  assert(replace_enduser_template_values('{{enduser.height.unit}}', enduserWithVitals) === 'inches', 'fail height.unit', 'height.unit')
+  assert(replace_enduser_template_values('{{enduser.weight.value}}', enduserWithVitals) === '180', 'fail weight.value', 'weight.value')
+  assert(replace_enduser_template_values('{{enduser.weight.unit}}', enduserWithVitals) === 'lbs', 'fail weight.unit', 'weight.unit')
+
+  // Test undefined safeguards - enduser without height/weight should return empty string
+  assert(replace_enduser_template_values('{{enduser.height.value}}', enduser) === '', 'fail undefined height.value', 'undefined height.value')
+  assert(replace_enduser_template_values('{{enduser.height.unit}}', enduser) === '', 'fail undefined height.unit', 'undefined height.unit')
+  assert(replace_enduser_template_values('{{enduser.weight.value}}', enduser) === '', 'fail undefined weight.value', 'undefined weight.value')
+  assert(replace_enduser_template_values('{{enduser.weight.unit}}', enduser) === '', 'fail undefined weight.unit', 'undefined weight.unit')
+
+  await sdk.api.endusers.deleteOne(enduserWithVitals.id)
   await sdk.api.endusers.deleteOne(enduser.id)
 }