"use client"; import { useCallback, useEffect, useState } from "react"; import type { TFunction } from "i18next"; import { useTranslation } from "react-i18next"; import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, } from "@kandev/ui/alert-dialog"; import { Badge } from "@kandev/ui/badge"; import { Button } from "@kandev/ui/button"; import { Card, CardContent, CardHeader, CardTitle } from "@kandev/ui/card"; import { Spinner } from "@kandev/ui/spinner"; import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@kandev/ui/table"; import { IconMailForward, IconUserPlus, IconUsers } from "@tabler/icons-react"; import { useToast } from "@/components/toast-provider"; import { ApiError } from "@/lib/api/client"; import { listUsers, updateUser, type AuthUser } from "@/lib/api/domains/auth-api"; import { CreateUserDialog } from "./create-user-dialog"; import { InviteDialog } from "./invite-dialog"; type PendingAction = { user: AuthUser; next: { role?: string; status?: string }; label: string }; /** * `role` and `status` are wire values sent straight back to the API, so the * `next` payload above always carries the raw token. Only these badge/button * labels are copy, and an unrecognized value from a newer backend echoes the * token rather than rendering blank. */ const ROLE_LABEL_KEYS: Record = { admin: "system:usersRoleAdmin", member: "system:usersRoleMember", }; const STATUS_LABEL_KEYS: Record = { active: "system:usersStatusActive", disabled: "system:usersStatusDisabled", }; function roleLabel(role: string, t: TFunction): string { return ROLE_LABEL_KEYS[role] ? t(ROLE_LABEL_KEYS[role]) : role; } function useUsersList(t: TFunction) { const [users, setUsers] = useState([]); const [loaded, setLoaded] = useState(false); const [isLoading, setIsLoading] = useState(false); const [error, setError] = useState(null); const reload = useCallback(async () => { setIsLoading(true); setError(null); try { const res = await listUsers({ cache: "no-store" }); setUsers(res.users); setLoaded(true); } catch (err) { setError(err instanceof ApiError ? err.message : t("system:usersLoadFailed")); } finally { setIsLoading(false); } }, [t]); useEffect(() => { void reload(); }, [reload]); return { users, loaded, isLoading, error, reload }; } function StatusBadge({ status }: { status: string }) { const { t } = useTranslation(); return ( {STATUS_LABEL_KEYS[status] ? t(STATUS_LABEL_KEYS[status]) : status} ); } function UserRow({ user, onToggleRole, onToggleStatus, }: { user: AuthUser; onToggleRole: (user: AuthUser) => void; onToggleStatus: (user: AuthUser) => void; }) { const { t } = useTranslation(); const isDisabled = user.status === "disabled"; return ( {/* Email and display name are user data. */} {user.email} {user.display_name} {roleLabel(user.role, t)}
); } function UsersConfirmDialog({ pending, onCancel, onConfirm, }: { pending: PendingAction | null; onCancel: () => void; onConfirm: () => void; }) { const { t } = useTranslation(); return ( !open && onCancel()}> {pending?.label} {t("system:usersTakesEffectImmediately", { email: pending?.user.email ?? "" })} {t("common:cancel")} {t("system:usersConfirm")} ); } /** * These two build the confirmation sentence outside JSX, which is why * `mode: "jsx-only"` never reported them. The email is interpolated as a value * and the target role travels as its own translated label. */ function roleTogglePending(u: AuthUser, t: TFunction): PendingAction { const next = u.role === "admin" ? "member" : "admin"; return { user: u, next: { role: next }, label: t("system:usersConfirmRoleChange", { email: u.email, role: roleLabel(next, t) }), }; } function statusTogglePending(u: AuthUser, t: TFunction): PendingAction { const disabling = u.status !== "disabled"; return { user: u, next: { status: disabling ? "disabled" : "active" }, label: disabling ? t("system:usersConfirmDisable", { email: u.email }) : t("system:usersConfirmEnable", { email: u.email }), }; } function UsersTableList({ users, onToggleRole, onToggleStatus, }: { users: AuthUser[]; onToggleRole: (u: AuthUser) => void; onToggleStatus: (u: AuthUser) => void; }) { const { t } = useTranslation(); return ( {t("system:usersColumnEmail")} {t("system:usersColumnName")} {t("system:usersColumnRole")} {t("system:usersColumnStatus")} {t("system:usersColumnActions")} {users.map((user) => ( ))}
); } export function UsersTable() { const { t } = useTranslation(); const { users, loaded, isLoading, error, reload } = useUsersList(t); const [createOpen, setCreateOpen] = useState(false); const [inviteOpen, setInviteOpen] = useState(false); const [pending, setPending] = useState(null); const { toast } = useToast(); const onConfirm = async () => { if (!pending) return; try { await updateUser(pending.user.id, pending.next); await reload(); } catch (err) { toast({ variant: "error", title: t("system:usersUpdateFailed"), description: err instanceof ApiError ? err.message : t("system:usersLastAdminGuard"), }); } finally { setPending(null); } }; return ( {t("system:usersTitle")}
{error && (

{error}

)} {!loaded && isLoading && (
{t("system:usersLoading")}
)} {loaded && users.length > 0 && ( setPending(roleTogglePending(u, t))} onToggleStatus={(u) => setPending(statusTogglePending(u, t))} /> )} {loaded && users.length === 0 && !error && (

{t("system:usersEmpty")}

)}
void reload()} /> void reload()} /> setPending(null)} onConfirm={() => void onConfirm()} />
); }