@tellescope/sdk 1.246.2 → 1.247.0

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

@@ -0,0 +1,418 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  async_test,
+  assert,
+  handleAnyError,
+  log_header,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+export const calendar_events_bulk_update_tests = async ({ sdk }: { sdk: Session }) => {
+  log_header("Calendar Events Bulk Update Tests")
+
+  // Track all created resources for cleanup
+  const createdEventIds: string[] = []
+  const createdEnduserIds: string[] = []
+
+  const createEvent = async (overrides: Record<string, any> = {}) => {
+    const event = await sdk.api.calendar_events.createOne({
+      title: "Bulk Update Test Event",
+      durationInMinutes: 30,
+      startTimeInMS: Date.now() + Math.random() * 100000,
+      ...overrides,
+    })
+    createdEventIds.push(event.id)
+    return event
+  }
+
+  const createEnduser = async () => {
+    const enduser = await sdk.api.endusers.createOne({})
+    createdEnduserIds.push(enduser.id)
+    return enduser
+  }
+
+  try {
+    // ============================================================
+    // SECTION 1: Validation / Error Cases
+    // ============================================================
+    log_header("Bulk Update - Validation")
+
+    await async_test(
+      "bulk_update errors when neither recurringEventId nor ids provided",
+      () => sdk.api.calendar_events.bulk_update({ action: 'cancel' } as any),
+      { shouldError: true, onError: (e: any) => e.message.includes("Either recurringEventId or ids is required") }
+    )
+
+    const validationEvent = await createEvent()
+
+    await async_test(
+      "bulk_update errors when both recurringEventId and ids provided",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: validationEvent.id,
+        ids: [validationEvent.id],
+        action: 'cancel',
+      }),
+      { shouldError: true, onError: (e: any) => e.message.includes("Provide either recurringEventId or ids, not both") }
+    )
+
+    const validationEnduser = await createEnduser()
+
+    await async_test(
+      "bulk_update errors when attendee-level action used with ids",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [validationEvent.id],
+        action: 'cancel_for_attendee',
+        enduserId: validationEnduser.id,
+      }),
+      { shouldError: true, onError: (e: any) => e.message.includes("only supported with recurringEventId") }
+    )
+
+    await async_test(
+      "bulk_update errors when attendee action missing enduserId",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: validationEvent.id,
+        action: 'cancel_for_attendee',
+      }),
+      { shouldError: true, onError: (e: any) => e.message.includes("enduserId is required") }
+    )
+
+    // ============================================================
+    // SECTION 2: ID-based bulk operations (new feature)
+    // ============================================================
+    log_header("Bulk Update - ID-based Cancel")
+
+    const [ev1, ev2, ev3] = await Promise.all([createEvent(), createEvent(), createEvent()])
+
+    await async_test(
+      "bulk cancel by IDs cancels selected events",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [ev1.id, ev2.id],
+        action: 'cancel',
+        cancelReason: 'Testing bulk cancel',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 2
+          && r.updated.every((e: any) => !!e.cancelledAt)
+          && r.updated.every((e: any) => e.cancelReason === 'Testing bulk cancel')
+        )
+      }
+    )
+
+    // Verify third event is unchanged
+    const ev3After = await sdk.api.calendar_events.getOne(ev3.id)
+    assert(!ev3After.cancelledAt, 'Third event should not be cancelled', 'Third event remains uncancelled')
+
+    // --- Uncancel ---
+    log_header("Bulk Update - ID-based Uncancel")
+
+    await async_test(
+      "bulk uncancel by IDs restores cancelled events",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [ev1.id, ev2.id],
+        action: 'uncancel',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 2
+          && r.updated.every((e: any) => !e.cancelledAt)
+        )
+      }
+    )
+
+    // --- Confirm ---
+    log_header("Bulk Update - ID-based Confirm")
+
+    await async_test(
+      "bulk confirm by IDs sets confirmedAt",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [ev1.id, ev2.id],
+        action: 'confirm',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 2
+          && r.updated.every((e: any) => !!e.confirmedAt)
+        )
+      }
+    )
+
+    // --- Idempotency: confirm already-confirmed ---
+    await async_test(
+      "bulk confirm on already-confirmed events returns empty updated",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [ev1.id, ev2.id],
+        action: 'confirm',
+      }),
+      { onResult: (r: any) => r.updated.length === 0 }
+    )
+
+    // --- No Show ---
+    log_header("Bulk Update - ID-based No Show")
+
+    await async_test(
+      "bulk no_show by IDs sets noShowedAt",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [ev1.id, ev2.id],
+        action: 'no_show',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 2
+          && r.updated.every((e: any) => !!e.noShowedAt)
+        )
+      }
+    )
+
+    // --- Un-No-Show ---
+    log_header("Bulk Update - ID-based Un-No-Show")
+
+    await async_test(
+      "bulk un_no_show by IDs clears noShowedAt",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [ev1.id, ev2.id],
+        action: 'un_no_show',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 2
+          && r.updated.every((e: any) => !e.noShowedAt)
+        )
+      }
+    )
+
+    // --- Delete by IDs ---
+    log_header("Bulk Update - ID-based Delete")
+
+    const [delEv1, delEv2] = await Promise.all([createEvent(), createEvent()])
+
+    await async_test(
+      "bulk delete by IDs removes events",
+      () => sdk.api.calendar_events.bulk_update({
+        ids: [delEv1.id, delEv2.id],
+        action: 'delete',
+      }),
+      { onResult: (r: any) => r.deleted.length === 2 }
+    )
+
+    // Verify deleted events are gone
+    await async_test(
+      "deleted events are no longer accessible",
+      () => sdk.api.calendar_events.getOne(delEv1.id),
+      { shouldError: true, onError: (e: any) => e.message.includes("Could not find") }
+    )
+
+    // Remove from cleanup tracking since already deleted
+    createdEventIds.splice(createdEventIds.indexOf(delEv1.id), 1)
+    createdEventIds.splice(createdEventIds.indexOf(delEv2.id), 1)
+
+    // ============================================================
+    // SECTION 3: Recurring series operations
+    // ============================================================
+    log_header("Bulk Update - Recurring Series")
+
+    const now = Date.now()
+    const DAY = 24 * 60 * 60 * 1000
+    const enduser = await createEnduser()
+
+    // Create a "recurring series": root event + child events with copiedFrom
+    const rootEvent = await createEvent({
+      title: "Recurring Root",
+      startTimeInMS: now - 2 * DAY, // 2 days ago
+      attendees: [{ id: enduser.id, type: 'enduser' }],
+    })
+    const childEvent1 = await createEvent({
+      title: "Recurring Child 1",
+      startTimeInMS: now - 1 * DAY, // 1 day ago
+      copiedFrom: rootEvent.id,
+      attendees: [{ id: enduser.id, type: 'enduser' }],
+    })
+    const childEvent2 = await createEvent({
+      title: "Recurring Child 2",
+      startTimeInMS: now + 1 * DAY, // tomorrow
+      copiedFrom: rootEvent.id,
+      attendees: [{ id: enduser.id, type: 'enduser' }],
+    })
+    const childEvent3 = await createEvent({
+      title: "Recurring Child 3",
+      startTimeInMS: now + 2 * DAY, // 2 days from now
+      copiedFrom: rootEvent.id,
+      attendees: [{ id: enduser.id, type: 'enduser' }],
+    })
+
+    // --- Cancel with scope 'this_and_future' ---
+    log_header("Bulk Update - Recurring Cancel this_and_future")
+
+    await async_test(
+      "recurring cancel this_and_future cancels anchor and future events",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: childEvent2.id,
+        action: 'cancel',
+        scope: 'this_and_future',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 2
+          && r.updated.every((e: any) => !!e.cancelledAt)
+          && r.updated.some((e: any) => e.id === childEvent2.id)
+          && r.updated.some((e: any) => e.id === childEvent3.id)
+        )
+      }
+    )
+
+    // Verify earlier events were NOT cancelled
+    const rootAfter = await sdk.api.calendar_events.getOne(rootEvent.id)
+    assert(!rootAfter.cancelledAt, 'Root should not be cancelled', 'Root event not cancelled by this_and_future')
+    const child1After = await sdk.api.calendar_events.getOne(childEvent1.id)
+    assert(!child1After.cancelledAt, 'Child 1 should not be cancelled', 'Child 1 not cancelled by this_and_future')
+
+    // --- Uncancel with scope 'all' to reset ---
+    await sdk.api.calendar_events.bulk_update({
+      recurringEventId: rootEvent.id,
+      action: 'uncancel',
+      scope: 'all',
+    })
+
+    // --- Cancel with scope 'all' ---
+    log_header("Bulk Update - Recurring Cancel All")
+
+    await async_test(
+      "recurring cancel all cancels entire series",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: childEvent1.id,
+        action: 'cancel',
+        scope: 'all',
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 4
+          && r.updated.every((e: any) => !!e.cancelledAt)
+        )
+      }
+    )
+
+    // Reset: uncancel all
+    await sdk.api.calendar_events.bulk_update({
+      recurringEventId: rootEvent.id,
+      action: 'uncancel',
+      scope: 'all',
+    })
+
+    // --- Cancel for attendee ---
+    log_header("Bulk Update - Recurring Cancel for Attendee")
+
+    await async_test(
+      "cancel_for_attendee adds enduser to cancelledGroupAttendees across series",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: rootEvent.id,
+        action: 'cancel_for_attendee',
+        scope: 'all',
+        enduserId: enduser.id,
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 4
+          && r.updated.every((e: any) =>
+            e.cancelledGroupAttendees?.some((c: any) => c.id === enduser.id)
+          )
+        )
+      }
+    )
+
+    // --- Uncancel for attendee ---
+    log_header("Bulk Update - Recurring Uncancel for Attendee")
+
+    await async_test(
+      "uncancel_for_attendee removes enduser from cancelledGroupAttendees",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: rootEvent.id,
+        action: 'uncancel_for_attendee',
+        scope: 'all',
+        enduserId: enduser.id,
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 4
+          && r.updated.every((e: any) =>
+            !e.cancelledGroupAttendees?.some((c: any) => c.id === enduser.id)
+          )
+        )
+      }
+    )
+
+    // --- Remove attendee ---
+    log_header("Bulk Update - Recurring Remove Attendee")
+
+    await async_test(
+      "remove_attendee removes enduser from attendees across series",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: rootEvent.id,
+        action: 'remove_attendee',
+        scope: 'all',
+        enduserId: enduser.id,
+      }),
+      {
+        onResult: (r: any) => (
+          r.updated.length === 4
+          && r.updated.every((e: any) =>
+            !e.attendees?.some((a: any) => a.id === enduser.id)
+          )
+        )
+      }
+    )
+
+    // --- Recurring delete ---
+    log_header("Bulk Update - Recurring Delete")
+
+    await async_test(
+      "recurring delete removes all events in series",
+      () => sdk.api.calendar_events.bulk_update({
+        recurringEventId: rootEvent.id,
+        action: 'delete',
+        scope: 'all',
+      }),
+      { onResult: (r: any) => r.deleted.length === 4 }
+    )
+
+    // Remove from cleanup tracking since already deleted
+    for (const id of [rootEvent.id, childEvent1.id, childEvent2.id, childEvent3.id]) {
+      const idx = createdEventIds.indexOf(id)
+      if (idx !== -1) createdEventIds.splice(idx, 1)
+    }
+
+  } finally {
+    // Cleanup remaining resources
+    for (const id of createdEventIds) {
+      try { await sdk.api.calendar_events.deleteOne(id) } catch (_) {}
+    }
+    for (const id of createdEnduserIds) {
+      try { await sdk.api.endusers.deleteOne(id) } catch (_) {}
+    }
+  }
+}
+
+// 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 calendar_events_bulk_update_tests({ sdk })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Calendar events bulk update test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Calendar events bulk update test suite failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -0,0 +1,259 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  assert,
+  async_test,
+  log_header,
+} 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
+export const mdb_sort_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("mdbSort Custom Sorting Support")
+
+  // Create test endusers with known field values for sorting
+  const testEndusers = await Promise.all([
+    sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Smith', email: 'alice-mdbsort@tellescope.com' }),
+    sdk.api.endusers.createOne({ fname: 'Bob', lname: 'Jones', email: 'bob-mdbsort@tellescope.com' }),
+    sdk.api.endusers.createOne({ fname: 'Charlie', lname: 'Adams', email: 'charlie-mdbsort@tellescope.com' }),
+    sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Zeta', email: 'alice2-mdbsort@tellescope.com' }), // Same fname for multi-field test
+  ])
+
+  const enduserIds = testEndusers.map(e => e.id)
+
+  try {
+    // Test 1: Sort by fname ascending (alphabetical order)
+    await async_test(
+      'mdbSort-fname-ascending',
+      async () => {
+        const results = await sdk.api.endusers.getSome({
+          filter: { id: { _in: enduserIds } },
+          mdbSort: { fname: 1 },
+        })
+        assert(results.length === 4, 'Expected 4 endusers', `Got ${results.length}`)
+
+        // Verify alphabetical order: Alice, Alice, Bob, Charlie
+        assert(results[0].fname === 'Alice', 'First should be Alice')
+        assert(results[1].fname === 'Alice', 'Second should be Alice')
+        assert(results[2].fname === 'Bob', 'Third should be Bob')
+        assert(results[3].fname === 'Charlie', 'Fourth should be Charlie')
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+    // Test 2: Sort by fname descending (reverse alphabetical order)
+    await async_test(
+      'mdbSort-fname-descending',
+      async () => {
+        const results = await sdk.api.endusers.getSome({
+          filter: { id: { _in: enduserIds } },
+          mdbSort: { fname: -1 },
+        })
+        assert(results.length === 4, 'Expected 4 endusers')
+
+        // Verify reverse alphabetical order: Charlie, Bob, Alice, Alice
+        assert(results[0].fname === 'Charlie', 'First should be Charlie')
+        assert(results[1].fname === 'Bob', 'Second should be Bob')
+        assert(results[2].fname === 'Alice', 'Third should be Alice')
+        assert(results[3].fname === 'Alice', 'Fourth should be Alice')
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+    // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
+    await async_test(
+      'mdbSort-multi-field',
+      async () => {
+        const results = await sdk.api.endusers.getSome({
+          filter: { id: { _in: enduserIds } },
+          mdbSort: { fname: 1, lname: 1 },
+        })
+        assert(results.length === 4, 'Expected 4 endusers')
+
+        // Verify multi-field sort:
+        // Alice Smith (fname: Alice, lname: Smith)
+        // Alice Zeta  (fname: Alice, lname: Zeta)
+        // Bob Jones   (fname: Bob)
+        // Charlie Adams (fname: Charlie)
+        assert(results[0].fname === 'Alice' && results[0].lname === 'Smith', 'First should be Alice Smith')
+        assert(results[1].fname === 'Alice' && results[1].lname === 'Zeta', 'Second should be Alice Zeta')
+        assert(results[2].fname === 'Bob', 'Third should be Bob')
+        assert(results[3].fname === 'Charlie', 'Fourth should be Charlie')
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+    // Test 4: mdbSort combined with mdbFilter
+    await async_test(
+      'mdbSort-with-mdbFilter',
+      async () => {
+        const results = await sdk.api.endusers.getSome({
+          mdbFilter: {
+            email: { $in: ['alice-mdbsort@tellescope.com', 'alice2-mdbsort@tellescope.com'] },
+            fname: 'Alice', // Only get Alice endusers
+          },
+          mdbSort: { lname: 1 }, // Sort by last name
+        })
+        assert(results.length === 2, 'Expected 2 Alice endusers', `Got ${results.length}`)
+
+        // Verify both are Alice and sorted by lname: Smith, then Zeta
+        assert(results[0].fname === 'Alice' && results[0].lname === 'Smith', 'First Alice should be Smith')
+        assert(results[1].fname === 'Alice' && results[1].lname === 'Zeta', 'Second Alice should be Zeta')
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+    // Test 5: mdbSort keyset pagination via mdbFilter $or
+    // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
+    // must be expressed in mdbFilter.
+    await async_test(
+      'mdbSort-keyset-pagination',
+      async () => {
+        const testEmails = [
+          'alice-mdbsort@tellescope.com',
+          'alice2-mdbsort@tellescope.com',
+          'bob-mdbsort@tellescope.com',
+          'charlie-mdbsort@tellescope.com',
+        ]
+
+        // Page 1: first 2 results sorted by fname ascending → both Alices
+        const page1 = await sdk.api.endusers.getSome({
+          mdbFilter: { email: { $in: testEmails } },
+          mdbSort: { fname: 1 },
+          limit: 2,
+        })
+        assert(page1.length === 2, 'Expected 2 endusers on page 1')
+        assert(page1[0].fname === 'Alice', 'Page 1 first should be Alice')
+        assert(page1[1].fname === 'Alice', 'Page 1 second should be Alice')
+
+        // Page 2: keyset cursor — fname > last seen fname ('Alice')
+        const lastFname = page1[page1.length - 1].fname
+        const page2 = await sdk.api.endusers.getSome({
+          mdbFilter: {
+            email: { $in: testEmails },
+            fname: { $gt: lastFname },
+          },
+          mdbSort: { fname: 1 },
+          limit: 2,
+        })
+        assert(page2.length === 2, 'Expected 2 endusers on page 2')
+        assert(page2[0].fname === 'Bob', 'Page 2 first should be Bob')
+        assert(page2[1].fname === 'Charlie', 'Page 2 second should be Charlie')
+
+        return [...page1, ...page2]
+      },
+      { onResult: () => true },
+    )
+
+    // Test 6: mdbSort with projection (ensure both work together)
+    await async_test(
+      'mdbSort-with-projection',
+      async () => {
+        const results = await sdk.api.endusers.getSome({
+          filter: { id: { _in: enduserIds } },
+          mdbSort: { fname: -1 },
+          projection: { fname: 1, lname: 1 },
+        })
+        assert(results.length === 4, 'Expected 4 endusers')
+
+        // Verify sort order (descending)
+        assert(results[0].fname === 'Charlie', 'First should be Charlie')
+
+        // Verify projection (only fname, lname, plus id and createdAt)
+        assert(results[0].fname !== undefined, 'fname should be present')
+        assert(results[0].lname !== undefined, 'lname should be present')
+        assert((results[0] as any).email === undefined, 'email should NOT be present')
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+    // Test 7: Non-admin access with mdbSort (RBA still applies)
+    await async_test(
+      'non-admin-mdbSort',
+      async () => {
+        const results = await sdkNonAdmin.api.endusers.getSome({
+          filter: { id: { _in: enduserIds } },
+          mdbSort: { fname: 1 },
+        })
+
+        // Non-admin should still get results (RBA should apply)
+        assert(Array.isArray(results), 'Non-admin should receive an array response')
+
+        // Verify sort order
+        if (results.length >= 2) {
+          const fnames = results.map(e => e.fname)
+          // Should be sorted alphabetically
+          assert(fnames[0]! <= fnames[1]!, 'Non-admin results should be sorted')
+        }
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+    // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
+    await async_test(
+      'no-mdbSort-fallback',
+      async () => {
+        // Without mdbSort, should fall back to default sorting by _id
+        const results = await sdk.api.endusers.getSome({
+          filter: { id: { _in: enduserIds } },
+          sortBy: 'updatedAt',
+          sort: 'oldFirst',
+        })
+        assert(results.length === 4, 'Expected 4 endusers')
+
+        // Verify traditional sortBy still works when mdbSort not provided
+        assert(results[0].id !== undefined, 'Should return valid endusers')
+
+        return results
+      },
+      { onResult: () => true },
+    )
+
+  } finally {
+    // Cleanup: Delete test resources
+    try {
+      for (const enduserId of enduserIds) {
+        await sdk.api.endusers.deleteOne(enduserId)
+      }
+    } catch (error) {
+      console.error('Cleanup error:', error)
+    }
+  }
+}
+
+// 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 mdb_sort_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ mdbSort test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ mdbSort test suite failed:", error)
+      process.exit(1)
+    })
+}