Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,129 @@
// @vitest-environment node
import type { ActionFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
const { adminSession, transaction } = vi.hoisted(() => ({
adminSession: {
id: "session-current",
adminUserId: "admin-1",
adminUser: { id: "admin-1", email: "admin@example.test" },
},
transaction: {
adminSession: { updateMany: vi.fn() },
},
}));
vi.mock("@hivegrid/db/admin-rbac.server", () => ({
disableAdminUserInTransaction: vi.fn(),
replaceAdminSystemRolesInTransaction: vi.fn(),
}));
vi.mock("@hivegrid/db/admin-permissions", () => ({
ADMIN_ROLE_KEYS: ["super_admin", "support", "sales", "sales_manager", "engineering", "executive", "viewer"],
}));
vi.mock("@hivegrid/db/rls-context.server", () => ({
runWithRlsTransaction: vi.fn(async (_transaction, operation: () => Promise<unknown>) => operation()),
}));
vi.mock("~/components/screens/admin/sales/security/AdminUserDetailPage", () => ({ AdminUserDetailPage: () => null }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
vi.mock("~/services/admin/admin-action-audit.server", async () => {
const actual = await vi.importActual<typeof import("~/services/admin/admin-action-audit.server")>(
"~/services/admin/admin-action-audit.server"
);
return { ...actual, recordAdminAction: vi.fn() };
});
vi.mock("~/services/admin/admin-identity.server", () => ({
runAsAdminIdentity: vi.fn(async (_request, _permission, operation) => operation(adminSession)),
}));
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({ csrf: "csrf" }) }));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn() }));
vi.mock("~/utils/db.server", () => ({
db: { $transaction: vi.fn(async (operation) => operation(transaction)) },
}));
import { disableAdminUserInTransaction, replaceAdminSystemRolesInTransaction } from "@hivegrid/db/admin-rbac.server";
import { recordAdminAction } from "~/services/admin/admin-action-audit.server";
import { runAsAdminIdentity } from "~/services/admin/admin-identity.server";
import { action } from "./$id";
function callAction(values: Array<[string, string]>, id = "admin-2") {
const body = new URLSearchParams();
for (const [key, value] of values) body.append(key, value);
return action({
request: new Request(`https://admin.example.test/settings/admin-users/${id}`, { method: "POST", body }),
params: { id },
context: {},
unstable_pattern: "admin/settings/admin-users/$id",
} as ActionFunctionArgs);
}
describe("admin user detail actions", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(replaceAdminSystemRolesInTransaction).mockResolvedValue(true);
vi.mocked(disableAdminUserInTransaction).mockResolvedValue(true);
transaction.adminSession.updateMany.mockResolvedValue({ count: 1 });
});
it("replaces typed roles through the smallest permission and audits the change", async () => {
const response = await callAction([
["intent", "save-roles"],
["reason", "Verantwortung im Sales-Team geändert"],
["roleKey", "sales"],
["roleKey", "viewer"],
["roleKey", "unknown"],
]);
expect(response.status).toBe(200);
expect(runAsAdminIdentity).toHaveBeenCalledWith(
expect.any(Request),
"admin_identity.users.manage",
expect.any(Function)
);
expect(replaceAdminSystemRolesInTransaction).toHaveBeenCalledWith({
adminUserId: "admin-2",
roleKeys: ["sales", "viewer"],
grantedByAdminUserId: "admin-1",
client: transaction,
});
expect(recordAdminAction).toHaveBeenCalledWith(
expect.objectContaining({
action: "security.adminRolesChanged",
targetId: "admin-2",
reason: "Verantwortung im Sales-Team geändert",
}),
transaction
);
});
it("maps last-superadmin protection to a stable user-facing failure", async () => {
vi.mocked(replaceAdminSystemRolesInTransaction).mockRejectedValueOnce(
Object.assign(new Error("protected"), { code: "ADMIN_LAST_SUPER_ADMIN" })
);
const response = await callAction([
["intent", "save-roles"],
["reason", "Rollenbereinigung im Admin-Team"],
["roleKey", "viewer"],
]);
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
ok: false,
errorKey: "admin.sales.adminUserDetail.errors.lastSuperAdmin",
});
});
it("prevents self-disable before calling the domain mutation", async () => {
const response = await callAction(
[
["intent", "disable"],
["reason", "Admin-Zugang wird deaktiviert"],
],
adminSession.adminUserId
);
expect(response.status).toBe(400);
expect(disableAdminUserInTransaction).not.toHaveBeenCalled();
expect(recordAdminAction).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,234 @@
import type { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction } from "react-router";
import { useFetcher, useLoaderData, useNavigate } from "react-router";
import type { AuditEventWriterClient } from "@hivegrid/db/audit-events.server";
import { disableAdminUserInTransaction, replaceAdminSystemRolesInTransaction } from "@hivegrid/db/admin-rbac.server";
import type { AdminRoleKey } from "@hivegrid/db/admin-permissions";
import { ADMIN_ROLE_KEYS } from "@hivegrid/db/admin-permissions";
import { runWithRlsTransaction } from "@hivegrid/db/rls-context.server";
import { buildAdminUserDetailVM } from "@hivegrid/view-models";
import { AdminUserDetailPage } from "~/components/screens/admin/sales/security/AdminUserDetailPage";
import { useSaveToast } from "~/hooks/use-save-toast";
import { getTranslations } from "~/locale/i18next.server";
import { assertAdminActionReason, recordAdminAction } from "~/services/admin/admin-action-audit.server";
import { runAsAdminIdentity } from "~/services/admin/admin-identity.server";
import { useRootData } from "~/utils/data/useRootData";
import { db } from "~/utils/db.server";
import { NOT_FOUND_ENVELOPE } from "~/utils/errors.server";
import { validateCSRFToken } from "~/utils/session.server";
type ActionData = { ok: true; intent: string; messageKey: string } | { ok: false; errorKey: string };
const roleKeySet = new Set<string>(ADMIN_ROLE_KEYS);
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export async function loader({ request, params }: LoaderFunctionArgs) {
const targetId = params.id;
if (!targetId) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
const { t } = await getTranslations(request);
const vm = await runAsAdminIdentity(request, "admin_identity.users.read", async (session) => {
const [user, availableRoles, audit] = await Promise.all([
db.adminUser.findUnique({
where: { id: targetId },
select: {
id: true,
email: true,
firstName: true,
lastName: true,
status: true,
authentikSubject: true,
lastSsoLoginAt: true,
roles: {
select: {
role: {
select: {
id: true,
name: true,
systemKey: true,
permissions: { select: { permission: { select: { name: true } } } },
},
},
},
},
sessions: {
where: { revokedAt: null, expiresAt: { gt: new Date() } },
select: {
id: true,
createdAt: true,
lastSeenAt: true,
expiresAt: true,
approxLocation: true,
userAgent: true,
mfaAssuredAt: true,
},
},
},
}),
db.adminRole.findMany({ where: { active: true, systemKey: { not: null } }, select: { id: true, name: true, systemKey: true } }),
db.auditEvent.findMany({
where: { tenantId: null, targetType: "admin-user", targetId },
select: { id: true, action: true, createdAt: true, summaryText: true },
orderBy: [{ createdAt: "desc" }, { id: "desc" }],
take: 25,
}),
]);
if (!user) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
return buildAdminUserDetailVM({
user,
sessions: user.sessions,
availableRoles,
audit,
currentAdminUserId: session.adminUserId,
currentSessionId: session.id,
});
});
return { title: `${vm.user.displayName} | ${t("admin.sales.adminUsers.title")}`, vm };
}
export async function action({ request, params }: ActionFunctionArgs) {
const targetId = params.id;
if (!targetId) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
await validateCSRFToken(request);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
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 });
}
try {
await runAsAdminIdentity(request, intent === "revoke-session" ? "admin_identity.sessions.revoke" : "admin_identity.users.manage", async (session) =>
db.$transaction((transaction) =>
runWithRlsTransaction(transaction, async () => {
if (intent === "save-roles") {
const requested = form
.getAll("roleKey")
.map(String)
.filter((key): key is AdminRoleKey => roleKeySet.has(key));
if (requested.length === 0) throw new Error("At least one role is required");
const updated = await replaceAdminSystemRolesInTransaction({
adminUserId: targetId,
roleKeys: requested,
grantedByAdminUserId: session.adminUserId,
client: transaction,
});
if (!updated) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
await recordAdminAction(
{
action: "security.adminRolesChanged",
actorUserId: session.adminUserId,
actorEmail: session.adminUser.email,
targetKind: "admin-user",
targetId,
reason,
request,
after: { roleKeys: requested },
},
transaction as unknown as AuditEventWriterClient
);
return;
}
if (intent === "disable") {
if (targetId === session.adminUserId) throw new Error("Self-disable is not allowed");
const disabled = await disableAdminUserInTransaction({ adminUserId: targetId, reason, client: transaction });
if (!disabled) throw Response.json(NOT_FOUND_ENVELOPE, { status: 404 });
await recordAdminAction(
{
action: "security.adminUserDisabled",
actorUserId: session.adminUserId,
actorEmail: session.adminUser.email,
targetKind: "admin-user",
targetId,
reason,
request,
},
transaction as unknown as AuditEventWriterClient
);
return;
}
if (intent === "revoke-session") {
const sessionId = String(form.get("sessionId") ?? "");
if (!sessionId || sessionId === session.id) throw new Error("Current session cannot be revoked here");
const result = await transaction.adminSession.updateMany({
where: { id: sessionId, adminUserId: targetId, revokedAt: null },
data: { revokedAt: new Date() },
});
if (result.count !== 1) throw new Error("Session not found");
await recordAdminAction(
{
action: "security.sessionRevoked",
actorUserId: session.adminUserId,
actorEmail: session.adminUser.email,
targetKind: "admin-user",
targetId,
reason,
request,
extraMeta: { sessionId },
},
transaction as unknown as AuditEventWriterClient
);
return;
}
throw new Error("Unsupported action");
})
)
);
const messageKeyByIntent: Record<string, string> = {
"save-roles": "admin.sales.adminUserDetail.toast.rolesSaved",
disable: "admin.sales.adminUserDetail.toast.disabled",
"revoke-session": "admin.sales.adminUserDetail.toast.sessionRevoked",
};
return Response.json({
ok: true,
intent,
messageKey: messageKeyByIntent[intent] ?? "admin.sales.adminUserDetail.toast.saved",
} satisfies ActionData);
} catch (error) {
if (error instanceof Response) throw error;
const errorKey =
error instanceof Error && "code" in error && error.code === "ADMIN_LAST_SUPER_ADMIN"
? "admin.sales.adminUserDetail.errors.lastSuperAdmin"
: "admin.sales.adminUserDetail.errors.updateFailed";
return Response.json({ ok: false, errorKey } satisfies ActionData, { status: 400 });
}
}
export default function AdminUserDetailRoute() {
const { vm } = useLoaderData<typeof loader>();
const fetcher = useFetcher<ActionData>();
const navigate = useNavigate();
const root = useRootData();
useSaveToast(fetcher.data?.ok ? fetcher.data : undefined);
const submit = (entries: Array<[string, string]>) => {
const form = new FormData();
for (const [key, value] of entries) form.append(key, value);
if (root.csrf) form.set("csrf", root.csrf);
fetcher.submit(form, { method: "post" });
};
return (
<AdminUserDetailPage
vm={vm}
busy={fetcher.state !== "idle"}
errorKey={fetcher.data && !fetcher.data.ok ? fetcher.data.errorKey : undefined}
actions={{
onBack: () => navigate(".."),
onSaveRoles: ({ roleKeys, reason }) =>
submit([["intent", "save-roles"], ["reason", reason], ...roleKeys.map((roleKey): [string, string] => ["roleKey", roleKey])]),
onDisable: (reason) =>
submit([
["intent", "disable"],
["reason", reason],
]),
onRevokeSession: ({ sessionId, reason }) =>
submit([
["intent", "revoke-session"],
["sessionId", sessionId],
["reason", reason],
]),
}}
/>
);
}
@@ -0,0 +1,126 @@
// @vitest-environment node
import type { ActionFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
const { adminSession, transaction } = vi.hoisted(() => ({
adminSession: {
id: "session-1",
adminUserId: "admin-1",
adminUser: { id: "admin-1", email: "admin@example.test" },
},
transaction: {
adminRole: { findMany: vi.fn() },
adminUser: { create: vi.fn() },
},
}));
vi.mock("@hivegrid/db/rls-context.server", () => ({
runWithRlsTransaction: vi.fn(async (_transaction, operation: () => Promise<unknown>) => operation()),
}));
vi.mock("~/components/screens/admin/sales/security/AdminUsersPage", () => ({ AdminUsersPage: () => null }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
vi.mock("~/services/admin/admin-action-audit.server", async () => {
const actual = await vi.importActual<typeof import("~/services/admin/admin-action-audit.server")>(
"~/services/admin/admin-action-audit.server"
);
return { ...actual, recordAdminAction: vi.fn() };
});
vi.mock("~/services/admin/admin-identity.server", () => ({
runAsAdminIdentity: vi.fn(async (_request, _permission, operation) => operation(adminSession)),
}));
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({ csrf: "csrf" }) }));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn() }));
vi.mock("~/utils/db.server", () => ({
db: { $transaction: vi.fn(async (operation) => operation(transaction)) },
}));
import { recordAdminAction } from "~/services/admin/admin-action-audit.server";
import { runAsAdminIdentity } from "~/services/admin/admin-identity.server";
import { validateCSRFToken } from "~/utils/session.server";
import { action } from "./index";
function callAction(values: Record<string, string | string[]>) {
const body = new URLSearchParams();
for (const [key, value] of Object.entries(values)) {
for (const item of Array.isArray(value) ? value : [value]) body.append(key, item);
}
const request = new Request("https://admin.example.test/settings/admin-users", {
method: "POST",
body,
});
return action({
request,
params: {},
context: {},
unstable_pattern: "admin/settings/admin-users/index",
} as ActionFunctionArgs);
}
describe("admin user preparation action", () => {
beforeEach(() => {
vi.clearAllMocks();
transaction.adminRole.findMany.mockResolvedValue([
{ id: "role-sales", systemKey: "sales" },
{ id: "role-viewer", systemKey: "viewer" },
]);
transaction.adminUser.create.mockResolvedValue({ id: "admin-prepared" });
});
it("prepares an Authentik identity with additive selected roles and mandatory audit", async () => {
const response = await callAction({
intent: "prepare-admin",
email: "NEW.ADMIN@EXAMPLE.TEST",
firstName: "Ada",
lastName: "Lovelace",
reason: "Neue Kollegin im Vertrieb",
roleKey: ["sales", "viewer"],
});
expect(response.status).toBe(200);
await expect(response.json()).resolves.toEqual({ ok: true, adminUserId: "admin-prepared" });
expect(validateCSRFToken).toHaveBeenCalledOnce();
expect(runAsAdminIdentity).toHaveBeenCalledWith(
expect.any(Request),
"admin_identity.users.manage",
expect.any(Function)
);
expect(transaction.adminUser.create).toHaveBeenCalledWith({
data: {
email: "new.admin@example.test",
firstName: "Ada",
lastName: "Lovelace",
roles: {
create: [
{ adminRoleId: "role-sales", grantedByAdminUserId: "admin-1" },
{ adminRoleId: "role-viewer", grantedByAdminUserId: "admin-1" },
],
},
},
select: { id: true },
});
expect(recordAdminAction).toHaveBeenCalledWith(
expect.objectContaining({
action: "security.adminUserPrepared",
actorUserId: "admin-1",
targetId: "admin-prepared",
reason: "Neue Kollegin im Vertrieb",
after: { email: "new.admin@example.test", roleKeys: ["sales", "viewer"] },
}),
transaction
);
});
it("rejects invalid identity input before opening the permission-gated mutation", async () => {
const response = await callAction({
intent: "prepare-admin",
email: "invalid",
firstName: "",
reason: "Neue Kollegin im Vertrieb",
roleKey: "viewer",
});
expect(response.status).toBe(400);
expect(runAsAdminIdentity).not.toHaveBeenCalled();
expect(transaction.adminUser.create).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,169 @@
import { useEffect } from "react";
import type { ActionFunctionArgs, LoaderFunctionArgs, MetaFunction } from "react-router";
import { useFetcher, useLoaderData, useNavigate } from "react-router";
import type { AuditEventWriterClient } from "@hivegrid/db/audit-events.server";
import type { AdminRoleKey } from "@hivegrid/db/admin-permissions";
import { ADMIN_ROLE_KEYS } from "@hivegrid/db/admin-permissions";
import { runWithRlsTransaction } from "@hivegrid/db/rls-context.server";
import { buildAdminUserListVM } from "@hivegrid/view-models";
import { AdminUsersPage } from "~/components/screens/admin/sales/security/AdminUsersPage";
import { getTranslations } from "~/locale/i18next.server";
import { assertAdminActionReason, recordAdminAction } from "~/services/admin/admin-action-audit.server";
import { runAsAdminIdentity } from "~/services/admin/admin-identity.server";
import { useRootData } from "~/utils/data/useRootData";
import { db } from "~/utils/db.server";
import { validateCSRFToken } from "~/utils/session.server";
type ActionData = { ok: true; adminUserId: string } | { ok: false; errorKey: string };
const roleKeySet = new Set<string>(ADMIN_ROLE_KEYS);
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export async function loader({ request }: LoaderFunctionArgs) {
const { t } = await getTranslations(request);
const vm = await runAsAdminIdentity(request, "admin_identity.users.read", async () => {
const [users, availableRoles] = await Promise.all([
db.adminUser.findMany({
select: {
id: true,
email: true,
firstName: true,
lastName: true,
status: true,
authentikSubject: true,
lastSsoLoginAt: true,
roles: { select: { role: { select: { id: true, name: true, systemKey: true } } } },
sessions: {
where: { revokedAt: null },
select: { lastSeenAt: true },
orderBy: { lastSeenAt: "desc" },
take: 1,
},
},
}),
db.adminRole.findMany({
where: { active: true, systemKey: { not: null } },
select: { id: true, name: true, systemKey: true },
}),
]);
return buildAdminUserListVM(users, availableRoles);
});
return { title: `${t("admin.sales.adminUsers.title")} | ${process.env.APP_NAME}`, vm };
}
export async function action({ request }: ActionFunctionArgs) {
await validateCSRFToken(request);
const form = await request.formData();
if (form.get("intent") !== "prepare-admin") {
return Response.json({ ok: false, errorKey: "admin.sales.adminUsers.errors.invalid" } satisfies ActionData, { status: 400 });
}
const email = String(form.get("email") ?? "")
.trim()
.toLowerCase();
const firstName = String(form.get("firstName") ?? "").trim();
const lastName = String(form.get("lastName") ?? "").trim();
const rawRoleKeys = form.getAll("roleKey").map(String);
const roleKeys = [...new Set(rawRoleKeys)] as AdminRoleKey[];
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 });
}
if (
!email.includes("@") ||
firstName.length === 0 ||
email.length > 320 ||
firstName.length > 200 ||
lastName.length > 200 ||
roleKeys.length === 0 ||
rawRoleKeys.some((key) => !roleKeySet.has(key))
) {
return Response.json({ ok: false, errorKey: "admin.sales.adminUsers.errors.invalid" } satisfies ActionData, { status: 400 });
}
try {
const adminUserId = await runAsAdminIdentity(request, "admin_identity.users.manage", async (session) =>
db.$transaction((transaction) =>
runWithRlsTransaction(transaction, async () => {
const roles = await transaction.adminRole.findMany({
where: { systemKey: { in: roleKeys }, active: true },
select: { id: true, systemKey: true },
});
if (roles.length !== roleKeys.length) throw new Error("Admin role catalog is not synchronized");
const prepared = await transaction.adminUser.create({
data: {
email,
firstName,
lastName,
roles: {
create: roles.map((role) => ({
adminRoleId: role.id,
grantedByAdminUserId: session.adminUserId,
})),
},
},
select: { id: true },
});
await recordAdminAction(
{
action: "security.adminUserPrepared",
actorUserId: session.adminUserId,
actorEmail: session.adminUser.email,
targetKind: "admin-user",
targetId: prepared.id,
reason,
request,
after: { email, roleKeys },
},
transaction as unknown as AuditEventWriterClient
);
return prepared.id;
})
)
);
return Response.json({ ok: true, adminUserId } satisfies ActionData);
} catch (error) {
if (error instanceof Response) throw error;
const duplicate = error instanceof Error && "code" in error && error.code === "P2002";
return Response.json(
{ ok: false, errorKey: duplicate ? "admin.sales.adminUsers.errors.duplicate" : "admin.sales.adminUsers.errors.createFailed" } satisfies ActionData,
{ status: duplicate ? 409 : 500 }
);
}
}
export default function AdminUsersRoute() {
const { vm } = useLoaderData<typeof loader>();
const fetcher = useFetcher<ActionData>();
const navigate = useNavigate();
const root = useRootData();
useEffect(() => {
if (fetcher.data?.ok) {
navigate(`${fetcher.data.adminUserId}?toast=${encodeURIComponent("admin.sales.adminUsers.toast.created")}`);
}
}, [fetcher.data, navigate]);
return (
<AdminUsersPage
vm={vm}
busy={fetcher.state !== "idle"}
errorKey={fetcher.data && !fetcher.data.ok ? fetcher.data.errorKey : undefined}
actions={{
onOpenUser: (userId) => navigate(userId),
onCreateUser: ({ email, firstName, lastName, roleKeys, reason }) => {
const form = new FormData();
form.set("intent", "prepare-admin");
form.set("email", email);
form.set("firstName", firstName);
form.set("lastName", lastName);
form.set("reason", reason);
for (const roleKey of roleKeys) form.append("roleKey", roleKey);
if (root.csrf) form.set("csrf", root.csrf);
fetcher.submit(form, { method: "post" });
},
}}
/>
);
}