Skip to content

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

TypeScript

feat(control-api): carry replaceInviter and inviter on control admin invitations

Jose Gabriel Ramirez Encinasbac0426686f1
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index 5866a0ac6..b18e36f6c 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.638",
+ "version": "0.1.639",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.638",
+ "version": "0.1.639",
"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 2783e9829..770c65c01 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.638",
+ "version": "0.1.639",
"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/adminAuthService.ts b/control-api/src/services/adminAuthService.ts
index 3d94b0a32..e8e3bc2b3 100644
--- a/control-api/src/services/adminAuthService.ts
+++ b/control-api/src/services/adminAuthService.ts
@@ -55,8 +55,15 @@ export type ControlAdminInvitationRecord = {
expiresAt: Date
createdAt: Date
acceptedAt: Date | null
+ /** Accepting this invitation retires the inviter (completeControlAdminInvitation). */
+ replaceInviter: boolean
+ /** NULL when the inviting admin row was deleted (FK ON DELETE SET NULL). */
+ invitedByAdminId: string | null
}
+const INVITATION_COLUMNS =
+ 'id, email, status, expires_at, created_at, accepted_at, invited_by_admin_id, replace_inviter'
+
export type ControlAdminEmailChangeRequestRecord = {
id: string
adminId: string
@@ -104,10 +111,12 @@ function mapAdminRow(row: {
function mapInvitationRow(row: {
id: string
email: string
- status: 'pending' | 'accepted' | 'revoked'
+ status: 'pending' | 'opened' | 'accepted' | 'revoked'
expires_at: Date
created_at: Date
accepted_at: Date | null
+ invited_by_admin_id: string | null
+ replace_inviter: boolean | null
}): ControlAdminInvitationRecord {
return {
id: row.id,
@@ -116,6 +125,8 @@ function mapInvitationRow(row: {
expiresAt: new Date(row.expires_at),
createdAt: new Date(row.created_at),
acceptedAt: row.accepted_at ? new Date(row.accepted_at) : null,
+ replaceInviter: row.replace_inviter === true,
+ invitedByAdminId: row.invited_by_admin_id ?? null,
}
}
@@ -716,7 +727,7 @@ export async function listControlAdmins(): Promise<{
ORDER BY accepted_at DESC, created_at DESC`
),
pool.query(
- `SELECT id, email, status, expires_at, created_at, accepted_at
+ `SELECT ${INVITATION_COLUMNS}
FROM control_admin_invitations
WHERE status = 'pending'
ORDER BY created_at DESC`
@@ -821,9 +832,11 @@ export async function listControlAdmins(): Promise<{
export async function createControlAdminInvitation(
email: string,
- invitedByAdminId: string
+ invitedByAdminId: string,
+ options: { replaceInviter?: boolean } = {}
): Promise<ControlAdminInvitationRecord | { error: 'duplicate_email' }> {
const normalizedEmail = normalizeEmail(email)
+ const replaceInviter = options.replaceInviter === true
// Revoke expired active invitations first so the INSERT guard can treat any remaining
// pending/opened invitation as a real blocker for the partial unique index.
await pool.query(
@@ -838,8 +851,8 @@ export async function createControlAdminInvitation(
let result
try {
result = await pool.query(
- `INSERT INTO control_admin_invitations(email, invited_by_admin_id)
- SELECT $1, $2
+ `INSERT INTO control_admin_invitations(email, invited_by_admin_id, replace_inviter)
+ SELECT $1, $2, $3::boolean
WHERE NOT EXISTS (
SELECT 1 FROM control_admin_users WHERE lower(email) = lower($1)
)
@@ -848,8 +861,8 @@ export async function createControlAdminInvitation(
WHERE lower(email) = lower($1)
AND status IN ('pending', 'opened')
)
- RETURNING id, email, status, expires_at, created_at, accepted_at`,
- [normalizedEmail, invitedByAdminId]
+ RETURNING ${INVITATION_COLUMNS}`,
+ [normalizedEmail, invitedByAdminId, replaceInviter]
)
} catch (error) {
if (
@@ -888,7 +901,7 @@ export async function getPendingControlAdminInvitation(
email: string
): Promise<ControlAdminInvitationRecord | null> {
const result = await db.query(
- `SELECT id, email, status, expires_at, created_at, accepted_at
+ `SELECT ${INVITATION_COLUMNS}
FROM control_admin_invitations
WHERE id = $1
AND lower(email) = lower($2)
diff --git a/control-api/test/services.controlAdminReplaceInviter.realPostgres.integration.test.ts b/control-api/test/services.controlAdminReplaceInviter.realPostgres.integration.test.ts
new file mode 100644
index 000000000..cbcc6e3b0
--- /dev/null
+++ b/control-api/test/services.controlAdminReplaceInviter.realPostgres.integration.test.ts
@@ -0,0 +1,187 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+import { randomBytes, randomUUID } from 'node:crypto'
+import { Pool } from 'pg'
+import { initDb, pool } from '../src/db.js'
+import {
+ completeControlAdminInvitation,
+ createControlAdminInvitation,
+ findAdminByLogin,
+ getPendingControlAdminInvitation,
+ listControlAdmins,
+ revokeControlAdminInvitation,
+} from '../src/services/adminAuthService.js'
+import { passwordLoginData } from '../src/services/directory/login.js'
+import {
+ acceptInvitationById,
+ createSilentInvitationForTeams,
+} from '../src/services/directory/membership.js'
+
+const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
+const describeRealPostgres = adminUrl ? describe : describe.skip
+
+function databaseUrl(baseUrl: string, database: string): string {
+ const url = new URL(baseUrl)
+ url.pathname = `/${database}`
+ return url.toString()
+}
+
+function quoteIdent(value: string): string {
+ return `"${value.replace(/"/g, '""')}"`
+}
+
+function uniqueEmail(label: string): string {
+ return `${label}-${randomUUID()}@example.test`
+}
+
+describeRealPostgres('control admin replace-inviter invitations on real PostgreSQL', () => {
+ const database = `control_admin_replace_${randomBytes(6).toString('hex')}`
+ const connectionString = databaseUrl(
+ adminUrl ?? 'postgresql://[email protected]/postgres',
+ database
+ )
+ let adminPool: Pool
+ let testPool: Pool
+ let connectSpy: ReturnType<typeof vi.spyOn>
+ let querySpy: ReturnType<typeof vi.spyOn>
+
+ async function seedAdmin(
+ label: string
+ ): Promise<{ id: string; username: string; email: string }> {
+ const id = randomUUID()
+ const username = `${label}-${id.slice(0, 8)}`
+ const email = `${username}@example.test`
+ await testPool.query(
+ `INSERT INTO control_admin_users (id, username, email, password_hash, role, status, session_version)
+ VALUES ($1, $2, $3, 'real-pg-replace-test', 'admin', 'active', 1)`,
+ [id, username, email]
+ )
+ return { id, username, email }
+ }
+
+ async function seedDesktopUser(email: string): Promise<string> {
+ const id = randomUUID()
+ await testPool.query(`INSERT INTO users (id, email, name) VALUES ($1, $2, $3)`, [
+ id,
+ email,
+ email,
+ ])
+ return id
+ }
+
+ async function seedTeam(name: string): Promise<string> {
+ const result = await testPool.query(
+ `INSERT INTO teams (name) VALUES ($1) RETURNING id::text AS id`,
+ [name]
+ )
+ return (result.rows[0] as { id: string }).id
+ }
+
+ async function addTeamMember(teamId: string, userId: string, role: string): Promise<void> {
+ await testPool.query(
+ `INSERT INTO team_members (team_id, user_id, role, status) VALUES ($1::uuid, $2::uuid, $3, 'active')`,
+ [teamId, userId, role]
+ )
+ }
+
+ async function seedOperatorLink(userId: string, adminId: string): Promise<void> {
+ await testPool.query(
+ `INSERT INTO gfs_desktop_operator_links
+ (id, lineage_id, generation, user_id, control_admin_id, state, source, created_by, row_version)
+ VALUES (gen_random_uuid(), gen_random_uuid(), 1, $1::uuid, $2::uuid,
+ 'active', 'initial_setup', $2::uuid, 1)`,
+ [userId, adminId]
+ )
+ }
+
+ async function inviteDesktopAccess(email: string): Promise<string> {
+ const invitation = await createSilentInvitationForTeams({
+ inviteeName: email,
+ email,
+ teamAssignments: [],
+ fallbackRole: 'member',
+ purpose: 'admin_desktop_access',
+ })
+ return invitation.id
+ }
+
+ async function adminInvitationStatus(id: string): Promise<string | undefined> {
+ const result = await testPool.query(
+ `SELECT status FROM control_admin_invitations WHERE id = $1::uuid`,
+ [id]
+ )
+ return (result.rows[0] as { status?: string } | undefined)?.status
+ }
+
+ async function desktopInvitationStatus(id: string): Promise<string | undefined> {
+ const result = await testPool.query(`SELECT status FROM invitations WHERE id = $1::uuid`, [id])
+ return (result.rows[0] as { status?: string } | undefined)?.status
+ }
+
+ async function adminStatus(id: string): Promise<string | undefined> {
+ const result = await testPool.query(
+ `SELECT status FROM control_admin_users WHERE id = $1::uuid`,
+ [id]
+ )
+ return (result.rows[0] as { status?: string } | undefined)?.status
+ }
+
+ async function desktopLifecycle(id: string): Promise<string | undefined> {
+ const result = await testPool.query(`SELECT lifecycle_state FROM users WHERE id = $1::uuid`, [
+ id,
+ ])
+ return (result.rows[0] as { lifecycle_state?: string } | undefined)?.lifecycle_state
+ }
+
+ beforeAll(async () => {
+ adminPool = new Pool({ connectionString: adminUrl })
+ await adminPool.query(`CREATE DATABASE ${quoteIdent(database)}`)
+ testPool = new Pool({ connectionString })
+ await initDb({ connect: () => testPool.connect() })
+ connectSpy = vi
+ .spyOn(pool, 'connect')
+ .mockImplementation((() => testPool.connect()) as typeof pool.connect)
+ querySpy = vi
+ .spyOn(pool, 'query')
+ .mockImplementation(((text: string, values?: unknown[]) =>
+ testPool.query(text, values)) as unknown as typeof pool.query)
+ }, 60_000)
+
+ afterAll(async () => {
+ querySpy?.mockRestore()
+ connectSpy?.mockRestore()
+ await testPool?.end()
+ if (!adminPool) return
+ await adminPool.query(
+ `SELECT pg_terminate_backend(pid) FROM pg_stat_activity
+ WHERE datname = $1 AND pid <> pg_backend_pid()`,
+ [database]
+ )
+ await adminPool.query(`DROP DATABASE IF EXISTS ${quoteIdent(database)}`)
+ await adminPool.end()
+ })
+
+ it('stores replaceInviter and exposes it with the inviter on every invitation read', async () => {
+ const inviter = await seedAdmin('lister')
+ const replacing = await createControlAdminInvitation(uniqueEmail('replacing'), inviter.id, {
+ replaceInviter: true,
+ })
+ const plain = await createControlAdminInvitation(uniqueEmail('plain'), inviter.id)
+ if ('error' in replacing || 'error' in plain) throw new Error('invitation insert failed')
+
+ expect(replacing).toMatchObject({ replaceInviter: true, invitedByAdminId: inviter.id })
+ expect(plain).toMatchObject({ replaceInviter: false, invitedByAdminId: inviter.id })
+
+ const listed = await listControlAdmins()
+ expect(listed.invitations.find(item => item.id === replacing.id)).toMatchObject({
+ replaceInviter: true,
+ invitedByAdminId: inviter.id,
+ })
+ expect(listed.invitations.find(item => item.id === plain.id)).toMatchObject({
+ replaceInviter: false,
+ invitedByAdminId: inviter.id,
+ })
+ await expect(
+ getPendingControlAdminInvitation(testPool, replacing.id, replacing.email)
+ ).resolves.toMatchObject({ replaceInviter: true, invitedByAdminId: inviter.id })
+ })
+})