143 lines
5.5 KiB
TypeScript
143 lines
5.5 KiB
TypeScript
import type { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction } from "react-router";
|
|
import { useFetcher, useLoaderData } from "react-router";
|
|
|
|
import type { AuditEventWriterClient } from "@hivegrid/db/audit-events.server";
|
|
import { runWithRlsTransaction } from "@hivegrid/db/rls-context.server";
|
|
import { buildAdminSecurityProfileVM } from "@hivegrid/view-models";
|
|
|
|
import { AdminSecurityProfilePage } from "~/components/screens/admin/sales/security/AdminSecurityProfilePage";
|
|
import { useSaveToast } from "~/hooks/use-save-toast";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import { assertAdminActionReason, recordAdminAction } from "~/services/admin/admin-action-audit.server";
|
|
import { requireAdminIdentityPermission, runAsAdminIdentity } from "~/services/admin/admin-identity.server";
|
|
import { db } from "~/utils/db.server";
|
|
import { useRootData } from "~/utils/data/useRootData";
|
|
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
|
|
import { validateCSRFToken } from "~/utils/session.server";
|
|
|
|
type ActionData = { ok: true; messageKey: string } | { ok: false; errorKey: string };
|
|
|
|
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
|
|
|
|
export async function loader({ request }: LoaderFunctionArgs) {
|
|
const session = await requireAdminIdentityPermission(request, "admin_identity.sessions.read");
|
|
const admin = await runAsAdminIdentity(request, "admin_identity.sessions.read", () =>
|
|
db.adminUser.findUnique({
|
|
where: { id: session.adminUserId },
|
|
select: {
|
|
id: true,
|
|
email: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
status: true,
|
|
authentikSubject: true,
|
|
lastSsoLoginAt: true,
|
|
roles: {
|
|
where: { role: { active: true } },
|
|
select: { role: { select: { id: true, name: true, systemKey: true } } },
|
|
},
|
|
sessions: {
|
|
where: { revokedAt: null, expiresAt: { gt: new Date() } },
|
|
select: {
|
|
id: true,
|
|
createdAt: true,
|
|
lastSeenAt: true,
|
|
expiresAt: true,
|
|
approxLocation: true,
|
|
userAgent: true,
|
|
mfaAssuredAt: true,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
);
|
|
if (!admin) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
|
|
const { t } = await getTranslations(request);
|
|
return {
|
|
title: `${t("admin.sales.security.title")} | ${process.env.APP_NAME}`,
|
|
vm: buildAdminSecurityProfileVM({
|
|
identity: admin,
|
|
roles: admin.roles.map((assignment) => assignment.role),
|
|
sessions: admin.sessions,
|
|
currentSessionId: session.id,
|
|
}),
|
|
};
|
|
}
|
|
|
|
export async function action({ request }: ActionFunctionArgs): Promise<Response> {
|
|
await validateCSRFToken(request);
|
|
const currentSession = await requireAdminIdentityPermission(request, "admin_identity.sessions.revoke");
|
|
const form = await request.formData();
|
|
if (form.get("intent") !== "revoke-session") {
|
|
return Response.json({ ok: false, errorKey: "admin.sales.security.errors.revokeFailed" } satisfies ActionData, { status: 400 });
|
|
}
|
|
const sessionId = String(form.get("sessionId") ?? "").trim();
|
|
if (!sessionId || sessionId === currentSession.id) {
|
|
return Response.json({ ok: false, errorKey: "admin.sales.security.errors.revokeFailed" } satisfies ActionData, { status: 400 });
|
|
}
|
|
|
|
let reason: string;
|
|
try {
|
|
reason = assertAdminActionReason(String(form.get("reason") ?? ""));
|
|
} catch {
|
|
return Response.json({ ok: false, errorKey: "admin.audit.errors.reasonTooShort" } satisfies ActionData, { status: 400 });
|
|
}
|
|
|
|
const result = await runAsAdminIdentity(request, "admin_identity.sessions.revoke", () =>
|
|
db.$transaction(async (transaction) =>
|
|
runWithRlsTransaction(transaction, async () => {
|
|
const revoked = await transaction.adminSession.updateMany({
|
|
where: {
|
|
id: sessionId,
|
|
adminUserId: currentSession.adminUserId,
|
|
revokedAt: null,
|
|
},
|
|
data: { revokedAt: new Date() },
|
|
});
|
|
if (revoked.count !== 1) return "missing" as const;
|
|
await recordAdminAction(
|
|
{
|
|
action: "security.sessionRevoked",
|
|
actorUserId: currentSession.adminUserId,
|
|
actorEmail: currentSession.adminUser.email,
|
|
targetKind: "admin-session",
|
|
targetId: sessionId,
|
|
reason,
|
|
request,
|
|
},
|
|
transaction as unknown as AuditEventWriterClient
|
|
);
|
|
return "revoked" as const;
|
|
})
|
|
)
|
|
);
|
|
if (result !== "revoked") {
|
|
return Response.json({ ok: false, errorKey: "admin.sales.security.errors.revokeFailed" } satisfies ActionData, { status: 404 });
|
|
}
|
|
return Response.json({ ok: true, messageKey: "admin.sales.security.toast.sessionRevoked" } satisfies ActionData);
|
|
}
|
|
|
|
export default function AdminSecurityProfileRoute() {
|
|
const data = useLoaderData<typeof loader>();
|
|
const fetcher = useFetcher<ActionData>();
|
|
const rootData = useRootData();
|
|
useSaveToast(fetcher.data?.ok ? fetcher.data : undefined);
|
|
return (
|
|
<AdminSecurityProfilePage
|
|
vm={data.vm}
|
|
busy={fetcher.state !== "idle"}
|
|
errorKey={fetcher.data && !fetcher.data.ok ? fetcher.data.errorKey : undefined}
|
|
actions={{
|
|
onRevokeSession: ({ sessionId, reason }) => {
|
|
const form = new FormData();
|
|
form.set("intent", "revoke-session");
|
|
form.set("sessionId", sessionId);
|
|
form.set("reason", reason);
|
|
if (rootData.csrf) form.set("csrf", rootData.csrf);
|
|
fetcher.submit(form, { method: "post" });
|
|
},
|
|
}}
|
|
/>
|
|
);
|
|
}
|