@tellescope/sdk 1.246.2 → 1.248.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/date_string_validation.test.ts

@@ -0,0 +1,107 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  assert,
+  log_header,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+import { is_valid_mm_dd_yyyy } from "@tellescope/validation"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+export const date_string_validation_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Date String Validation Tests (is_valid_mm_dd_yyyy)")
+
+  // --- Valid standard dates ---
+  assert(is_valid_mm_dd_yyyy('01-15-1990') === true, 'Expected 01-15-1990 to be valid', 'valid: 01-15-1990')
+  assert(is_valid_mm_dd_yyyy('12-31-2024') === true, 'Expected 12-31-2024 to be valid', 'valid: 12-31-2024')
+  assert(is_valid_mm_dd_yyyy('06-15-2000') === true, 'Expected 06-15-2000 to be valid', 'valid: 06-15-2000')
+  assert(is_valid_mm_dd_yyyy('01-01-2000') === true, 'Expected 01-01-2000 to be valid', 'valid: 01-01-2000')
+
+  // --- Leap year: Feb 29 accepted ---
+  assert(is_valid_mm_dd_yyyy('02-29-2024') === true, 'Expected 02-29-2024 to be valid (2024 is leap year, div by 4)', 'valid: 02-29-2024 (leap year)')
+  assert(is_valid_mm_dd_yyyy('02-29-2000') === true, 'Expected 02-29-2000 to be valid (2000 is leap year, div by 400)', 'valid: 02-29-2000 (leap year)')
+  assert(is_valid_mm_dd_yyyy('02-29-2400') === true, 'Expected 02-29-2400 to be valid (2400 is leap year, div by 400)', 'valid: 02-29-2400 (leap year)')
+
+  // --- Non-leap year: Feb 29 rejected ---
+  assert(is_valid_mm_dd_yyyy('02-29-2023') === false, 'Expected 02-29-2023 to be invalid (2023 is not a leap year)', 'invalid: 02-29-2023 (not leap year)')
+  assert(is_valid_mm_dd_yyyy('02-29-1900') === false, 'Expected 02-29-1900 to be invalid (1900 div by 100 but not 400)', 'invalid: 02-29-1900 (not leap year)')
+  assert(is_valid_mm_dd_yyyy('02-29-2100') === false, 'Expected 02-29-2100 to be invalid (2100 div by 100 but not 400)', 'invalid: 02-29-2100 (not leap year)')
+  assert(is_valid_mm_dd_yyyy('02-29-2025') === false, 'Expected 02-29-2025 to be invalid (2025 is not a leap year)', 'invalid: 02-29-2025 (not leap year)')
+
+  // --- Feb 30 and Feb 31 always rejected (the original bug) ---
+  assert(is_valid_mm_dd_yyyy('02-30-2024') === false, 'Expected 02-30-2024 to be invalid (Feb never has 30 days)', 'invalid: 02-30-2024 (Feb 30 leap year)')
+  assert(is_valid_mm_dd_yyyy('02-31-2024') === false, 'Expected 02-31-2024 to be invalid (Feb never has 31 days)', 'invalid: 02-31-2024 (Feb 31 leap year)')
+  assert(is_valid_mm_dd_yyyy('02-30-2023') === false, 'Expected 02-30-2023 to be invalid (Feb never has 30 days)', 'invalid: 02-30-2023 (Feb 30 non-leap)')
+  assert(is_valid_mm_dd_yyyy('02-31-2023') === false, 'Expected 02-31-2023 to be invalid (Feb never has 31 days)', 'invalid: 02-31-2023 (Feb 31 non-leap)')
+
+  // --- Feb 28 always valid ---
+  assert(is_valid_mm_dd_yyyy('02-28-2024') === true, 'Expected 02-28-2024 to be valid', 'valid: 02-28-2024')
+  assert(is_valid_mm_dd_yyyy('02-28-2023') === true, 'Expected 02-28-2023 to be valid', 'valid: 02-28-2023')
+
+  // --- 30-day months: day 31 rejected ---
+  assert(is_valid_mm_dd_yyyy('04-31-2024') === false, 'Expected 04-31-2024 to be invalid (April has 30 days)', 'invalid: 04-31 (April)')
+  assert(is_valid_mm_dd_yyyy('06-31-2024') === false, 'Expected 06-31-2024 to be invalid (June has 30 days)', 'invalid: 06-31 (June)')
+  assert(is_valid_mm_dd_yyyy('09-31-2024') === false, 'Expected 09-31-2024 to be invalid (September has 30 days)', 'invalid: 09-31 (September)')
+  assert(is_valid_mm_dd_yyyy('11-31-2024') === false, 'Expected 11-31-2024 to be invalid (November has 30 days)', 'invalid: 11-31 (November)')
+
+  // --- 30-day months: day 30 accepted ---
+  assert(is_valid_mm_dd_yyyy('04-30-2024') === true, 'Expected 04-30-2024 to be valid', 'valid: 04-30 (April)')
+  assert(is_valid_mm_dd_yyyy('06-30-2024') === true, 'Expected 06-30-2024 to be valid', 'valid: 06-30 (June)')
+  assert(is_valid_mm_dd_yyyy('09-30-2024') === true, 'Expected 09-30-2024 to be valid', 'valid: 09-30 (September)')
+  assert(is_valid_mm_dd_yyyy('11-30-2024') === true, 'Expected 11-30-2024 to be valid', 'valid: 11-30 (November)')
+
+  // --- 31-day months: day 31 accepted ---
+  assert(is_valid_mm_dd_yyyy('01-31-2024') === true, 'Expected 01-31-2024 to be valid', 'valid: 01-31 (January)')
+  assert(is_valid_mm_dd_yyyy('03-31-2024') === true, 'Expected 03-31-2024 to be valid', 'valid: 03-31 (March)')
+  assert(is_valid_mm_dd_yyyy('05-31-2024') === true, 'Expected 05-31-2024 to be valid', 'valid: 05-31 (May)')
+  assert(is_valid_mm_dd_yyyy('07-31-2024') === true, 'Expected 07-31-2024 to be valid', 'valid: 07-31 (July)')
+  assert(is_valid_mm_dd_yyyy('08-31-2024') === true, 'Expected 08-31-2024 to be valid', 'valid: 08-31 (August)')
+  assert(is_valid_mm_dd_yyyy('10-31-2024') === true, 'Expected 10-31-2024 to be valid', 'valid: 10-31 (October)')
+  assert(is_valid_mm_dd_yyyy('12-31-2024') === true, 'Expected 12-31-2024 to be valid', 'valid: 12-31 (December)')
+
+  // --- Invalid month values ---
+  assert(is_valid_mm_dd_yyyy('00-15-2024') === false, 'Expected month 00 to be invalid', 'invalid: month 00')
+  assert(is_valid_mm_dd_yyyy('13-15-2024') === false, 'Expected month 13 to be invalid', 'invalid: month 13')
+
+  // --- Invalid day values ---
+  assert(is_valid_mm_dd_yyyy('01-00-2024') === false, 'Expected day 00 to be invalid', 'invalid: day 00')
+  assert(is_valid_mm_dd_yyyy('01-32-2024') === false, 'Expected day 32 to be invalid', 'invalid: day 32')
+
+  // --- Malformed strings ---
+  assert(is_valid_mm_dd_yyyy('') === false, 'Expected empty string to be invalid', 'invalid: empty string')
+  assert(is_valid_mm_dd_yyyy('not-a-date') === false, 'Expected text to be invalid', 'invalid: text')
+  assert(is_valid_mm_dd_yyyy('2024-01-15') === false, 'Expected YYYY-MM-DD to be invalid', 'invalid: YYYY-MM-DD format')
+  assert(is_valid_mm_dd_yyyy('1-15-2024') === false, 'Expected single-digit month to be invalid', 'invalid: single-digit month')
+  assert(is_valid_mm_dd_yyyy('01/15/2024') === false, 'Expected slashes to be invalid', 'invalid: slashes')
+  assert(is_valid_mm_dd_yyyy('01-15-24') === false, 'Expected 2-digit year to be invalid', 'invalid: 2-digit year')
+  assert(is_valid_mm_dd_yyyy('01-5-2024') === false, 'Expected single-digit day to be invalid', 'invalid: single-digit day')
+  assert(is_valid_mm_dd_yyyy('01-15-20240') === false, 'Expected 5-digit year to be invalid', 'invalid: 5-digit year')
+
+  // --- Whitespace trimming ---
+  assert(is_valid_mm_dd_yyyy(' 01-15-1990 ') === true, 'Expected trimmed whitespace to be valid', 'valid: whitespace trimmed')
+  assert(is_valid_mm_dd_yyyy('  02-28-2024  ') === true, 'Expected trimmed whitespace to be valid', 'valid: whitespace trimmed (2)')
+}
+
+// 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 date_string_validation_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("Date string validation test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("Date string validation test suite failed:", error)
+      process.exit(1)
+    })
+}

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

