@tellescope/sdk 2.0.0-beta.0 → 2.0.0-beta.2

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

@@ -0,0 +1,419 @@
+require('source-map-support').install();
+
+import { AUTOMATED_ACTION_CANCEL_REASONS } from "@tellescope/constants"
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Coverage for POST /v1/user-logs/restore-deleted — re-creating a deleted contact, and the records
+ * cascade-deleted with it, by replaying user_logs rows.
+ *
+ * The check that most justifies the handler's shape is B. handleDeletionForDependencies runs BEFORE
+ * the parent `delete` row is inserted, so cascade rows have SMALLER _ids than the parent row. If the
+ * `_id` range is ever written the intuitive way round (forwards from the parent), the contact still
+ * comes back and every "contact restored" check still passes — only the dependent counts go to zero.
+ * B is what fails in that case.
+ *
+ * H is the other half of that: the window is scoped by enduserId, which the delete path stamps on
+ * every cascade row for every model. Deleting contact B's ticket inside the same five-minute window
+ * must not bring it back when contact A is restored.
+ *
+ * The suite MUST poll for audit rows: the delete endpoint responds 204 *before* writing them, so
+ * reading immediately after a delete is a race.
+ *
+ * Restores are deliberately not idempotent in the "refuse if present" sense — they RESUME. D and E
+ * pin that: a second press duplicates nothing, and a dependent deleted since comes back.
+ */
+
+const poll_for = async <T,>(get: () => Promise<T>, done: (v: T) => boolean, attempts = 40): Promise<T> => {
+  let value = await get()
+  for (let i = 0; i < attempts && !done(value); i++) {
+    await new Promise(resolve => setTimeout(resolve, 250))
+    value = await get()
+  }
+  return value
+}
+
+/** The delete endpoint returns before writing its audit rows, so every read of one polls. */
+const poll_for_delete_log = async (sdk: any, resource: string, resourceId: string) => {
+  const log = await poll_for(
+    async () => (
+      await sdk.api.user_logs.getSome({ filter: { resourceId } })
+    ).find((l: any) => l.action === 'delete' && l.resource === resource),
+    l => !!l,
+  )
+  if (!log) throw new Error(`no delete user_log appeared for ${resource} ${resourceId}`)
+  return log
+}
+
+const sum = (counts: Record<string, number> = {}) => Object.values(counts).reduce((a, b) => a + b, 0)
+
+const rejection_of = async (run: () => Promise<any>) => {
+  try {
+    await run()
+    return undefined
+  } catch (err: any) {
+    return err
+  }
+}
+
+export const user_logs_restore_deleted_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+  let otherTenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  try {
+    ;[tenant, otherTenant] = await Promise.all([
+      setup_isolated_tenant({
+        name: `RestoreDeleted ${RAND()}`,
+        // A non-admin is provisioned deliberately: without one, sdkNonAdmin is an unauthenticated
+        // stub and the permission check (G) would pass for the wrong reason.
+        users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+        apiKeys: 0,
+      }),
+      setup_isolated_tenant({ name: `RestoreDeletedOther ${RAND()}`, users: [{ isAdmin: true }], apiKeys: 0 }),
+    ])
+
+    const { sdk, sdkNonAdmin } = tenant
+
+    /* ============================== fixtures ============================== */
+
+    const queue = await sdk.api.ticket_queues.createOne({
+      title: `Restore Queue ${RAND()}`,
+      userIds: [sdk.userInfo.id],
+    })
+
+    const journey = await sdk.api.journeys.createOne({ title: `Restore Journey ${RAND()}` })
+    const step = await sdk.api.automation_steps.createOne({
+      journeyId: journey.id,
+      action: { type: 'setEnduserStatus', info: { status: 'Restored' } },
+      events: [{ type: 'onJourneyStart', info: {} }],
+    })
+
+    const emailA = `restore-a-${RAND()}@example.com`
+    const externalIdA = `restore-ext-${RAND()}`
+
+    const contactA = await sdk.api.endusers.createOne({
+      fname: 'Restore', lname: 'Target', email: emailA, externalId: externalIdA,
+    })
+    const contactB = await sdk.api.endusers.createOne({
+      fname: 'Bystander', lname: 'Contact', email: `restore-b-${RAND()}@example.com`,
+    })
+
+    const noteA = await sdk.api.notes.createOne({ enduserId: contactA.id, text: 'A note that must come back' })
+    const ticketA = await sdk.api.tickets.createOne({
+      title: `Ticket for A ${RAND()}`, enduserId: contactA.id, queueId: queue.id,
+    })
+    const actionA = await sdk.api.automated_actions.createOne({
+      journeyId: journey.id,
+      automationStepId: step.id,
+      enduserId: contactA.id,
+      processAfter: Date.now() + 100000000, // far future: the worker must not process it during the test
+      status: 'active',
+      event: { type: 'onJourneyStart', info: {} },
+      action: { type: 'setEnduserStatus', info: { status: 'Restored' } },
+    })
+    const ticketB = await sdk.api.tickets.createOne({
+      title: `Ticket for B ${RAND()}`, enduserId: contactB.id,
+    })
+
+    // ticket_queues.count is maintained by asynchronous side effects, so every read of it polls
+    const queueCountAfterCreate = (await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id),
+      q => (q.count ?? 0) >= 1,
+    )).count ?? 0
+
+    /* ====================== delete A (and one of B's tickets) ====================== */
+
+    // H: deleted INSIDE the same window as A's delete, to prove enduserId scoping
+    await sdk.api.tickets.deleteOne(ticketB.id)
+    await poll_for_delete_log(sdk, 'tickets', ticketB.id)
+
+    await sdk.api.endusers.deleteOne(contactA.id)
+    const deleteLogA = await poll_for_delete_log(sdk, 'endusers', contactA.id)
+
+    const queueCountAfterDelete = (await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id),
+      q => (q.count ?? 0) < queueCountAfterCreate,
+    )).count ?? 0
+
+    record(
+      'delete removes the contact and decrements the queue',
+      !(await sdk.api.endusers.getSome({ filter: { } })).some(e => e.id === contactA.id)
+        && queueCountAfterDelete === queueCountAfterCreate - 1,
+      `queue ${queueCountAfterCreate} -> ${queueCountAfterDelete}`,
+    )
+
+    const auditRowsBefore = (await sdk.api.user_logs.getSome({ filter: { resourceId: contactA.id } })).length
+
+    /* ============================== A: the restore ============================== */
+
+    const result = await sdk.api.user_logs.restore_deleted({ userLogId: deleteLogA.id })
+
+    record(
+      'A1: restore returns the contact resource and its original id',
+      result.resource === 'endusers' && result.resourceId === contactA.id,
+      `resource=${result.resource} resourceId=${result.resourceId} (expected ${contactA.id})`,
+    )
+
+    const restoredContact = await sdk.api.endusers.getOne(contactA.id)
+    record(
+      'A2: the contact is back at its original id with its fields intact',
+      restoredContact.id === contactA.id
+        && restoredContact.fname === 'Restore'
+        && restoredContact.lname === 'Target'
+        && restoredContact.email === emailA
+        && restoredContact.externalId === externalIdA,
+      `id=${restoredContact.id} fname=${restoredContact.fname} email=${restoredContact.email} externalId=${restoredContact.externalId}`,
+    )
+
+    record(
+      'A3: the contact keeps its original creation timestamp',
+      new Date(restoredContact.createdAt).getTime() === new Date(contactA.createdAt).getTime(),
+      `restored=${restoredContact.createdAt} original=${contactA.createdAt}`,
+    )
+
+    /* ---- B: the cascade. This is what fails if the _id range runs the wrong way. ---- */
+
+    const dependentModels = Object.keys(result.restoredCounts ?? {}).filter(m => m !== 'endusers')
+    record(
+      'B1: restoredCounts covers at least two dependent models',
+      dependentModels.length >= 2,
+      `restoredCounts=${JSON.stringify(result.restoredCounts)} (the _id range runs BACKWARDS from the parent row)`,
+    )
+
+    const restoredNote = await sdk.api.notes.getOne(noteA.id)
+    const restoredTicket = await sdk.api.tickets.getOne(ticketA.id)
+    record(
+      'B2: dependents come back at their original ids',
+      restoredNote?.id === noteA.id && restoredTicket?.id === ticketA.id,
+      `note=${restoredNote?.id} ticket=${restoredTicket?.id}`,
+    )
+    record(
+      'B3: dependents keep their original authorship and content',
+      restoredNote.creator === noteA.creator
+        && restoredNote.text === 'A note that must come back'
+        && restoredTicket.creator === ticketA.creator
+        && restoredTicket.title === ticketA.title,
+      `note.creator=${restoredNote.creator} (orig ${noteA.creator}); ticket.creator=${restoredTicket.creator} (orig ${ticketA.creator})`,
+    )
+
+    /* ---- C: journey actions come back CANCELLED, never active ---- */
+
+    const expectedCancelReason = AUTOMATED_ACTION_CANCEL_REASONS.indexOf('Restored from Deletion')
+    const restoredAction = await sdk.api.automated_actions.getOne(actionA.id)
+    record(
+      'C: the pending journey action is restored cancelled with the new reason',
+      restoredAction?.status === 'cancelled' && restoredAction?.cancelReason === expectedCancelReason,
+      `status=${restoredAction?.status} cancelReason=${restoredAction?.cancelReason} (expected ${expectedCancelReason})`,
+    )
+
+    /* ---- H: cross-contact isolation ---- */
+
+    const bTicketBack = await rejection_of(() => sdk.api.tickets.getOne(ticketB.id))
+    record(
+      "H: restoring A does not bring back contact B's separately-deleted ticket",
+      bTicketBack !== undefined,
+      `enduserId scoping; getOne(ticketB) ${bTicketBack === undefined ? 'UNEXPECTEDLY SUCCEEDED' : 'rejected as expected'}`,
+    )
+
+    /* ---- queue count round-trips ---- */
+
+    const queueCountAfterRestore = (await poll_for(
+      () => sdk.api.ticket_queues.getOne(queue.id),
+      q => (q.count ?? 0) > queueCountAfterDelete,
+    )).count ?? 0
+    record(
+      'F1: the ticket queue count round-trips on restore',
+      queueCountAfterRestore === queueCountAfterCreate,
+      `${queueCountAfterCreate} -> ${queueCountAfterDelete} -> ${queueCountAfterRestore}`,
+    )
+
+    /* ---- audit: exactly one new row per restore ---- */
+
+    const auditRowsAfter = await poll_for(
+      async () => await sdk.api.user_logs.getSome({ filter: { resourceId: contactA.id } }),
+      rows => rows.length > auditRowsBefore,
+    )
+    const restoreRows = auditRowsAfter.filter(r => r.action === 'create' && r.note === 'Restored from deletion')
+    record(
+      'I1: the restore writes exactly one audit row',
+      auditRowsAfter.length === auditRowsBefore + 1 && restoreRows.length === 1,
+      `rows ${auditRowsBefore} -> ${auditRowsAfter.length}; restore rows=${restoreRows.length}`,
+    )
+    record(
+      'I2: the restore audit row records the source log id and the counts',
+      (restoreRows[0]?.info as any)?.sourceUserLogId === deleteLogA.id
+        && !!(restoreRows[0]?.info as any)?.restoredCounts,
+      `info=${JSON.stringify(restoreRows[0]?.info)?.slice(0, 200)}`,
+    )
+
+    /* ---- D: a second restore resumes, and duplicates nothing ---- */
+
+    const second = await sdk.api.user_logs.restore_deleted({ userLogId: deleteLogA.id })
+    record(
+      'D1: a second restore restores nothing and skips everything',
+      sum(second.restoredCounts) === 0 && sum(second.skippedCounts) > 0,
+      `restored=${JSON.stringify(second.restoredCounts)} skipped=${JSON.stringify(second.skippedCounts)}`,
+    )
+
+    const allContacts = await sdk.api.endusers.getSome({ filter: { } })
+    const allNotes = await sdk.api.notes.getSome({ filter: { enduserId: contactA.id } })
+    record(
+      'D2: a second restore duplicates neither the contact nor its records',
+      allContacts.filter(e => e.id === contactA.id).length === 1 && allNotes.length === 1,
+      `contacts with that id=${allContacts.filter(e => e.id === contactA.id).length} notes=${allNotes.length}`,
+    )
+
+    const queueCountAfterSecond = (await sdk.api.ticket_queues.getOne(queue.id)).count ?? 0
+    record(
+      'F2: a second restore does not inflate the queue count',
+      queueCountAfterSecond === queueCountAfterCreate,
+      `expected ${queueCountAfterCreate}, got ${queueCountAfterSecond}`,
+    )
+
+    /* ---- E: resume brings back a dependent deleted since ---- */
+
+    await sdk.api.notes.deleteOne(noteA.id)
+    await poll_for_delete_log(sdk, 'notes', noteA.id)
+
+    const third = await sdk.api.user_logs.restore_deleted({ userLogId: deleteLogA.id })
+    const noteBackAgain = await sdk.api.notes.getOne(noteA.id)
+    record(
+      'E: a repeat restore brings back exactly the record deleted since',
+      (third.restoredCounts as any)?.notes === 1
+        && sum(third.restoredCounts) === 1
+        && noteBackAgain?.id === noteA.id,
+      `restored=${JSON.stringify(third.restoredCounts)} note back=${noteBackAgain?.id}`,
+    )
+
+    /* ============================== error cases ============================== */
+
+    // G: a non-admin is refused. NOTE: for the default Non-Admin role the role-permission layer fires
+    // FIRST with 403 "Inaccessible" (the role has no user_logs access at all), so the schema's
+    // adminOnly gate — 401 "Admin access only" — is never reached. Both refuse; this asserts only
+    // that the call is rejected, so it stays green whichever of the two gates fires.
+    const nonAdminErr = await rejection_of(() => sdkNonAdmin.api.user_logs.restore_deleted({ userLogId: deleteLogA.id }))
+    record(
+      'G: a non-admin is refused',
+      nonAdminErr !== undefined,
+      `error=${JSON.stringify(nonAdminErr)?.slice(0, 200)}`,
+    )
+
+    // another tenant's log id is not found (indistinguishable from nonexistent)
+    const otherContact = await otherTenant.sdk.api.endusers.createOne({ fname: 'Other', lname: 'Tenant' })
+    await otherTenant.sdk.api.endusers.deleteOne(otherContact.id)
+    const otherLog = await poll_for_delete_log(otherTenant.sdk, 'endusers', otherContact.id)
+
+    const crossTenantErr = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: otherLog.id }))
+    record(
+      "J1: another tenant's log id is not found",
+      crossTenantErr !== undefined,
+      `error=${JSON.stringify(crossTenantErr)?.slice(0, 200)}`,
+    )
+
+    // a non-delete row is not found
+    const anyCreateRow = (await sdk.api.user_logs.getSome({ filter: { } })).find(l => l.action !== 'delete')
+    const nonDeleteErr = anyCreateRow
+      ? await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: anyCreateRow.id }))
+      : undefined
+    record(
+      'J2: a non-delete audit row is not found',
+      !anyCreateRow || nonDeleteErr !== undefined,
+      anyCreateRow ? `error=${JSON.stringify(nonDeleteErr)?.slice(0, 200)}` : 'no non-delete row available to test',
+    )
+
+    // K: a standalone ticket's delete row is refused as unsupported_resource, a 400 (not a 404)
+    const standaloneTicket = await sdk.api.tickets.createOne({ title: `Standalone ${RAND()}` })
+    await sdk.api.tickets.deleteOne(standaloneTicket.id)
+    const ticketLog = await poll_for_delete_log(sdk, 'tickets', standaloneTicket.id)
+
+    const unsupportedErr: any = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: ticketLog.id }))
+    record(
+      'K: a non-contact delete row is refused with unsupported_resource',
+      unsupportedErr?.info?.reason === 'unsupported_resource',
+      `error=${JSON.stringify(unsupportedErr)?.slice(0, 300)}`,
+    )
+
+    // L: a merge's delete row carries the Profile merge marker and is refused
+    const mergeSource = await sdk.api.endusers.createOne({ fname: 'Merge', lname: 'Source', email: `merge-src-${RAND()}@example.com` })
+    const mergeDest = await sdk.api.endusers.createOne({ fname: 'Merge', lname: 'Dest', email: `merge-dst-${RAND()}@example.com` })
+    await sdk.api.endusers.merge({ sourceEnduserId: mergeSource.id, destinationEnduserId: mergeDest.id })
+    const mergeLog = await poll_for_delete_log(sdk, 'endusers', mergeSource.id)
+
+    record(
+      "L1: the merge's delete row is marked 'Profile merge'",
+      mergeLog.note === 'Profile merge',
+      `note=${mergeLog.note}`,
+    )
+
+    const mergeErr: any = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: mergeLog.id }))
+    record(
+      'L2: a merge delete row is refused with merge_row',
+      mergeErr?.info?.reason === 'merge_row',
+      `error=${JSON.stringify(mergeErr)?.slice(0, 300)}`,
+    )
+
+    // M: reusing a deleted contact's email yields unique_conflict
+    const conflictEmail = `restore-conflict-${RAND()}@example.com`
+    const conflictContact = await sdk.api.endusers.createOne({ fname: 'Conflict', lname: 'Target', email: conflictEmail })
+    await sdk.api.endusers.deleteOne(conflictContact.id)
+    const conflictLog = await poll_for_delete_log(sdk, 'endusers', conflictContact.id)
+
+    const replacement = await sdk.api.endusers.createOne({ fname: 'Replacement', lname: 'Contact', email: conflictEmail })
+    const conflictErr: any = await rejection_of(() => sdk.api.user_logs.restore_deleted({ userLogId: conflictLog.id }))
+
+    record(
+      'M1: restoring into a reused email yields unique_conflict',
+      conflictErr?.info?.reason === 'unique_conflict',
+      `error=${JSON.stringify(conflictErr)?.slice(0, 300)}`,
+    )
+
+    const conflictStillGone = await rejection_of(() => sdk.api.endusers.getOne(conflictContact.id))
+    const replacementUntouched = await sdk.api.endusers.getOne(replacement.id)
+    record(
+      'M2: a unique conflict restores nothing and leaves the new contact untouched',
+      conflictStillGone !== undefined && replacementUntouched?.email === conflictEmail,
+      `deleted contact still absent=${conflictStillGone !== undefined}; replacement email=${replacementUntouched?.email}`,
+    )
+  } finally {
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand these tenants.
+    for (const t of [tenant, otherTenant]) {
+      if (t) { try { await t.teardown() } catch (e) { console.error('teardown failed', e) } }
+    }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const user_logs_restore_deleted_tests = async () => {
+  assert_checks('user_logs restore_deleted', await user_logs_restore_deleted_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'user_logs restore_deleted', run: user_logs_restore_deleted_checks }
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  user_logs_restore_deleted_tests()
+    .then(() => {
+      console.log("✅ user_logs restore_deleted test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ user_logs restore_deleted test suite failed:", error)
+      process.exit(1)
+    })
+}