feat(finalist): admin alerts on confirm/decline/expire/promote

Wire notifyAdmins() into finalist lifecycle events so admins receive
in-app (+ email when enabled) notifications on each key transition:
- finalist.confirm → FINALIST_CONFIRMED
- finalist.decline / adminDecline → FINALIST_DECLINED
- expirePendingPastDeadline (per row) → FINALIST_EXPIRED
- promoteNextWaitlistEntry + manualPromote → FINALIST_WAITLIST_PROMOTED

All calls are wrapped in try/catch — comms never throw inside a mutation
or cron (CLAUDE.md: "round notifications never throw"). Added project
title to the project select where it was missing.

Tests: tests/unit/finalist-comms.test.ts — 3 tests passing (TDD).
Regression: finalist-confirmation, finalist-admin-confirm,
finalist-enrollment — 30 tests all passing.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Matt
2026-06-04 16:11:17 +02:00
parent f529e79cd7
commit b2826d595f
3 changed files with 371 additions and 2 deletions

View File

@@ -0,0 +1,255 @@
/**
* Task 3: Admin alerts on confirmation lifecycle
*
* Verifies that in-app notifications are created for SUPER_ADMIN users
* on confirm, decline, and expiry events.
*/
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { prisma, createCaller } from '../setup'
import {
createTestUser,
createTestProgram,
createTestProject,
createTestCompetition,
createTestRound,
cleanupTestData,
uid,
} from '../helpers'
import { finalistRouter } from '../../src/server/routers/finalist'
import { expirePendingPastDeadline } from '../../src/server/services/finalist-confirmation'
beforeAll(() => {
process.env.NEXTAUTH_SECRET = 'test-secret-for-finalist-tokens'
process.env.NEXTAUTH_URL = 'http://localhost:3001'
})
describe('finalist admin alert notifications (Task 3)', () => {
const programIds: string[] = []
const userIds: string[] = []
let adminUserId: string
afterAll(async () => {
// Clean up notifications for admin
if (adminUserId) {
await prisma.inAppNotification.deleteMany({ where: { userId: adminUserId } })
}
for (const programId of programIds) {
await prisma.inAppNotification.deleteMany({
where: {
metadata: { path: ['projectId'], string_contains: '' },
},
})
await prisma.attendingMember.deleteMany({
where: { confirmation: { project: { programId } } },
})
await prisma.finalistConfirmation.deleteMany({ where: { project: { programId } } })
await prisma.waitlistEntry.deleteMany({ where: { programId } })
await cleanupTestData(programId, [])
}
if (userIds.length > 0) {
await prisma.user.deleteMany({ where: { id: { in: userIds } } })
}
})
/**
* Set up a PENDING confirmation with a team lead + teammate, and a
* SUPER_ADMIN user to verify notifications against.
*/
async function setupWithAdmin(programName: string) {
// Create the admin once (shared) or per test
const admin = await prisma.user.create({
data: {
id: uid('user'),
email: `admin_${uid()}@test.local`,
name: 'Super Admin',
role: 'SUPER_ADMIN',
roles: ['SUPER_ADMIN'],
status: 'ACTIVE',
},
})
userIds.push(admin.id)
adminUserId = admin.id
const program = await createTestProgram({ name: programName })
programIds.push(program.id)
const lead = await prisma.user.create({
data: {
id: uid('user'),
email: `lead_${uid()}@test.local`,
name: 'Team Lead',
role: 'APPLICANT',
roles: ['APPLICANT'],
status: 'ACTIVE',
},
})
userIds.push(lead.id)
const teammate = await prisma.user.create({
data: {
id: uid('user'),
email: `mate_${uid()}@test.local`,
name: 'Teammate',
role: 'APPLICANT',
roles: ['APPLICANT'],
status: 'ACTIVE',
},
})
userIds.push(teammate.id)
const project = await createTestProject(program.id, {
title: 'Notification Test Project',
competitionCategory: 'STARTUP',
})
await prisma.teamMember.createMany({
data: [
{ projectId: project.id, userId: lead.id, role: 'LEAD' },
{ projectId: project.id, userId: teammate.id, role: 'MEMBER' },
],
})
const competition = await createTestCompetition(program.id, { status: 'ACTIVE' })
await createTestRound(competition.id, {
roundType: 'LIVE_FINAL',
configJson: { confirmationWindowHours: 24 },
})
// Use the admin caller to selectFinalists and get a PENDING confirmation
const adminCaller = createCaller(finalistRouter, {
id: admin.id,
email: admin.email,
role: 'SUPER_ADMIN',
})
const round = await prisma.round.findFirstOrThrow({
where: { competition: { programId: program.id } },
})
await adminCaller.selectFinalists({
programId: program.id,
category: 'STARTUP',
projectIds: [project.id],
roundId: round.id,
})
const confirmation = await prisma.finalistConfirmation.findUniqueOrThrow({
where: { projectId: project.id },
})
return { admin, program, lead, teammate, project, confirmation, round }
}
it('Test 1: finalist.confirm fires FINALIST_CONFIRMED notification to admin', async () => {
const { admin, lead, teammate, confirmation } = await setupWithAdmin(
`comms-confirm-${uid()}`,
)
// Clear any existing notifications for this admin before the action
await prisma.inAppNotification.deleteMany({ where: { userId: admin.id } })
const publicCaller = finalistRouter.createCaller({
session: null,
prisma,
ip: '127.0.0.1',
userAgent: 'vitest',
} as never)
await publicCaller.confirm({
token: confirmation.token,
attendingUserIds: [lead.id, teammate.id],
visaFlags: {},
})
const notification = await prisma.inAppNotification.findFirst({
where: {
userId: admin.id,
type: 'FINALIST_CONFIRMED',
},
})
expect(notification).not.toBeNull()
expect(notification?.type).toBe('FINALIST_CONFIRMED')
})
it('Test 2: finalist.decline fires FINALIST_DECLINED notification to admin', async () => {
const { admin, confirmation } = await setupWithAdmin(`comms-decline-${uid()}`)
// Clear existing notifications
await prisma.inAppNotification.deleteMany({ where: { userId: admin.id } })
const publicCaller = finalistRouter.createCaller({
session: null,
prisma,
ip: '127.0.0.1',
userAgent: 'vitest',
} as never)
await publicCaller.decline({ token: confirmation.token, reason: 'Cannot attend' })
const notification = await prisma.inAppNotification.findFirst({
where: {
userId: admin.id,
type: 'FINALIST_DECLINED',
},
})
expect(notification).not.toBeNull()
expect(notification?.type).toBe('FINALIST_DECLINED')
})
it('Test 3: expirePendingPastDeadline fires FINALIST_EXPIRED notification to admin', async () => {
// Create a fresh admin for this test (isolated)
const admin = await prisma.user.create({
data: {
id: uid('user'),
email: `admin_expire_${uid()}@test.local`,
name: 'Super Admin Expire',
role: 'SUPER_ADMIN',
roles: ['SUPER_ADMIN'],
status: 'ACTIVE',
},
})
userIds.push(admin.id)
const program = await createTestProgram({ name: `comms-expire-${uid()}` })
programIds.push(program.id)
const project = await createTestProject(program.id, {
title: 'Expire Test Project',
competitionCategory: 'STARTUP',
})
const competition = await createTestCompetition(program.id, { status: 'ACTIVE' })
await createTestRound(competition.id, {
roundType: 'LIVE_FINAL',
configJson: { confirmationWindowHours: 24 },
})
// Manually create a PENDING confirmation with a past deadline
const { signFinalistToken } = await import('../../src/lib/finalist-token')
const confirmationId = `cmfc_expire_${uid()}`
const expiredExp = Math.floor(Date.now() / 1000) - 60
const token = signFinalistToken({ confirmationId, exp: expiredExp })
await prisma.finalistConfirmation.create({
data: {
id: confirmationId,
projectId: project.id,
category: 'STARTUP',
status: 'PENDING',
deadline: new Date(Date.now() - 60_000),
token,
},
})
// Clear any existing notifications for this admin
await prisma.inAppNotification.deleteMany({ where: { userId: admin.id } })
await expirePendingPastDeadline(prisma)
const notification = await prisma.inAppNotification.findFirst({
where: {
userId: admin.id,
type: 'FINALIST_EXPIRED',
},
})
expect(notification).not.toBeNull()
expect(notification?.type).toBe('FINALIST_EXPIRED')
// Cleanup this test's notifications
await prisma.inAppNotification.deleteMany({ where: { userId: admin.id } })
})
})