@@ -0,0 +1,138 @@
+require('source-map-support').install();
+
+import { Session, EnduserSession } 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
+const businessId = '60398b1131a295e64f084ff6'
+
+// Main test function that can be called independently
+export const enduser_session_invalidation_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Enduser Session Invalidation Tests")
+
+  // Create test enduser
+  const testEnduser = await sdk.api.endusers.createOne({ email: `session-invalidation-test-${Date.now()}@tellescope.com` })
+
+  try {
+    // Generate auth token for the enduser
+    const { authToken } = await sdk.api.endusers.generate_auth_token({ id: testEnduser.id })
+    const enduserSDK = new EnduserSession({ host, authToken, businessId: sdk.userInfo.businessId })
+
+    // Test 1: Enduser authenticated before invalidation
+    await async_test(
+      'enduser authenticated before invalidation',
+      () => enduserSDK.test_authenticated(),
+      { expectedResult: 'Authenticated!' }
+    )
+
+    // Wait to ensure time separation between token creation and invalidation
+    await wait(undefined, 2000)
+
+    // Test 2: Setting invalidateSessionsBefore rejects old token (401)
+    await async_test(
+      'setting invalidateSessionsBefore rejects old token',
+      async () => {
+        await sdk.api.endusers.updateOne(testEnduser.id, { invalidateSessionsBefore: new Date() })
+
+        // Old token should now be rejected
+        try {
+          await enduserSDK.test_authenticated()
+          return 'should have thrown'
+        } catch (e) {
+          return 'rejected'
+        }
+      },
+      { expectedResult: 'rejected' }
+    )
+
+    // Test 3: New token after invalidation works
+    await async_test(
+      'new token after invalidation works',
+      async () => {
+        // Wait to ensure new token iat is after invalidateSessionsBefore
+        await wait(undefined, 2000)
+
+        const { authToken: newAuthToken } = await sdk.api.endusers.generate_auth_token({ id: testEnduser.id })
+        const newEnduserSDK = new EnduserSession({ host, authToken: newAuthToken, businessId: sdk.userInfo.businessId })
+
+        return await newEnduserSDK.test_authenticated()
+      },
+      { expectedResult: 'Authenticated!' }
+    )
+
+    // Test 4: Cannot set invalidateSessionsBefore backwards (constraint error)
+    await async_test(
+      'cannot set invalidateSessionsBefore backwards',
+      async () => {
+        // Try to set invalidateSessionsBefore to a date in the past (before current value)
+        const pastDate = new Date(Date.now() - 24 * 60 * 60 * 1000) // 1 day ago
+        await sdk.api.endusers.updateOne(testEnduser.id, { invalidateSessionsBefore: pastDate })
+      },
+      handleAnyError
+    )
+
+    // Test 5: Deleted enduser token rejected (401)
+    await async_test(
+      'deleted enduser token rejected',
+      async () => {
+        // Create a separate enduser, get token, then delete enduser
+        const tempEnduser = await sdk.api.endusers.createOne({ email: `temp-session-test-${Date.now()}@tellescope.com` })
+        const { authToken: tempAuthToken } = await sdk.api.endusers.generate_auth_token({ id: tempEnduser.id })
+        const tempEnduserSDK = new EnduserSession({ host, authToken: tempAuthToken, businessId: sdk.userInfo.businessId })
+
+        // Verify token works before deletion
+        await tempEnduserSDK.test_authenticated()
+
+        // Delete the enduser
+        await sdk.api.endusers.deleteOne(tempEnduser.id)
+
+        // Token should now be rejected
+        try {
+          await tempEnduserSDK.test_authenticated()
+          return 'should have thrown'
+        } catch (e) {
+          return 'rejected'
+        }
+      },
+      { expectedResult: 'rejected' }
+    )
+
+    console.log("✅ All Enduser Session Invalidation tests passed!")
+
+  } finally {
+    // Cleanup: Delete test enduser
+    try {
+      await sdk.api.endusers.deleteOne(testEnduser.id)
+    } 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 enduser_session_invalidation_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Enduser session invalidation test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Enduser session invalidation test suite failed:", error)
+      process.exit(1)
+    })
+}