Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { type DbTransactionClient, withTransaction } from '../../db.js'
import { verifyMemberPassword } from '../auth/passwordCredentialVerification.js'
import type { TeamRole } from './types.js'
type MembershipRow = {
team_id: string | null
role: TeamRole
team_name: string | null
}
async function findFirstActiveMembership(
db: {
query: (
text: string,
values?: unknown[]
) => Promise<{ rows: unknown[]; rowCount: number | null }>
},
userId: string
) {
return db.query(
`SELECT tm.team_id, tm.role, t.name AS team_name
FROM team_members tm
JOIN teams t ON t.id = tm.team_id
JOIN users member_user ON member_user.id = tm.user_id
LEFT JOIN LATERAL (
SELECT MAX(i.accepted_at) AS accepted_at
FROM invitations i
LEFT JOIN invitation_teams it ON it.invitation_id = i.id
JOIN users u ON u.id = tm.user_id
WHERE (i.team_id = tm.team_id OR it.team_id = tm.team_id)
AND i.status = 'accepted'
AND (i.accepted_user_id = tm.user_id OR LOWER(i.email) = LOWER(u.email))
) accepted_invitation ON TRUE
WHERE tm.user_id = $1
AND tm.status = 'active'
AND member_user.lifecycle_state = 'active'
ORDER BY
CASE WHEN accepted_invitation.accepted_at IS NULL THEN 1 ELSE 0 END,
accepted_invitation.accepted_at DESC NULLS LAST,
tm.created_at ASC
LIMIT 1`,
[userId]
)
}
async function findPendingInvitationMembership(
db: {
query: (
text: string,
values?: unknown[]
) => Promise<{ rows: unknown[]; rowCount: number | null }>
},
email: string
) {
return db.query(
`SELECT COALESCE(it.team_id, i.team_id) AS team_id,
COALESCE(it.role, i.role) AS role,
t.name AS team_name
FROM invitations i
LEFT JOIN invitation_teams it ON it.invitation_id = i.id
JOIN teams t ON t.id = COALESCE(it.team_id, i.team_id)
WHERE LOWER(i.email) = LOWER($1)
AND COALESCE(it.team_id, i.team_id) IS NOT NULL
AND i.status = 'pending'
AND i.expires_at > NOW()
ORDER BY i.created_at DESC
LIMIT 1`,
[email]
)
}
async function healAcceptedInvitationMemberships(
db: {
query: (
text: string,
values?: unknown[]
) => Promise<{ rows: unknown[]; rowCount: number | null }>
},
userId: string,
email: string
) {
await db.query(
`INSERT INTO team_members(team_id, user_id, role, status)
SELECT assignment.team_id, $1, assignment.role, 'active'
FROM (
SELECT DISTINCT ON (COALESCE(it.team_id, i.team_id))
COALESCE(it.team_id, i.team_id) AS team_id,
COALESCE(it.role, i.role) AS role,
i.accepted_at,
i.created_at
FROM invitations i
LEFT JOIN invitation_teams it ON it.invitation_id = i.id
WHERE LOWER(i.email) = LOWER($2)
AND COALESCE(it.team_id, i.team_id) IS NOT NULL
AND i.status = 'accepted'
ORDER BY COALESCE(it.team_id, i.team_id), i.accepted_at DESC NULLS LAST, i.created_at DESC
) assignment
ON CONFLICT (team_id, user_id) DO UPDATE SET
role = EXCLUDED.role,
status = 'active',
updated_at = NOW()
WHERE team_members.status <> 'deleted'`,
[userId, email]
)
}
async function linkAcceptedInvitationsToUser(
db: {
query: (
text: string,
values?: unknown[]
) => Promise<{ rows: unknown[]; rowCount: number | null }>
},
userId: string,
email: string
) {
await db.query(
`UPDATE invitations
SET accepted_user_id = COALESCE(accepted_user_id, $2)
WHERE LOWER(email) = LOWER($1)
AND status = 'accepted'`,
[email, userId]
)
}
function teamlessMemberMembership(): MembershipRow {
return {
team_id: null,
role: 'member',
team_name: null,
}
}
async function currentMemberMembership(
db: Pick<DbTransactionClient, 'query'>,
user: { id: string; email: string }
): Promise<MembershipRow> {
let membership = await findFirstActiveMembership(db, user.id)
if ((membership.rowCount ?? 0) === 0) {
await healAcceptedInvitationMemberships(db, user.id, user.email)
await linkAcceptedInvitationsToUser(db, user.id, user.email)
membership = await findFirstActiveMembership(db, user.id)
}
return (membership.rows[0] as MembershipRow | undefined) || teamlessMemberMembership()
}
export async function googleLoginData(input: { email: string; name?: string; picture?: string }) {
return withTransaction(async db => {
const existing = await db.query(
`SELECT id, email, name, picture, lifecycle_state, lifecycle_version
FROM users
WHERE email = $1`,
[input.email]
)
const isNewUser = (existing.rowCount ?? 0) === 0
if (
!isNewUser &&
(existing.rows[0] as { lifecycle_state?: unknown }).lifecycle_state !== 'active'
) {
return { error: 'user_retired' as const }
}
const userResult = isNewUser
? await db.query(
`INSERT INTO users(email, name, picture)
VALUES($1, $2, $3)
RETURNING id, email, name, picture, lifecycle_version`,
[input.email, input.name || null, input.picture || null]
)
: await db.query(
`UPDATE users
SET name = COALESCE($2, name),
picture = COALESCE($3, picture),
updated_at = NOW()
WHERE email = $1
RETURNING id, email, name, picture, lifecycle_version`,
[input.email, input.name || null, input.picture || null]
)
const user = userResult.rows[0] as {
id: string
email: string
name: string | null
picture: string | null
lifecycle_version: number | string | null
}
await db.query(
`INSERT INTO profiles(user_id, display_name)
VALUES($1, $2)
ON CONFLICT (user_id) DO NOTHING`,
[user.id, input.name || null]
)
await healAcceptedInvitationMemberships(db, user.id, input.email)
await linkAcceptedInvitationsToUser(db, user.id, input.email)
let membership = await findFirstActiveMembership(db, user.id)
if ((membership.rowCount ?? 0) === 0) {
membership = await findPendingInvitationMembership(db, input.email)
}
return {
isNewUser,
authGeneration: Number(user.lifecycle_version || 0),
user,
membership: ((membership.rows[0] as MembershipRow | undefined) ||
teamlessMemberMembership()) as MembershipRow,
}
})
}
export async function passwordLoginData(input: { email: string; password: string }) {
const user = await verifyMemberPassword(input.email, input.password, { publicLogin: true })
if (!user) return null
return withTransaction(async db => {
return {
authGeneration: Number(user.lifecycle_version || 0),
user: {
id: user.id,
email: user.email,
name: user.name,
picture: user.picture,
},
membership: await currentMemberMembership(db, user),
}
})
}
/** Resolve ordinary session claims in the same transaction as password recovery. */
export async function getMemberSessionContext(
db: Pick<DbTransactionClient, 'query'>,
user: { id: string; email: string; lifecycle_version?: number | string | null }
) {
const membership = await currentMemberMembership(db, user)
return {
userId: user.id,
email: user.email,
teamId: membership.team_id,
role: membership.role,
authGeneration: Number(user.lifecycle_version || 0),
}
}
export async function verifyUserPassword(input: {
userId: string
email: string
password: string
}): Promise<boolean> {
const user = await verifyMemberPassword(input.email, input.password, {
publicLogin: false,
userId: input.userId.trim(),
})
return !!user
}