@tellescope/sdk 1.237.2 → 1.237.3

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,83 @@ 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),
+    ])
+
     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 () => {