Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

refactor(control-api): separate password reset invitation issuance

Josuéc03d089c2b6d
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index eb52a7397..9371cabc5 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.765",
+ "version": "0.1.766",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.765",
+ "version": "0.1.766",
"dependencies": {
"@clerum/display-field": "file:../packages/display-field",
"@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract",
diff --git a/control-api/package.json b/control-api/package.json
index 5d8b9c550..275a6a574 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.765",
+ "version": "0.1.766",
"description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets",
"main": "dist/main.js",
"engines": {
diff --git a/control-api/src/services/directory/index.ts b/control-api/src/services/directory/index.ts
index 42940b87f..404e7c407 100644
--- a/control-api/src/services/directory/index.ts
+++ b/control-api/src/services/directory/index.ts
@@ -52,7 +52,6 @@ export {
listManagedPendingInvitationsForUser,
resendInvitation,
resendManagedInvitationForUser,
- requestProfilePasswordReset,
revokeManagedInvitationForUser,
revokePendingInvitation,
findMembership,
@@ -107,3 +106,9 @@ export {
export type { WorkflowGrantTeam, WorkflowGrantUser } from './workflowGrants.js'
export * from './adminProvisioning.js'
+
+export {
+ requestProfilePasswordReset,
+ createPasswordResetInvitation,
+ createSilentPasswordResetInvitation,
+} from './passwordResetInvitations.js'
diff --git a/control-api/src/services/directory/invitationStore.ts b/control-api/src/services/directory/invitationStore.ts
index d293e0c80..7d5f9c164 100644
--- a/control-api/src/services/directory/invitationStore.ts
+++ b/control-api/src/services/directory/invitationStore.ts
@@ -1,4 +1,4 @@
-import { type DbClient } from '../../db.js'
+import { type DbClient, pool } from '../../db.js'
import { type InviteRole, normalizeTeamRoleInput } from './types.js'
export const INVITATION_TTL_HOURS = 48
@@ -369,3 +369,34 @@ export function invitationForTeamsResponse(invitation: InvitationRow, teams: Inv
})),
}
}
+
+const DRAFT_INVITATION_CLEANUP_HOURS = 24
+
+export async function cleanupStaleDraftInvitations(): Promise<void> {
+ await pool.query(
+ `DELETE FROM invitations
+ WHERE status = 'draft'
+ AND created_at < NOW() - ($1::text || ' hours')::interval`,
+ [String(DRAFT_INVITATION_CLEANUP_HOURS)]
+ )
+}
+
+export type GenericInvitationPurpose = Exclude<InvitationPurpose, 'password_reset'>
+export type GenericInvitationForTeamsInput = Omit<InvitationForTeamsInput, 'purpose'> & {
+ purpose?: GenericInvitationPurpose
+}
+
+export async function activateDraftInvitation(
+ db: Pick<DbClient, 'query'>,
+ invitationId: string
+): Promise<InvitationRow | undefined> {
+ const activated = await db.query(
+ `UPDATE invitations
+ SET status = 'pending'
+ WHERE id = $1
+ AND status = 'draft'
+ RETURNING id, team_id, invitee_name, email, role, token, status, purpose, created_at, expires_at, accepted_at, accepted_user_id`,
+ [invitationId]
+ )
+ return activated.rows[0] as InvitationRow | undefined
+}
diff --git a/control-api/src/services/directory/membership.ts b/control-api/src/services/directory/membership.ts
index af1848cdc..7265aaa78 100644
--- a/control-api/src/services/directory/membership.ts
+++ b/control-api/src/services/directory/membership.ts
@@ -2,25 +2,26 @@ import { type DbClient, pool, withTransaction } from '../../db.js'
import { registerAndSendInvitation } from '../invitationFlowRegistrationService.js'
import { appendControlApiPermissionEventsInTransaction } from '../tracing/controlApiPermissionEvents.js'
import {
+ type GenericInvitationForTeamsInput,
+ type GenericInvitationPurpose,
INVITATION_TTL_HOURS,
- type InvitationForTeamsInput,
type InvitationPurpose,
type InvitationRow,
type InvitationTeamAssignment,
type InvitationTeamRow,
type InvitationUserRow,
type InvitationWithTeams,
+ activateDraftInvitation,
+ cleanupStaleDraftInvitations,
ensureInvitationUser,
getInvitationRecordById,
getInvitationRecordByToken,
getInvitationRecordByTokenOrId,
insertInvitationForTeams,
- insertInvitationTeams,
invitationForTeamsResponse,
invitationResponse,
invitationUserIsRetired,
loadInvitationTeams,
- lockPasswordResetUser,
normalizeInvitationPurpose,
normalizeInvitationTeamAssignments,
} from './invitationStore.js'
@@ -43,21 +44,9 @@ export {
export { withPasswordWorkLease as withMemberPasswordWorkLease } from '../auth/passwordWorkOwnership.js'
export type { MemberPasswordWorkLease } from '../auth/passwordWorkOwnership.js'
-const DRAFT_INVITATION_CLEANUP_HOURS = 24
const DRAFT_INVITATION_CLEANUP_INTERVAL_MS = 60 * 60 * 1000
let draftInvitationCleanupTimer: ReturnType<typeof setInterval> | null = null
-class PasswordResetPrincipalUnavailableError extends Error {}
-
-async function cleanupStaleDraftInvitations(): Promise<void> {
- await pool.query(
- `DELETE FROM invitations
- WHERE status = 'draft'
- AND created_at < NOW() - ($1::text || ' hours')::interval`,
- [String(DRAFT_INVITATION_CLEANUP_HOURS)]
- )
-}
-
export function startDraftInvitationCleanup(intervalMs = DRAFT_INVITATION_CLEANUP_INTERVAL_MS) {
if (draftInvitationCleanupTimer) return
cleanupStaleDraftInvitations().catch(() => undefined)
@@ -352,18 +341,12 @@ export async function addMemberToTeam(
}
async function createInvitationForTeamsRecord(
- input: InvitationForTeamsInput,
+ input: GenericInvitationForTeamsInput,
options: { sendEmail: boolean }
) {
cleanupStaleDraftInvitations().catch(() => undefined)
const purpose = normalizeInvitationPurpose(input.purpose)
const inserted = await withTransaction(async db => {
- if (purpose === 'password_reset') {
- const principal = await lockPasswordResetUser(db, input.email.trim().toLowerCase())
- if (!principal || invitationUserIsRetired(principal)) {
- throw new PasswordResetPrincipalUnavailableError()
- }
- }
return insertInvitationForTeams(db, {
...input,
purpose,
@@ -389,22 +372,8 @@ async function createInvitationForTeamsRecord(
}
)
- const activated = await pool.query(
- `UPDATE invitations
- SET status = 'pending'
- WHERE id = $1
- AND status = 'draft'
- RETURNING id, team_id, invitee_name, email, role, token, status, purpose, created_at, expires_at, accepted_at, accepted_user_id`,
- [inserted.invitation.id]
- )
- const pending = activated.rows[0] as InvitationRow | undefined
+ const pending = await activateDraftInvitation(pool, inserted.invitation.id)
if (!pending) {
- if (purpose === 'password_reset') {
- const current = await getInvitationRecordById(pool, inserted.invitation.id)
- if (current?.status === 'revoked') {
- return invitationForTeamsResponse(current, inserted.teams)
- }
- }
throw new Error('Failed to activate invitation after registration')
}
return invitationForTeamsResponse(
@@ -437,7 +406,7 @@ export async function createInvitationForTeams(input: {
inviteeName: string
email: string
teamAssignments?: readonly InvitationTeamAssignment[]
- purpose?: InvitationPurpose
+ purpose?: GenericInvitationPurpose
fallbackRole?: InviteRole
}) {
return createInvitationForTeamsRecord(input, { sendEmail: true })
@@ -448,7 +417,7 @@ export async function createSilentInvitationForTeams(input: {
email: string
teamAssignments?: readonly InvitationTeamAssignment[]
fallbackRole?: InviteRole
- purpose?: InvitationPurpose
+ purpose?: GenericInvitationPurpose
}) {
return createInvitationForTeamsRecord(input, { sendEmail: false })
}
@@ -536,38 +505,6 @@ export async function createPasswordSetupInvitationForUser(userId: string) {
}
}
-export async function requestProfilePasswordReset(email: string): Promise<{ requested: true }> {
- const normalizedEmail = email.trim().toLowerCase()
- if (!normalizedEmail) return { requested: true }
-
- const userResult = await pool.query(
- `SELECT id, email, name
- FROM users
- WHERE email = $1
- AND lifecycle_state = 'active'
- LIMIT 1`,
- [normalizedEmail]
- )
- const user =
- (userResult.rows[0] as { id: string; email: string; name: string | null } | undefined) || null
- if (!user) {
- return { requested: true }
- }
-
- try {
- await createInvitationForTeams({
- inviteeName: user.name || user.email.split('@')[0] || user.email,
- email: user.email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
- })
- } catch (error) {
- if (!(error instanceof PasswordResetPrincipalUnavailableError)) throw error
- }
- return { requested: true }
-}
-
export async function softDeleteMember(teamId: string, userId: string, operatorSub: string) {
return withTransaction(async db => {
const result = await db.query(
@@ -1448,3 +1385,5 @@ export async function revokeManagedInvitationForUser(managerUserId: string, invi
await pool.query(`UPDATE invitations SET status = 'revoked' WHERE id = $1`, [invitation.id])
return { revoked: true as const, id: invitation.id, email: invitation.email }
}
+
+export { requestProfilePasswordReset } from './passwordResetInvitations.js'
diff --git a/control-api/src/services/directory/passwordResetInvitations.ts b/control-api/src/services/directory/passwordResetInvitations.ts
new file mode 100644
index 000000000..302c1f8ee
--- /dev/null
+++ b/control-api/src/services/directory/passwordResetInvitations.ts
@@ -0,0 +1,105 @@
+import { pool, withTransaction } from '../../db.js'
+import { registerAndSendInvitation } from '../invitationFlowRegistrationService.js'
+import {
+ activateDraftInvitation,
+ cleanupStaleDraftInvitations,
+ getInvitationRecordById,
+ insertInvitationForTeams,
+ invitationForTeamsResponse,
+ invitationUserIsRetired,
+ lockPasswordResetUser,
+} from './invitationStore.js'
+
+class PasswordResetPrincipalUnavailableError extends Error {}
+
+async function createResetInvitation(
+ input: { email: string; inviteeName: string },
+ options: { sendEmail: boolean }
+) {
+ cleanupStaleDraftInvitations().catch(() => undefined)
+ const purpose = 'password_reset' as const
+ const inserted = await withTransaction(async db => {
+ const principal = await lockPasswordResetUser(db, input.email.trim().toLowerCase())
+ if (!principal || invitationUserIsRetired(principal)) {
+ throw new PasswordResetPrincipalUnavailableError()
+ }
+ return insertInvitationForTeams(db, {
+ ...input,
+ teamAssignments: [],
+ fallbackRole: 'member',
+ purpose,
+ status: options.sendEmail ? 'draft' : 'pending',
+ })
+ })
+
+ if (!options.sendEmail) {
+ return invitationForTeamsResponse(inserted.invitation, inserted.teams)
+ }
+
+ await registerAndSendInvitation(
+ inserted.invitation.email,
+ inserted.invitation.token,
+ inserted.teams.length > 0
+ ? inserted.teams.map(team => team.team_name).join(', ')
+ : inserted.invitation.team_name,
+ inserted.invitation.created_at.toISOString(),
+ inserted.invitation.expires_at.toISOString(),
+ {
+ purpose,
+ teamNames: inserted.teams.map(team => team.team_name),
+ }
+ )
+
+ const pending = await activateDraftInvitation(pool, inserted.invitation.id)
+ if (!pending) {
+ const current = await getInvitationRecordById(pool, inserted.invitation.id)
+ if (current?.status === 'revoked') {
+ return invitationForTeamsResponse(current, inserted.teams)
+ }
+ throw new Error('Failed to activate invitation after registration')
+ }
+ return invitationForTeamsResponse(
+ {
+ ...pending,
+ team_name: inserted.invitation.team_name,
+ },
+ inserted.teams
+ )
+}
+
+export function createPasswordResetInvitation(input: { email: string; inviteeName: string }) {
+ return createResetInvitation(input, { sendEmail: true })
+}
+
+export function createSilentPasswordResetInvitation(input: { email: string; inviteeName: string }) {
+ return createResetInvitation(input, { sendEmail: false })
+}
+
+export async function requestProfilePasswordReset(email: string): Promise<{ requested: true }> {
+ const normalizedEmail = email.trim().toLowerCase()
+ if (!normalizedEmail) return { requested: true }
+
+ const userResult = await pool.query(
+ `SELECT id, email, name
+ FROM users
+ WHERE email = $1
+ AND lifecycle_state = 'active'
+ LIMIT 1`,
+ [normalizedEmail]
+ )
+ const user =
+ (userResult.rows[0] as { id: string; email: string; name: string | null } | undefined) || null
+ if (!user) {
+ return { requested: true }
+ }
+
+ try {
+ await createPasswordResetInvitation({
+ inviteeName: user.name || user.email.split('@')[0] || user.email,
+ email: user.email,
+ })
+ } catch (error) {
+ if (!(error instanceof PasswordResetPrincipalUnavailableError)) throw error
+ }
+ return { requested: true }
+}
diff --git a/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts b/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts
index ce5494e77..96e00c400 100644
--- a/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts
+++ b/control-api/test/bug192.passwordLogin.realPostgres.integration.test.ts
@@ -16,6 +16,7 @@ import {
setInvitationPasswordForEmail,
updateUserPassword,
} from '../src/services/directory/membership.js'
+import { createPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { verifyExternalSessionToken } from '../src/utils/auth/externalSessionAuthToken.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
@@ -98,12 +99,9 @@ realPg('BUG-192 observable password-login regressions on real PostgreSQL', () =>
return metric.values.find(value => value.labels.reason === reason)?.value ?? 0
}
async function recoverPassword(nextPassword: string) {
- const invitation = await createInvitationForTeams({
+ const invitation = await createPasswordResetInvitation({
inviteeName: 'Synthetic member',
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
const proof = 'synthetic-trusted-reset-proof'
invitationFlow.validateInvitationFlowToken.mockResolvedValue({
@@ -412,19 +410,13 @@ realPg('BUG-192 observable password-login regressions on real PostgreSQL', () =>
}
})
it('returns acknowledged password recovery after a post-commit client cleanup failure', async () => {
- const invitation = await createInvitationForTeams({
+ const invitation = await createPasswordResetInvitation({
inviteeName: 'Synthetic member',
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
- const sibling = await createInvitationForTeams({
+ const sibling = await createPasswordResetInvitation({
inviteeName: 'Synthetic member',
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
const connect = holder.pool.connect.bind(holder.pool)
const connectSpy = vi.spyOn(holder.pool, 'connect')
diff --git a/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts b/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts
index 360f52f76..3be886d78 100644
--- a/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts
+++ b/control-api/test/bug192.passwordPersistence.realPostgres.integration.test.ts
@@ -27,6 +27,10 @@ import {
updateUserPassword,
withMemberPasswordWorkLease,
} from '../src/services/directory/membership.js'
+import {
+ createPasswordResetInvitation,
+ createSilentPasswordResetInvitation,
+} from '../src/services/directory/passwordResetInvitations.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
const holder = vi.hoisted(() => ({
@@ -244,12 +248,9 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
expect((await row()).failures).toEqual([])
})
it('serializes authenticated password change and recovery through one durable owner', async () => {
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
let resolveCompareEntered!: () => void
let releaseCompare!: () => void
@@ -324,12 +325,9 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
expect(bcrypt.getRounds(credential.password_hash)).toBe(12)
})
it('completes authenticated reset with a one-connection PostgreSQL pool', async () => {
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
const previousPool = holder.pool
const singleConnectionPool = new Pool({
@@ -431,12 +429,9 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
).toBe('0')
})
it('does not accept a pending password-reset link through generic invitation acceptance', async () => {
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
await expect(acceptInvitationForEmail(email, '', invitation.id)).resolves.toEqual({
@@ -453,13 +448,7 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
})
it('revokes every other pending password-reset link for the same account only', async () => {
const makeReset = (address: string) =>
- createSilentInvitationForTeams({
- inviteeName: 'Synthetic member',
- email: address,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
- })
+ createSilentPasswordResetInvitation({ inviteeName: 'Synthetic member', email: address })
const redeemed = await makeReset(email)
const sibling = await makeReset(email)
await expect(getInvitationByToken(redeemed.token)).resolves.toMatchObject({
@@ -533,12 +522,9 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
})
it('maps the email producer token to its distinct recovery row ID', async () => {
- const invitation = await createInvitationForTeams({
+ const invitation = await createPasswordResetInvitation({
inviteeName: 'Synthetic member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
expect(invitationFlow.registerAndSendInvitation).toHaveBeenCalledWith(
email,
@@ -573,13 +559,7 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
it('allows at most one credential mutation when sibling reset links race', async () => {
const makeReset = () =>
- createSilentInvitationForTeams({
- inviteeName: 'Synthetic member',
- email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
- })
+ createSilentPasswordResetInvitation({ inviteeName: 'Synthetic member', email })
const first = await makeReset()
const second = await makeReset()
const hash = vi.spyOn(bcrypt, 'hash')
@@ -622,13 +602,15 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
})
it('rejects expired, revoked, wrong-purpose and wrong-account recovery credentials', async () => {
const makeInvitation = (purpose: 'password_reset' | 'member_invitation') =>
- createSilentInvitationForTeams({
- inviteeName: 'Synthetic member',
- email,
- purpose,
- teamAssignments: [],
- fallbackRole: 'member',
- })
+ purpose === 'password_reset'
+ ? createSilentPasswordResetInvitation({ inviteeName: 'Synthetic member', email })
+ : createSilentInvitationForTeams({
+ inviteeName: 'Synthetic member',
+ email,
+ purpose,
+ teamAssignments: [],
+ fallbackRole: 'member',
+ })
const expired = await makeInvitation('password_reset')
const revoked = await makeInvitation('password_reset')
const wrongAccount = await makeInvitation('password_reset')
@@ -661,12 +643,9 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
).toBe(hash)
})
it('fails recovery closed when durable password work authority is unavailable', async () => {
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
await holder.pool.query(
'ALTER TABLE password_verification_work RENAME TO password_verification_work_unavailable'
@@ -690,12 +669,9 @@ realPg('Spec 043 persistence, migration, atomicity and fencing design acceptance
}
})
it('bounds recovery hashing with the shared owner and does not hash while it is busy', async () => {
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
const lease = await acquirePasswordWork()
expect(lease).not.toBeNull()
diff --git a/control-api/test/bug192.passwordRecovery.memberRegistration.realPostgres.integration.test.ts b/control-api/test/bug192.passwordRecovery.memberRegistration.realPostgres.integration.test.ts
index 78f6416ba..d5c04da29 100644
--- a/control-api/test/bug192.passwordRecovery.memberRegistration.realPostgres.integration.test.ts
+++ b/control-api/test/bug192.passwordRecovery.memberRegistration.realPostgres.integration.test.ts
@@ -9,6 +9,7 @@ import { createExternalAuthRouter } from '../src/routes/external/auth.js'
import { createExternalInvitationsRouter } from '../src/routes/external/invitations.js'
import { passwordIdentifierKey } from '../src/services/auth/passwordAdmissionState.js'
import { createInvitationForTeams } from '../src/services/directory/membership.js'
+import { createPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
const holder = vi.hoisted(() => ({
@@ -136,12 +137,9 @@ realCrossService(
.expect(429)
expect(deniedLogin.body.error).toBe('rate_limited')
- const invitation = await createInvitationForTeams({
+ const invitation = await createPasswordResetInvitation({
inviteeName: 'Synthetic issue 1055 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
const flowRows = await memberRegistrationDb.query(
`SELECT invitation_jwt
diff --git a/control-api/test/passwordResetInvitations.realPostgres.integration.test.ts b/control-api/test/passwordResetInvitations.realPostgres.integration.test.ts
new file mode 100644
index 000000000..59a015e68
--- /dev/null
+++ b/control-api/test/passwordResetInvitations.realPostgres.integration.test.ts
@@ -0,0 +1,256 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { randomBytes } from 'node:crypto'
+import { Pool } from 'pg'
+import { initDb } from '../src/db.js'
+import {
+ createInvitationForTeams,
+ createSilentInvitationForTeams,
+} from '../src/services/directory/membership.js'
+import {
+ createPasswordResetInvitation,
+ createSilentPasswordResetInvitation,
+ requestProfilePasswordReset,
+} from '../src/services/directory/passwordResetInvitations.js'
+import { retireDesktopUser } from '../src/services/directory/users.js'
+import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
+
+const holder = vi.hoisted(() => ({ pool: null as unknown as Pool }))
+const sender = vi.hoisted(() => vi.fn())
+vi.mock('../src/services/invitationFlowRegistrationService.js', () => ({
+ registerAndSendInvitation: sender,
+}))
+vi.mock('../src/db.js', async importOriginal => {
+ const real = await importOriginal<typeof import('../src/db.js')>()
+ return {
+ ...real,
+ pool: { query: (...args: unknown[]) => (holder.pool.query as Function)(...args) },
+ withTransaction: (
+ work: Parameters<typeof real.withTransaction>[0],
+ _pool?: unknown,
+ options?: Parameters<typeof real.withTransaction>[2]
+ ) => real.withTransaction(work, holder.pool, options),
+ }
+})
+const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
+const realPg = adminUrl ? describe : describe.skip
+realPg('password reset issuance ownership on PostgreSQL 16', () => {
+ const database = `reset_issuance_${randomBytes(6).toString('hex')}`
+ let admin: Pool
+ let local: Pool
+ beforeAll(async () => {
+ admin = new Pool({ connectionString: adminUrl })
+ await admin.query(`CREATE DATABASE "${database}"`)
+ const url = new URL(adminUrl!)
+ url.pathname = `/${database}`
+ local = new Pool({ connectionString: url.toString() })
+ holder.pool = local
+ await initDb(local)
+ }, 60_000)
+ beforeEach(() => {
+ vi.restoreAllMocks()
+ sender.mockReset().mockResolvedValue(undefined)
+ })
+ afterAll(async () => {
+ try {
+ vi.restoreAllMocks()
+ await endPoolAndWaitForClients(local)
+ if (admin) await admin.query(`DROP DATABASE IF EXISTS "${database}"`)
+ } finally {
+ await admin?.end()
+ }
+ })
+ async function principal() {
+ const email = `${randomBytes(8).toString('hex')}@example.invalid`
+ const row = (
+ await local.query('INSERT INTO users(email,name) VALUES ($1,$2) RETURNING id', [
+ email,
+ 'Captured display name',
+ ])
+ ).rows[0]
+ return { email, id: row.id as string }
+ }
+ async function rows(email: string) {
+ return (
+ await local.query('SELECT * FROM invitations WHERE email = $1 ORDER BY created_at', [email])
+ ).rows
+ }
+ async function retire(userId: string) {
+ const actor = await principal()
+ await retireDesktopUser(
+ { kind: 'platform_user', desktopUserId: actor.id },
+ userId,
+ 'Synthetic reset issuance retirement',
+ `issuance-${randomBytes(12).toString('hex')}`,
+ null,
+ { retainWithoutLinkHistory: true }
+ )
+ }
+
+ it('does not enumerate empty, unknown or retired principals or send mail', async () => {
+ const user = await principal()
+ await retire(user.id)
+ for (const email of ['', `${randomBytes(8).toString('hex')}@example.invalid`, user.email]) {
+ expect(await requestProfilePasswordReset(email)).toEqual({ requested: true })
+ expect(await rows(email)).toHaveLength(0)
+ }
+ expect(sender).not.toHaveBeenCalled()
+ })
+
+ it('commits the draft before dispatch then activates the exact token with unchanged TTL', async () => {
+ const user = await principal()
+ sender.mockImplementation(async (email: string, token: string) => {
+ const before = await rows(email)
+ expect(before).toHaveLength(1)
+ expect(before[0]).toMatchObject({
+ token,
+ status: 'draft',
+ purpose: 'password_reset',
+ team_id: null,
+ })
+ })
+ expect(await requestProfilePasswordReset(` ${user.email.toUpperCase()} `)).toEqual({
+ requested: true,
+ })
+ const row = (await rows(user.email))[0]
+ expect(row).toMatchObject({
+ status: 'pending',
+ invitee_name: 'Captured display name',
+ role: 'member',
+ })
+ expect(row.expires_at.getTime() - row.created_at.getTime()).toBe(48 * 60 * 60 * 1000)
+ expect(sender).toHaveBeenCalledWith(
+ user.email,
+ row.token,
+ null,
+ row.created_at.toISOString(),
+ row.expires_at.toISOString(),
+ { purpose: 'password_reset', teamNames: [] }
+ )
+ expect(sender).toHaveBeenCalledTimes(1)
+ })
+
+ it('uses the same real lock/insert in silent mode without dispatch', async () => {
+ const user = await principal()
+ const row = await createSilentPasswordResetInvitation({
+ email: user.email,
+ inviteeName: 'Silent member',
+ })
+ expect(row).toMatchObject({
+ status: 'pending',
+ purpose: 'password_reset',
+ team_id: null,
+ teams: [],
+ })
+ expect(await rows(user.email)).toHaveLength(1)
+ expect(sender).not.toHaveBeenCalled()
+ })
+
+ it('propagates send failure and retains only the committed draft', async () => {
+ const user = await principal()
+ const failure = new Error('synthetic dispatch failure')
+ sender.mockRejectedValue(failure)
+ await expect(requestProfilePasswordReset(user.email)).rejects.toBe(failure)
+ expect((await rows(user.email)).map(row => row.status)).toEqual(['draft'])
+ expect(sender).toHaveBeenCalledTimes(1)
+ })
+
+ it.each(['delete', 'retire', 'rename'] as const)(
+ 'preserves the screen-to-lock %s race',
+ async transition => {
+ const user = await principal()
+ const query = local.query.bind(local)
+ let changed = false
+ vi.spyOn(local, 'query').mockImplementation((async (sql: string, values: unknown[]) => {
+ const result = await query(sql, values)
+ if (
+ !changed &&
+ sql.includes('SELECT id, email, name') &&
+ sql.includes("lifecycle_state = 'active'")
+ ) {
+ changed = true
+ if (transition === 'delete') await query('DELETE FROM users WHERE id=$1', [user.id])
+ if (transition === 'retire') await retire(user.id)
+ if (transition === 'rename')
+ await query('UPDATE users SET name=$2 WHERE id=$1', [user.id, 'Later display name'])
+ }
+ return result
+ }) as typeof local.query)
+ expect(await requestProfilePasswordReset(user.email)).toEqual({ requested: true })
+ expect(changed).toBe(true)
+ if (transition === 'rename') {
+ expect((await rows(user.email))[0]).toMatchObject({
+ invitee_name: 'Captured display name',
+ status: 'pending',
+ })
+ expect(sender).toHaveBeenCalledTimes(1)
+ } else {
+ expect(await rows(user.email)).toHaveLength(0)
+ expect(sender).not.toHaveBeenCalled()
+ }
+ }
+ )
+
+ it('does not resurrect a reset draft revoked while dispatch completes', async () => {
+ const user = await principal()
+ sender.mockImplementation(async (_email: string, token: string) => {
+ await local.query("UPDATE invitations SET status='revoked' WHERE token=$1", [token])
+ })
+ const result = await createPasswordResetInvitation({
+ email: user.email,
+ inviteeName: 'Synthetic member',
+ })
+ expect(result.status).toBe('revoked')
+ expect((await rows(user.email))[0].status).toBe('revoked')
+ })
+
+ it('reports missing activation state rather than swallowing it as unavailable principal', async () => {
+ const user = await principal()
+ sender.mockImplementation(async (_email: string, token: string) => {
+ await local.query('DELETE FROM invitations WHERE token=$1', [token])
+ })
+ await expect(requestProfilePasswordReset(user.email)).rejects.toThrow(
+ 'Failed to activate invitation after registration'
+ )
+ })
+
+ it('does not swallow a real storage failure at the eligibility screen', async () => {
+ const user = await principal()
+ await local.query('ALTER TABLE users RENAME TO issuance_unavailable_users')
+ try {
+ await expect(requestProfilePasswordReset(user.email)).rejects.toMatchObject({ code: '42P01' })
+ } finally {
+ await local.query('ALTER TABLE issuance_unavailable_users RENAME TO users')
+ }
+ expect(sender).not.toHaveBeenCalled()
+ })
+
+ it.each(['member_invitation', 'admin_desktop_access'] as const)(
+ 'retains generic %s positive controls',
+ async purpose => {
+ const email = `${randomBytes(8).toString('hex')}@example.invalid`
+ const silent = await createSilentInvitationForTeams({
+ email,
+ inviteeName: 'Generic member',
+ purpose,
+ })
+ expect(silent).toMatchObject({ purpose, status: 'pending' })
+ const dispatched = await createInvitationForTeams({
+ email,
+ inviteeName: 'Generic member',
+ purpose,
+ })
+ expect(dispatched).toMatchObject({ purpose, status: 'pending' })
+ expect(sender).toHaveBeenCalledTimes(1)
+ }
+ )
+
+ it('keeps revoked generic activation a failure while reset owns the special case', async () => {
+ const email = `${randomBytes(8).toString('hex')}@example.invalid`
+ sender.mockImplementation(async (_email: string, token: string) => {
+ await local.query("UPDATE invitations SET status='revoked' WHERE token=$1", [token])
+ })
+ await expect(
+ createInvitationForTeams({ email, inviteeName: 'Generic member' })
+ ).rejects.toThrow('Failed to activate invitation after registration')
+ })
+})
diff --git a/control-api/test/passwordWorkOwnership.operation.realPostgres.integration.test.ts b/control-api/test/passwordWorkOwnership.operation.realPostgres.integration.test.ts
index cda94af5a..bb20ff473 100644
--- a/control-api/test/passwordWorkOwnership.operation.realPostgres.integration.test.ts
+++ b/control-api/test/passwordWorkOwnership.operation.realPostgres.integration.test.ts
@@ -15,6 +15,7 @@ import {
setInvitationPasswordForUser,
withMemberPasswordWorkLease,
} from '../src/services/directory/membership.js'
+import { createSilentPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { createPostgresCommitReplyBlackhole } from './helpers/realPostgresCancellation.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
@@ -71,10 +72,9 @@ realPg('password-work operation preservation on PostgreSQL 16', () => {
const email = `${randomBytes(8).toString('hex')}@example.invalid`
const user = (await local.query('INSERT INTO users(email) VALUES ($1) RETURNING id', [email]))
.rows[0]
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic preservation member',
email,
- purpose: 'password_reset',
})
return { email, userId: user.id as string, invitation }
}
@@ -185,10 +185,9 @@ realPg('password-work operation preservation on PostgreSQL 16', () => {
it('keeps a real lost-COMMIT outcome above failed owner cleanup in an outer reservation', async () => {
const fixture = await resetFixture()
- const sibling = await createSilentInvitationForTeams({
+ const sibling = await createSilentPasswordResetInvitation({
email: fixture.email,
inviteeName: 'Synthetic sibling',
- purpose: 'password_reset',
})
const blackhole = await createPostgresCommitReplyBlackhole(connectionString)
const proxyPool = new Pool({ connectionString: blackhole.connectionString, max: 1 })
@@ -291,10 +290,9 @@ realPg('password-work operation preservation on PostgreSQL 16', () => {
it('keeps concurrent supplied domain operations at one committed reset', async () => {
const fixture = await resetFixture()
- const sibling = await createSilentInvitationForTeams({
+ const sibling = await createSilentPasswordResetInvitation({
email: fixture.email,
inviteeName: 'Synthetic sibling',
- purpose: 'password_reset',
})
const hash = vi.spyOn(bcrypt, 'hash')
const outcomes = await withMemberPasswordWorkLease(lease =>
diff --git a/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts b/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts
index ca7e22984..fdaa40ce0 100644
--- a/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts
+++ b/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts
@@ -11,6 +11,7 @@ import {
createSilentInvitationForTeams,
setInvitationPasswordForEmail,
} from '../src/services/directory/membership.js'
+import { createSilentPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { createPostgresCommitReplyBlackhole } from './helpers/realPostgresCancellation.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
@@ -84,19 +85,13 @@ realPg('R2-H2 lost password-reset COMMIT acknowledgement on PostgreSQL 16', () =
)
userId = user.rows[0].id as string
- const primary = await createSilentInvitationForTeams({
+ const primary = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R2-H2 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
- const sibling = await createSilentInvitationForTeams({
+ const sibling = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R2-H2 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
resetInvitationId = primary.id
siblingInvitationId = sibling.id
@@ -201,19 +196,13 @@ realPg('R2-H2 lost password-reset COMMIT acknowledgement on PostgreSQL 16', () =
[retryEmail, retryUserHash]
)
const retryUserId = retryUser.rows[0].id as string
- const retryReset = await createSilentInvitationForTeams({
+ const retryReset = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R2-H3 member',
email: retryEmail,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
- const retrySibling = await createSilentInvitationForTeams({
+ const retrySibling = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R2-H3 member',
email: retryEmail,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
await normalPool.query(`
@@ -313,19 +302,13 @@ realPg('R2-H2 lost password-reset COMMIT acknowledgement on PostgreSQL 16', () =
[retryEmail, retryUserHash]
)
const retryUserId = retryUser.rows[0].id as string
- const reset = await createSilentInvitationForTeams({
+ const reset = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R3-M1 member',
email: retryEmail,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
- const sibling = await createSilentInvitationForTeams({
+ const sibling = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R3-M1 member',
email: retryEmail,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
await normalPool.query(`CREATE SEQUENCE ${sequenceName}`)
diff --git a/control-api/test/r2m5.passwordResetLocking.realPostgres.integration.test.ts b/control-api/test/r2m5.passwordResetLocking.realPostgres.integration.test.ts
index 8fee003df..6aa9491ed 100644
--- a/control-api/test/r2m5.passwordResetLocking.realPostgres.integration.test.ts
+++ b/control-api/test/r2m5.passwordResetLocking.realPostgres.integration.test.ts
@@ -9,6 +9,7 @@ import {
createSilentInvitationForTeams,
setInvitationPasswordForEmail,
} from '../src/services/directory/membership.js'
+import { createSilentPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
const holder = vi.hoisted(() => ({
@@ -102,12 +103,9 @@ realPg('R2-M5 password-reset row-lock compatibility on PostgreSQL 16', () => {
expect(accepted).not.toHaveProperty('error')
await holder.pool.query('DELETE FROM team_members WHERE user_id = $1', [userId])
- const recoveryInvitation = await createSilentInvitationForTeams({
+ const recoveryInvitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R2-M5 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
recoveryInvitationId = recoveryInvitation.id
})
diff --git a/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.ts b/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.ts
index b69f606f2..b9e2af420 100644
--- a/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.ts
+++ b/control-api/test/r4l1.resetPasswordPayload.externalRest.realPostgres.integration.test.ts
@@ -14,6 +14,7 @@ import { requireInternalToken } from '../src/middleware/internalServiceAuth.js'
import { sendPasswordAdmissionError } from '../src/middleware/passwordLoginAdmission.js'
import { createExternalInvitationsRouter } from '../src/routes/external/invitations.js'
import { createSilentInvitationForTeams } from '../src/services/directory/membership.js'
+import { createSilentPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { registerAndSendInvitation } from '../src/services/invitationFlowRegistrationService.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
@@ -382,19 +383,13 @@ realProducer('R4-L1 reset password payload through the public route and real pro
[email, originalHash]
)
).rows[0].id as string
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R4-L1 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
- const sibling = await createSilentInvitationForTeams({
+ const sibling = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R4-L1 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
await registerAndSendInvitation(
email,
diff --git a/control-api/test/r4m2.passwordResetFatalCommit.realPostgres.integration.test.ts b/control-api/test/r4m2.passwordResetFatalCommit.realPostgres.integration.test.ts
index db82c8f80..89da114d9 100644
--- a/control-api/test/r4m2.passwordResetFatalCommit.realPostgres.integration.test.ts
+++ b/control-api/test/r4m2.passwordResetFatalCommit.realPostgres.integration.test.ts
@@ -11,6 +11,7 @@ import {
createSilentInvitationForTeams,
setInvitationPasswordForEmail,
} from '../src/services/directory/membership.js'
+import { createSilentPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { createPostgresFatalCommitReplyInjector } from './helpers/realPostgresFatalCommit.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
@@ -78,19 +79,13 @@ realPg('R4-M2 PostgreSQL session termination after COMMIT dispatch', () => {
[email, originalHash]
)
userId = user.rows[0].id as string
- const primary = await createSilentInvitationForTeams({
+ const primary = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R4-M2 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
- const sibling = await createSilentInvitationForTeams({
+ const sibling = await createSilentPasswordResetInvitation({
inviteeName: 'Synthetic R4-M2 member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
resetInvitationId = primary.id
siblingInvitationId = sibling.id
diff --git a/control-api/test/r6.retiredRecoveryRoute.realPostgres.integration.test.ts b/control-api/test/r6.retiredRecoveryRoute.realPostgres.integration.test.ts
index 74a8880ae..1b4bfe903 100644
--- a/control-api/test/r6.retiredRecoveryRoute.realPostgres.integration.test.ts
+++ b/control-api/test/r6.retiredRecoveryRoute.realPostgres.integration.test.ts
@@ -10,6 +10,7 @@ import { initDb } from '../src/db.js'
import { requireInternalToken } from '../src/middleware/internalServiceAuth.js'
import { createExternalInvitationsRouter } from '../src/routes/external/invitations.js'
import { createSilentInvitationForTeams } from '../src/services/directory/membership.js'
+import { createSilentPasswordResetInvitation } from '../src/services/directory/passwordResetInvitations.js'
import { retireDesktopUser } from '../src/services/directory/users.js'
import { endPoolAndWaitForClients } from './helpers/realPostgresTeardown.js'
@@ -80,12 +81,9 @@ realPg('R6 retired-user password reset route and public mapping (PostgreSQL)', (
[email, initialHash]
)
userId = String(user.rows[0].id)
- const invitation = await createSilentInvitationForTeams({
+ const invitation = await createSilentPasswordResetInvitation({
inviteeName: 'R6 synthetic retired member',
email,
- purpose: 'password_reset',
- teamAssignments: [],
- fallbackRole: 'member',
})
invitationId = invitation.id
invitationToken = invitation.token