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,68 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
requireAuth: vi.fn(),
getTranslations: vi.fn(),
getTenantIdFromUrl: vi.fn(),
getUserInfo: vi.fn(),
getUserPermission: vi.fn(),
getAllGroups: vi.fn(),
getMyGroups: vi.fn(),
getTenantUsers: vi.fn(),
}));
vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: mocks.requireAuth }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: mocks.getTranslations }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: mocks.getTenantIdFromUrl }));
vi.mock("~/utils/session.server", () => ({ getUserInfo: mocks.getUserInfo }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ getUserPermission: mocks.getUserPermission }));
vi.mock("~/utils/db/permissions/groups.db.server", () => ({
getAllGroups: mocks.getAllGroups,
getMyGroups: mocks.getMyGroups,
}));
vi.mock("~/utils/db/tenants.db.server", () => ({ getTenantUsers: mocks.getTenantUsers }));
import { loader } from "./groups";
const request = new Request("https://app.example.test/acme/settings/team/groups");
describe("settings groups loader authorization", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireAuth.mockResolvedValue({ userId: "user-1" });
mocks.getTranslations.mockResolvedValue({ t: (key: string) => key });
mocks.getTenantIdFromUrl.mockResolvedValue("tenant-1");
mocks.getUserInfo.mockResolvedValue({ userId: "user-1" });
mocks.getAllGroups.mockResolvedValue([{ id: "group-all" }]);
mocks.getMyGroups.mockResolvedValue([{ id: "group-own" }]);
mocks.getTenantUsers.mockResolvedValue([
{ userId: "user-2", user: { firstName: "Ada", lastName: "Lovelace", email: "ada@example.test" } },
]);
});
it("returns all groups and the minimal member directory to group managers", async () => {
mocks.getUserPermission.mockResolvedValue({ permission: { id: "permission-1" }, userPermission: "app.settings.groups.full" });
const data = await loader({ request, params: { tenant: "acme" } } as never);
expect(mocks.getAllGroups).toHaveBeenCalledWith("tenant-1");
expect(mocks.getMyGroups).not.toHaveBeenCalled();
expect(mocks.getTenantUsers).toHaveBeenCalledWith("tenant-1");
expect(data.tenantUsers).toEqual([{ userId: "user-2", firstName: "Ada", lastName: "Lovelace", email: "ada@example.test" }]);
});
it.each([
{ permission: { id: "permission-1" }, userPermission: undefined },
{ permission: null, userPermission: undefined },
])("fails closed and withholds the tenant member directory without the management grant", async (permissionResult) => {
mocks.getUserPermission.mockResolvedValue(permissionResult);
const data = await loader({ request, params: { tenant: "acme" } } as never);
expect(mocks.getMyGroups).toHaveBeenCalledWith("user-1", "tenant-1");
expect(mocks.getAllGroups).not.toHaveBeenCalled();
expect(mocks.getTenantUsers).not.toHaveBeenCalled();
expect(data.tenantUsers).toEqual([]);
});
});
@@ -0,0 +1,185 @@
import { useEffect, useRef, useState } from "react";
import { LoaderFunctionArgs, MetaFunction, useFetcher, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { useParams } from "react-router";
import { toast } from "sonner";
import { FeatherPlus } from "@subframe/core";
import { buildGroupsDetailVM } from "@hivegrid/view-models";
import { getTranslations } from "~/locale/i18next.server";
import { getUserPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getAllGroups, getMyGroups, GroupWithDetails } from "~/utils/db/permissions/groups.db.server";
import { getTenantUsers } from "~/utils/db/tenants.db.server";
import { getUserInfo } from "~/utils/session.server";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { PageIntro } from "~/components/screens/shared/PageShell";
import { Button } from "~/ui/components/Button";
import GroupsListView from "~/modules/users/components/GroupsListView";
import { GroupMembersDialog, type GroupMembersActions } from "~/components/screens/users/GroupMembersDialog";
import { GroupNewDialog, type GroupNewInput } from "~/components/screens/users/GroupNewDialog";
import UrlUtils from "~/utils/app/UrlUtils";
import { useRootData } from "~/utils/data/useRootData";
import { useAppData } from "~/utils/data/useAppData";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { requireAuth } from "~/utils/loaders.middleware";
// R-P2b — groups bulk add/remove (interim UI per AD-28, David parked groups
// for RBAC V2): the list gains a "manage members" row action opening the bulk
// dialog, which posts bulk-add/bulk-remove to the existing groups/$id action.
type TenantUserRow = { userId: string; firstName: string | null; lastName: string | null; email: string };
type LoaderData = {
title: string;
items: GroupWithDetails[];
tenantUsers: TenantUserRow[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const userInfo = await getUserInfo(request);
const { userPermission } = await getUserPermission({
userId: userInfo.userId,
permissionName: "app.settings.groups.full",
tenantId: tenantId,
});
const canManageGroups = Boolean(userPermission);
const items: GroupWithDetails[] = canManageGroups ? await getAllGroups(tenantId) : await getMyGroups(userInfo.userId, tenantId);
// Only group managers may enumerate tenant members and their email addresses.
// Non-managers can still see their own groups without receiving the bulk-add
// candidate directory in the loader response.
const tenantUsers = canManageGroups
? (await getTenantUsers(tenantId)).map((member) => ({
userId: member.userId,
firstName: member.user.firstName,
lastName: member.user.lastName,
email: member.user.email,
}))
: [];
const data: LoaderData = {
title: `${t("models.group.plural")} | ${process.env.APP_NAME}`,
items,
tenantUsers,
};
return data;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
type MutationResponse = { error?: string; success?: string };
export default function GroupsRoute() {
const data = useLoaderData<LoaderData>();
const rootData = useRootData();
const appData = useAppData();
const params = useParams();
const { t } = useTranslation();
const fetcher = useFetcher<MutationResponse>();
const [openGroupId, setOpenGroupId] = useState<string | null>(null);
const [createOpen, setCreateOpen] = useState(false);
const hadSubmission = useRef(false);
const canManage = getUserHasPermission(appData, "app.settings.groups.full");
const submitting = fetcher.state !== "idle";
useEffect(() => {
if (fetcher.state !== "idle") {
hadSubmission.current = true;
return;
}
if (hadSubmission.current) {
hadSubmission.current = false;
if (fetcher.data?.error) toast.error(fetcher.data.error);
else if (fetcher.data?.success) toast.success(fetcher.data.success);
}
}, [fetcher.state, fetcher.data]);
const openGroup = openGroupId ? (data.items.find((group) => group.id === openGroupId) ?? null) : null;
const groupVM = openGroup
? buildGroupsDetailVM({
group: { id: openGroup.id, name: openGroup.name, description: openGroup.description },
memberUsers: openGroup.users.map((entry) => ({
userId: entry.user.id,
firstName: entry.user.firstName,
lastName: entry.user.lastName,
email: entry.user.email,
})),
tenantUsers: data.tenantUsers,
canManage,
})
: null;
function postBulk(intent: "bulk-add" | "bulk-remove", userIds: string[]) {
if (!openGroupId) return;
const formData = new FormData();
if (rootData.csrf) formData.set("csrf", rootData.csrf);
formData.set("action", intent);
for (const userId of userIds) {
formData.append("user-ids", userId);
}
fetcher.submit(formData, { method: "post", action: UrlUtils.currentTenantUrl(params, `settings/team/groups/${openGroupId}`) });
}
const bulkActions: GroupMembersActions = {
onAdd: (userIds) => postBulk("bulk-add", userIds),
onRemove: (userIds) => postBulk("bulk-remove", userIds),
};
// Posts the unchanged create contract of settings/team/groups/new; that route
// keeps the action, it just no longer renders a slide-over of its own.
function createGroup(input: GroupNewInput) {
const formData = new FormData();
if (rootData.csrf) formData.set("csrf", rootData.csrf);
formData.set("action", "create");
formData.set("name", input.name);
formData.set("description", input.description);
formData.set("color", String(input.color));
for (const userId of input.userIds) {
formData.append("users[]", userId);
}
fetcher.submit(formData, { method: "post", action: UrlUtils.currentTenantUrl(params, "settings/team/groups/new") });
setCreateOpen(false);
}
return (
<EditPageLayout>
{/* AK-SET-01: the Team-Hub owns the page header; intro and create CTA share
a row inside the tab, exactly as the Mitarbeiter and Rollen tabs do.
This screen used to render a second PageHeader ("Gruppen") below the
hub's own, which read as two page titles stacked. */}
<div className="mobile:flex-col mobile:items-start flex w-full items-start justify-between gap-4">
<PageIntro uiId="ui.settings.groups.intro">{t("settings.members.groups.subtitle")}</PageIntro>
{canManage ? (
<Button icon={<FeatherPlus />} onClick={() => setCreateOpen(true)} data-ui-id="ui.settings.groups.new">
{t("settings.members.groups.createCta")}
</Button>
) : null}
</div>
<GroupsListView
items={data.items}
canManage={canManage}
onManageMembers={canManage ? setOpenGroupId : undefined}
onCreate={canManage ? () => setCreateOpen(true) : undefined}
/>
{groupVM ? <GroupMembersDialog vm={groupVM} actions={bulkActions} submitting={submitting} onClose={() => setOpenGroupId(null)} /> : null}
{canManage ? (
<GroupNewDialog
open={createOpen}
onOpenChange={setCreateOpen}
candidates={data.tenantUsers.map((member) => ({
userId: member.userId,
name: [member.firstName, member.lastName].filter(Boolean).join(" "),
email: member.email,
}))}
submitting={submitting}
onCreate={createGroup}
/>
) : null}
</EditPageLayout>
);
}
@@ -0,0 +1,174 @@
import { randomUUID } from "node:crypto";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { useNavigate, useParams } from "react-router";
import GroupForm from "~/components/core/roles/GroupForm";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppData } from "~/utils/data/useAppData";
import { createLog } from "~/utils/db/logs.db.server";
import { getGroup, GroupWithDetails, updateGroup } from "~/utils/db/permissions/groups.db.server";
import {
addGroupUsersAndSync,
deletePermissionGroupAndSync,
removeGroupUsersAndSync,
replaceGroupUsers,
} from "~/utils/db/permissions/userGroups.db.server";
import { getTenantUsers, TenantUserWithUser } from "~/utils/db/tenants.db.server";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { getUserPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
import { useSaveToast } from "~/hooks/use-save-toast";
type LoaderData = {
title: string;
item: GroupWithDetails;
tenantUsers: TenantUserWithUser[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const userInfo = await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const item = await getGroup(params.id ?? "", tenantId);
if (!item) {
throw redirect(UrlUtils.currentTenantUrl(params, "settings/team"));
}
const { userPermission: canManageGroups } = await getUserPermission({
userId: userInfo.userId,
tenantId,
permissionName: "app.settings.groups.full",
});
if (!canManageGroups && item.createdByUserId !== userInfo.userId) {
throw Response.json({ error: t("models.group.errors.manageForbidden") }, { status: 403 });
}
const data: LoaderData = {
title: `${item.name} | ${t("models.group.object")} | ${process.env.APP_NAME}`,
item,
tenantUsers: await getTenantUsers(tenantId),
};
return data;
};
type ActionData = {
error?: string;
ok?: boolean;
messageKey?: string;
messageValues?: { count: number };
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const userInfo = await requireAuth({ request, params });
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const existing = await getGroup(params.id ?? "", tenantId);
if (!existing) {
throw redirect(UrlUtils.currentTenantUrl(params, "settings/team"));
}
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const { userPermission: canManageGroups } = await getUserPermission({
userId: userInfo.userId,
tenantId,
permissionName: "app.settings.groups.full",
});
if (!canManageGroups && existing.createdByUserId !== userInfo.userId) {
throw Response.json({ error: t("models.group.errors.manageForbidden") }, { status: 403 });
}
if (action === "edit") {
const data = {
tenantId: tenantId,
name: form.get("name")?.toString() ?? "",
description: form.get("description")?.toString() ?? "",
color: Number(form.get("color")),
};
const updated = await updateGroup(existing.id, data, tenantId);
if ("count" in updated && updated.count !== 1) {
return badRequest({ error: t("shared.notFound") });
}
const userIds = form.getAll("users[]").map((f) => f.toString());
const selectedUserIds = new Set(userIds);
const tenantUsers = await getTenantUsers(tenantId);
const users = tenantUsers.filter((tenantUser) => selectedUserIds.has(tenantUser.userId)).map((tenantUser) => tenantUser.user);
if (users.length !== userIds.length) {
return badRequest({ error: t("shared.invalidForm") });
}
await replaceGroupUsers(
existing.id,
tenantId,
users.map((user) => user.id),
{ actorUserId: userInfo.userId, requestId: `settings-group:${existing.id}:replace:${randomUUID()}` }
);
await createLog(request, tenantId, "settings.groups.updated", `${existing.name}: ${JSON.stringify({ ...data, users: users.map((f) => f.email) })}`);
} else if (action === "bulk-add" || action === "bulk-remove") {
// R-P2b — bulk member ops for the interim group members dialog (AD-28).
// Only tenant members are accepted; the ops themselves are idempotent.
const userIds = form.getAll("user-ids").map((value) => value.toString());
const tenantUserIds = new Set((await getTenantUsers(tenantId)).map((tenantUser) => tenantUser.userId));
if (userIds.length === 0 || !userIds.every((userId) => tenantUserIds.has(userId))) {
return badRequest({ error: t("shared.invalidForm") });
}
if (action === "bulk-add") {
await addGroupUsersAndSync(existing.id, tenantId, userIds, {
actorUserId: userInfo.userId,
requestId: `settings-group:${existing.id}:add:${randomUUID()}`,
});
await createLog(request, tenantId, "settings.groups.membersAdded", `${existing.name}: +${userIds.length}`);
return Response.json({ ok: true, messageKey: "settings.members.toast.groupMembersAdded", messageValues: { count: userIds.length } });
}
await removeGroupUsersAndSync(existing.id, tenantId, userIds, {
actorUserId: userInfo.userId,
requestId: `settings-group:${existing.id}:remove:${randomUUID()}`,
});
await createLog(request, tenantId, "settings.groups.membersRemoved", `${existing.name}: -${userIds.length}`);
return Response.json({ ok: true, messageKey: "settings.members.toast.groupMembersRemoved", messageValues: { count: userIds.length } });
} else if (action === "delete") {
const deleted = await deletePermissionGroupAndSync(existing.id, tenantId, {
actorUserId: userInfo.userId,
requestId: `settings-group:${existing.id}:delete:${randomUUID()}`,
});
if ("count" in deleted && deleted.count !== 1) {
return badRequest({ error: t("shared.notFound") });
}
await createLog(request, tenantId, "settings.groups.deleted", `${existing.name}`);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
const messageKey = action === "delete" ? "settings.members.toast.groupDeleted" : "settings.members.toast.groupSaved";
return redirect(`${UrlUtils.currentTenantUrl(params, "settings/team")}?toast=${encodeURIComponent(messageKey)}`);
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function AdminEditGroupRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const appData = useAppData();
const navigate = useNavigate();
const params = useParams();
const { t } = useTranslation();
useSaveToast(actionData);
return (
<SlideOverWideEmpty
title={t("settings.members.groups.editTitle")}
open={true}
className="sm:max-w-sm"
onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/team"))}
>
<GroupForm
allUsers={data.tenantUsers}
item={data.item}
canUpdate={getUserHasPermission(appData, "app.settings.groups.full") || data.item.createdByUserId === appData.user.id}
canDelete={getUserHasPermission(appData, "app.settings.groups.full") || data.item.createdByUserId === appData.user.id}
/>
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,84 @@
import { ActionFunction, LoaderFunctionArgs, Navigate, redirect, useParams } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { createLog } from "~/utils/db/logs.db.server";
import { createPermissionGroupWithUsers } from "~/utils/db/permissions/userGroups.db.server";
import { getTenantUsers, TenantUserWithUser } from "~/utils/db/tenants.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
tenantUsers: TenantUserWithUser[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.groups.full", tenantId);
const data: LoaderData = {
tenantUsers: await getTenantUsers(tenantId),
};
return data;
};
type ActionData = {
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.groups.full", tenantId);
await validateCSRFToken(request);
const userInfo = await getUserInfo(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "create") {
const data = {
createdByUserId: userInfo.userId,
tenantId: tenantId,
name: form.get("name")?.toString() ?? "",
description: form.get("description")?.toString() ?? "",
color: Number(form.get("color")),
};
const userIds = form.getAll("users[]").map((f) => f.toString());
const tenantUsers = await getTenantUsers(tenantId);
const users = tenantUsers.filter((tenantUser) => userIds.includes(tenantUser.userId)).map((tenantUser) => tenantUser.user);
if (users.length !== userIds.length) {
return badRequest({ error: t("shared.invalidForm") });
}
await createPermissionGroupWithUsers(
tenantId,
{
createdByUserId: data.createdByUserId,
name: data.name,
description: data.description,
color: data.color,
},
users.map((user) => user.id)
);
await createLog(
request,
tenantId,
"settings.groups.created",
`${JSON.stringify({
...data,
users: users.map((f) => f.email),
})}`
);
// Back to the tab the dialog was opened from, so the new group is visible.
return redirect(`${UrlUtils.currentTenantUrl(params, "settings/team/groups")}?toast=${encodeURIComponent("settings.members.toast.groupCreated")}`);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
// Action-only route: the create form is the GroupNewDialog on the Gruppen tab
// (see settings/team/groups.tsx), which posts this action. Opening the URL
// directly lands on the tab that owns the dialog.
export default function NewGroupRoute() {
const params = useParams();
return <Navigate to={UrlUtils.currentTenantUrl(params, "settings/team/groups")} replace />;
}
@@ -0,0 +1,319 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
useActionData: () => undefined,
useLoaderData: () => ({}),
useNavigate: () => vi.fn(),
useNavigation: () => ({ state: "idle" }),
useOutlet: () => null,
useParams: () => ({}),
useSubmit: () => vi.fn(),
};
});
vi.mock("sonner", () => ({ toast: { success: vi.fn(), error: vi.fn() } }));
vi.mock("~/components/screens/users/MembersPage", () => ({ MembersPage: () => null }));
vi.mock("~/ui/components/Dialog", () => ({ Dialog: Object.assign(() => null, { Content: () => null }) }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/utils/app/UrlUtils", () => ({ default: { currentTenantUrl: vi.fn(() => "/acme/settings/team") } }));
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({}) }));
vi.mock("~/utils/db/logs.db.server", () => ({ createAdminLog: vi.fn() }));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({ getTenantAssignableAppRole: vi.fn(), getTenantAssignableAppRoles: vi.fn() }));
vi.mock("~/utils/db/permissions/userRoles.db.server", () => ({ createUserRole: vi.fn(), deleteUserRole: vi.fn() }));
vi.mock("~/utils/db/tenantUserInvitations.db.server", () => ({ deleteUserInvitation: vi.fn(), getUserInvitation: vi.fn(), getUserInvitations: vi.fn() }));
vi.mock("~/utils/db/tenants.db.server", () => ({ getTenant: vi.fn(), getTenantMember: vi.fn(), getTenantUsers: vi.fn() }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ getUserPermission: vi.fn(), verifyUserHasPermission: vi.fn() }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => key })) }));
vi.mock("~/modules/events/services/.server/EventsService", () => ({ default: { create: vi.fn() } }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn() }));
vi.mock("~/utils/services/tenantUserLifecycle.server", () => ({ deactivateTenantUser: vi.fn(), reactivateTenantUser: vi.fn() }));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn(), getEnabledTotpUserIds: vi.fn() }));
// The loader reads the plan seat limit for the invite dialog; keep it off the DB.
vi.mock("~/utils/services/.server/subscriptionService", () => ({ getPlanFeatureUsage: vi.fn(async () => undefined) }));
vi.mock("~/utils/session.server", () => ({
createImpersonationStartedAt: vi.fn(() => "2026-05-08T17:00:00.000Z"),
createUserSession: vi.fn(),
getUserInfo: vi.fn(),
setLoggedUser: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("@hivegrid/config", () => ({
loadRequiredWebConfig: () => ({
routing: {
protocol: "https",
webAppHost: "app.example.test",
adminAppHost: "admin.example.test",
apiHost: "api.example.test",
appBaseDomain: "example.test",
},
}),
}));
import { getTenantAssignableAppRole, getTenantAssignableAppRoles } from "~/utils/db/permissions/roles.db.server";
import { createUserRole } from "~/utils/db/permissions/userRoles.db.server";
import { deleteUserInvitation, getUserInvitation, getUserInvitations } from "~/utils/db/tenantUserInvitations.db.server";
import { getTenant, getTenantMember, getTenantUsers } from "~/utils/db/tenants.db.server";
import { getEnabledTotpUserIds, getUser } from "~/utils/db/users.db.server";
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { deactivateTenantUser, reactivateTenantUser } from "~/utils/services/tenantUserLifecycle.server";
import { createUserSession, getUserInfo, setLoggedUser, validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./index";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
const actor = { id: "admin-1", admin: true, email: "admin@example.test" };
const targetUser = { id: "user-1", admin: false, email: "user@example.test" };
const actorInfo = {
userId: actor.id,
lightOrDarkMode: "light",
lng: "en",
cookies: [],
};
function postRequest(form: Record<string, string> = { action: "impersonate", "user-id": targetUser.id }) {
return new Request("https://app.example.test/acme/settings/team?tab=active", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form),
});
}
async function callAction(form?: Record<string, string>) {
try {
const response = await action({
request: postRequest(form),
params: { tenant: "acme" },
context: {},
unstable_pattern: "app/$tenant/settings/team",
} as ActionFunctionArgs);
return { thrown: false, response: response as Response };
} catch (error) {
return { thrown: true, response: error as Response, error };
}
}
async function callLoader() {
return loader({
request: new Request("https://app.example.test/acme/settings/team"),
params: { tenant: "acme" },
context: {},
} as LoaderFunctionArgs);
}
describe("workspace member lifecycle actions", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1" as never);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue(actorInfo as never);
vi.mocked(getUser).mockImplementation(async (id?: string) => (id === actor.id ? actor : id === targetUser.id ? targetUser : null) as never);
vi.mocked(setLoggedUser).mockResolvedValue({ userId: targetUser.id, defaultTenantId: "tenant-1" } as never);
vi.mocked(getTenant).mockResolvedValue({ id: "tenant-1", slug: "acme" } as never);
vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never);
vi.mocked(createUserSession).mockResolvedValue(new Response(null, { status: 302, headers: { Location: "/acme/dashboard" } }) as never);
});
it("uses only tenant permissions for tenant-member impersonation", async () => {
const result = await callAction();
expect(result.thrown).toBe(false);
expect(result.response.status).toBe(302);
expect(validateCSRFToken).toHaveBeenCalledWith(expect.any(Request));
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.impersonate", "tenant-1");
expect(setLoggedUser).toHaveBeenCalledWith(targetUser);
expect(createUserSession).toHaveBeenCalledWith(
expect.objectContaining({
userId: targetUser.id,
impersonatingFromUserId: actor.id,
impersonatingStartedAt: "2026-05-08T17:00:00.000Z",
}),
"/acme/dashboard",
{ request: expect.any(Request) },
);
expect(result.response.headers.get("Location")).toBe("/acme/dashboard");
});
it("requires role-set permission before assigning workspace roles", async () => {
vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never);
vi.mocked(getTenantAssignableAppRole).mockResolvedValue({ id: "role-1", name: "User", description: "User", type: "app" } as never);
vi.mocked(createUserRole).mockResolvedValue({ id: "user-role-1" } as never);
const result = await callAction({ action: "edit", "user-id": targetUser.id, "role-id": "role-1", add: "true" });
expect(result.thrown).toBe(false);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.update", "tenant-1");
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.roles.set", "tenant-1");
expect(getTenantAssignableAppRole).toHaveBeenCalledWith("role-1", "tenant-1");
expect(createUserRole).toHaveBeenCalledWith(targetUser.id, "role-1", "tenant-1");
});
it("requires delete permission before revoking pending invitations", async () => {
vi.mocked(getUserInvitation).mockResolvedValue({ id: "invitation-1" } as never);
vi.mocked(deleteUserInvitation).mockResolvedValue({ count: 1 } as never);
const result = await callAction({ action: "delete-invitation", "invitation-id": "invitation-1" });
expect(result.thrown).toBe(false);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.update", "tenant-1");
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.delete", "tenant-1");
expect(deleteUserInvitation).toHaveBeenCalledWith("invitation-1", "tenant-1");
await expect(result.response.json()).resolves.toEqual({ success: "settings.members.success.invitationDeleted" });
});
it("localizes the last-super-admin removal guard response with the V01 code", async () => {
vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never);
vi.mocked(getTenantAssignableAppRole).mockResolvedValue({ id: "role-super", name: "SuperUser", description: "Super User", type: "app" } as never);
vi.mocked(getTenantUsers).mockResolvedValue([
{
status: TenantUserStatus.ACTIVE,
user: { id: targetUser.id, roles: [{ tenantId: "tenant-1", role: { name: "SuperUser" } }] },
},
] as never);
const result = await callAction({ action: "edit", "user-id": targetUser.id, "role-id": "role-super", add: "false" });
expect(result.thrown).toBe(false);
expect(result.response.status).toBe(400);
await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.atLeastOneSuperAdmin", code: "last-admin" });
});
it("localizes the own super-admin role removal guard response", async () => {
vi.mocked(getTenantMember).mockResolvedValue({ user: actor } as never);
vi.mocked(getTenantAssignableAppRole).mockResolvedValue({ id: "role-super", name: "SuperUser", description: "Super User", type: "app" } as never);
vi.mocked(getTenantUsers).mockResolvedValue([
{
status: TenantUserStatus.ACTIVE,
user: { id: actor.id, roles: [{ tenantId: "tenant-1", role: { name: "SuperUser" } }] },
},
{
status: TenantUserStatus.ACTIVE,
user: { id: targetUser.id, roles: [{ tenantId: "tenant-1", role: { name: "SuperUser" } }] },
},
] as never);
const result = await callAction({ action: "edit", "user-id": actor.id, "role-id": "role-super", add: "false" });
expect(result.thrown).toBe(false);
expect(result.response.status).toBe(400);
await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.cannotRemoveOwnSuperAdminRole" });
});
});
describe("workspace member lifecycle intents (R-P2b M03/V01)", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1" as never);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue(actorInfo as never);
vi.mocked(getUser).mockResolvedValue(actor as never);
vi.mocked(getTenant).mockResolvedValue({ id: "tenant-1", name: "Acme", slug: "acme" } as never);
vi.mocked(getTenantMember).mockResolvedValue({ user: targetUser } as never);
});
it("deactivates a member through the lifecycle service without reassign", async () => {
vi.mocked(deactivateTenantUser).mockResolvedValue({ ok: true } as never);
const result = await callAction({ action: "deactivate", "user-id": targetUser.id });
expect(result.thrown).toBe(false);
expect(deactivateTenantUser).toHaveBeenCalledWith({ tenantId: "tenant-1", targetUserId: targetUser.id });
await expect(result.response.json()).resolves.toEqual({ success: "settings.members.success.deactivated" });
});
it("maps the last-admin guard to the V01 blocker code", async () => {
vi.mocked(deactivateTenantUser).mockResolvedValue({ ok: false, reason: "last-admin" } as never);
const result = await callAction({ action: "deactivate", "user-id": targetUser.id });
expect(result.thrown).toBe(false);
expect(result.response.status).toBe(400);
await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.lastAdminBody", code: "last-admin" });
});
it("rejects other deactivation failures with a plain error", async () => {
vi.mocked(deactivateTenantUser).mockResolvedValue({ ok: false, reason: "already-inactive" } as never);
const result = await callAction({ action: "deactivate", "user-id": targetUser.id });
expect(result.response.status).toBe(400);
await expect(result.response.json()).resolves.toEqual({ error: "shared.invalidForm" });
});
it("reactivates a member through the lifecycle service", async () => {
vi.mocked(reactivateTenantUser).mockResolvedValue({ ok: true } as never);
const result = await callAction({ action: "reactivate", "user-id": targetUser.id });
expect(result.thrown).toBe(false);
expect(reactivateTenantUser).toHaveBeenCalledWith({ tenantId: "tenant-1", targetUserId: targetUser.id });
await expect(result.response.json()).resolves.toEqual({ success: "settings.members.success.reactivated" });
});
});
describe("workspace members loader (MembersListVM)", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1" as never);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue(actorInfo as never);
vi.mocked(getUserPermission).mockResolvedValue({ permission: null, userPermission: null } as never);
vi.mocked(getEnabledTotpUserIds).mockResolvedValue(["user-1"] as never);
vi.mocked(getUserInvitations).mockResolvedValue([{ id: "invite-1", email: "new@example.test", firstName: "New", lastName: "Person" }] as never);
// The helper already scopes to assignable defaults + the tenant's own roles.
vi.mocked(getTenantAssignableAppRoles).mockResolvedValue([
{ id: "role-1", name: "SuperUser", description: "", tenantId: null },
{ id: "role-shk", name: "Monteur", description: "", tenantId: "tenant-1" },
] as never);
vi.mocked(getTenantUsers).mockResolvedValue([
{
id: "member-1",
userId: "user-1",
status: TenantUserStatus.ACTIVE,
user: {
id: "user-1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
phone: "+49 1",
roles: [{ tenantId: "tenant-1", role: { id: "role-1", name: "SuperUser", description: "", seatCategory: "office" } }],
},
},
{
id: "member-2",
userId: "user-2",
status: TenantUserStatus.INACTIVE,
user: { id: "user-2", firstName: "Grace", lastName: "Hopper", email: "grace@example.test", phone: null, roles: [] },
},
] as never);
});
it("builds the VM including deactivated members and the tenant's assignable roles", async () => {
const data = (await callLoader()) as { vm: { status: string; data?: any }; canViewRoles: boolean };
expect(getTenantUsers).toHaveBeenCalledWith("tenant-1", { includeInactive: true });
expect(getTenantAssignableAppRoles).toHaveBeenCalledWith("tenant-1");
expect(data.vm.status).toBe("ready");
const rows = data.vm.data.rows;
expect(rows).toHaveLength(2);
// Fundament C: an office role promotes to the office seat; no roles => field seat.
expect(rows[0]).toMatchObject({ name: "Ada Lovelace", status: "active", mfaEnabled: true, roles: [{ id: "role-1" }], seatType: "office" });
expect(rows[1]).toMatchObject({ name: "Grace Hopper", status: "inactive", mfaEnabled: false, canReactivate: true, seatType: "field" });
// Defaults AND the tenant's own custom/SHK roles feed the D01 dropdown.
expect(data.vm.data.assignableRoles).toEqual([
{ id: "role-1", name: "SuperUser", description: "" },
{ id: "role-shk", name: "Monteur", description: "" },
]);
expect(data.vm.data.pendingInvitations).toEqual([{ id: "invite-1", email: "new@example.test", name: "New Person", createdAtIso: null }]);
expect(data.canViewRoles).toBe(true);
});
});
@@ -0,0 +1,375 @@
import { useEffect, useState } from "react";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, useActionData, useLoaderData } from "react-router";
import { useFetcher, useNavigate, useNavigation, useOutlet, useParams, useSubmit } from "react-router";
import { useTranslation } from "react-i18next";
import { toast } from "sonner";
import { buildMembersListVM, type MembersListVM, type MemberStatus } from "@hivegrid/view-models";
import { deriveSeatType } from "@hivegrid/entitlements";
import { getTenant, getTenantMember, getTenantUsers } from "~/utils/db/tenants.db.server";
import { deleteUserInvitation, getUserInvitation, getUserInvitations } from "~/utils/db/tenantUserInvitations.db.server";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantAssignableAppRole, getTenantAssignableAppRoles } from "~/utils/db/permissions/roles.db.server";
import { getEnabledTotpUserIds, getUser } from "~/utils/db/users.db.server";
import { getPlanFeatureUsage } from "~/utils/services/.server/subscriptionService";
import { DefaultFeatures } from "~/application/dtos/shared/DefaultFeatures";
import type { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto";
import { createAdminLog } from "~/utils/db/logs.db.server";
import { createUserRole, deleteUserRole } from "~/utils/db/permissions/userRoles.db.server";
import { createImpersonationStartedAt, createUserSession, getUserInfo, setLoggedUser, validateCSRFToken } from "~/utils/session.server";
import { deactivateTenantUser, reactivateTenantUser } from "~/utils/services/tenantUserLifecycle.server";
import { FeatherPlus } from "@subframe/core";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { MembersPage, type MembersActions } from "~/components/screens/users/MembersPage";
import { InviteMemberDialog, type InviteMemberInput } from "~/components/screens/users/InviteMemberDialog";
import { PageIntro } from "~/components/screens/shared/PageShell";
import { Button } from "~/ui/components/Button";
import { Dialog } from "~/ui/components/Dialog";
import { DefaultAppRoles } from "~/application/dtos/shared/DefaultAppRoles";
import { useRootData } from "~/utils/data/useRootData";
import EventsService from "~/modules/events/services/.server/EventsService";
import { RoleAssignedDto } from "~/modules/events/dtos/RoleAssignedDto";
import { RoleUnassignedDto } from "~/modules/events/dtos/RoleUnassignedDto";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
type LoaderData = {
title: string;
vm: MembersListVM;
canViewRoles: boolean;
/** Seat limit of the plan — gates the invite dialog, as the sub-page did before. */
featurePlanUsage: PlanFeatureUsageDto | undefined;
};
function toMemberStatus(status: TenantUserStatus): MemberStatus {
if (status === TenantUserStatus.ACTIVE) return "active";
if (status === TenantUserStatus.INACTIVE) return "inactive";
return "invited";
}
async function hasPermission(userId: string, permissionName: string, tenantId: string): Promise<boolean> {
const { permission, userPermission } = await getUserPermission({ userId, permissionName, tenantId });
return !permission || Boolean(userPermission);
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const userInfo = await getUserInfo(request);
await verifyUserHasPermission(request, "app.settings.members.view", tenantId);
// Deactivated members stay visible with status "Deaktiviert" (David's S01/M03).
const [users, pendingInvitations, roles, canInvite, canEditRoles, canManageMembers, canViewRoles] = await Promise.all([
getTenantUsers(tenantId, { includeInactive: true }),
getUserInvitations(tenantId),
// Assignable defaults + the tenant's own custom/SHK roles (D01 dropdown).
getTenantAssignableAppRoles(tenantId),
hasPermission(userInfo.userId, "app.settings.members.create", tenantId),
hasPermission(userInfo.userId, "app.settings.roles.set", tenantId),
hasPermission(userInfo.userId, "app.settings.members.update", tenantId),
hasPermission(userInfo.userId, "app.settings.roles.view", tenantId),
]);
const mfaEnabledUserIds = new Set(await getEnabledTotpUserIds(users.map((member) => member.user.id)));
const vm = buildMembersListVM({
rows: users.map((member) => ({
tenantUserId: member.id,
userId: member.userId,
firstName: member.user.firstName,
lastName: member.user.lastName,
email: member.user.email,
phone: member.user.phone,
status: toMemberStatus(member.status),
mfaEnabled: mfaEnabledUserIds.has(member.user.id),
roles: member.user.roles
.filter((userRole) => userRole.tenantId === tenantId)
.map((userRole) => ({ id: userRole.role.id, name: userRole.role.name, description: userRole.role.description })),
// Effective seat (Fundament C): derived from the roles already batch-loaded by
// getTenantUsers (no extra query, no N+1); the TenantUser.seatType override wins.
seatType: deriveSeatType({
roleSeatCategories: member.user.roles.filter((userRole) => userRole.tenantId === tenantId).map((userRole) => userRole.role.seatCategory),
override: member.seatType,
}),
})),
pendingInvitations: pendingInvitations.map((invitation) => ({
id: invitation.id,
email: invitation.email,
name: [invitation.firstName, invitation.lastName].filter(Boolean).join(" "),
createdAtIso: null,
})),
assignableRoles: roles.map((role) => ({ id: role.id, name: role.name, description: role.description })),
currentUserId: userInfo.userId,
canInvite,
canEditRoles,
canManageMembers,
});
const data: LoaderData = {
title: `${t("settings.members.title")} | ${process.env.APP_NAME}`,
vm,
canViewRoles,
featurePlanUsage: canInvite ? await getPlanFeatureUsage(tenantId, DefaultFeatures.Users) : undefined,
};
return data;
};
type ActionData = {
success?: string;
error?: string;
/** Machine-readable guard code — "last-admin" opens the V01 blocker dialog. */
code?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.members.update", tenantId);
await validateCSRFToken(request);
const userInfo = await getUserInfo(request);
const form = await request.formData();
const action = form.get("action")?.toString();
const fromUser = await getUser(userInfo.userId);
if (!fromUser) {
return badRequest({ error: t("settings.members.errors.invalidUser") });
}
if (action === "delete-invitation") {
await verifyUserHasPermission(request, "app.settings.members.delete", tenantId);
const invitationId = form.get("invitation-id")?.toString() ?? "";
const invitation = await getUserInvitation(invitationId, tenantId);
if (!invitation) {
return badRequest({
error: t("settings.members.errors.invitationNotFound"),
});
}
await deleteUserInvitation(invitation.id, tenantId);
return Response.json({ success: t("settings.members.success.invitationDeleted") });
}
if (action === "deactivate" || action === "reactivate") {
// R-P2b user lifecycle (M03/V01): soft-deactivation via the lifecycle service.
// Reassign-on-deactivate stays Backlog/V2 (David) — the service keeps the option.
const userId = form.get("user-id")?.toString() ?? "";
const tenant = await getTenant(tenantId);
const tenantMember = await getTenantMember(userId, tenantId);
if (!tenant || !tenantMember) {
return badRequest({ error: t("shared.invalidForm") });
}
if (action === "deactivate") {
const result = await deactivateTenantUser({ tenantId, targetUserId: userId });
if (!result.ok) {
if (result.reason === "last-admin") {
return badRequest({ error: t("settings.members.errors.lastAdminBody"), code: "last-admin" });
}
return badRequest({ error: t("shared.invalidForm") });
}
createAdminLog(request, "settings.members.deactivated", `[${tenant.name}] ${tenantMember.user.email}`);
return Response.json({ success: t("settings.members.success.deactivated") });
}
const result = await reactivateTenantUser({ tenantId, targetUserId: userId });
if (!result.ok) {
return badRequest({ error: t("shared.invalidForm") });
}
createAdminLog(request, "settings.members.reactivated", `[${tenant.name}] ${tenantMember.user.email}`);
return Response.json({ success: t("settings.members.success.reactivated") });
}
if (action === "edit") {
await verifyUserHasPermission(request, "app.settings.roles.set", tenantId);
const userId = form.get("user-id")?.toString() ?? "";
const roleId = form.get("role-id")?.toString() ?? "";
const add = form.get("add") === "true";
const tenant = await getTenant(tenantId);
const tenantMember = await getTenantMember(userId, tenantId);
const user = tenantMember?.user ?? null;
const role = await getTenantAssignableAppRole(roleId, tenantId);
if (!tenantMember || !user || !role || role.type !== "app" || !tenant) {
return badRequest({ error: t("shared.invalidForm") });
}
if (role?.name === DefaultAppRoles.SuperUser) {
const allMembers = await getTenantUsers(tenantId);
const activeMembers = allMembers.filter((member) => member.status === TenantUserStatus.ACTIVE);
const superAdmins = activeMembers.filter((m) => m.user.roles.some((r) => r.tenantId === tenantId && r.role.name === DefaultAppRoles.SuperUser));
if (superAdmins.length === 1 && !add) {
// Same guard family as deactivation: the workspace must keep an admin (V01).
return badRequest({
error: t("settings.members.errors.atLeastOneSuperAdmin"),
code: "last-admin",
});
}
if (userId === userInfo.userId) {
return badRequest({
error: t("settings.members.errors.cannotRemoveOwnSuperAdminRole"),
});
}
}
if (add) {
await createUserRole(userId, roleId, tenantId);
if (fromUser && user && role) {
await EventsService.create({
request,
event: "role.assigned",
tenantId,
userId: fromUser.id,
data: {
fromUser: { id: fromUser.id, email: fromUser.email },
toUser: { id: user.id, email: user.email },
role: { id: role.id, name: role.name, description: role.description },
} satisfies RoleAssignedDto,
});
}
createAdminLog(request, "settings.memberRoles.created", `[${tenant?.name}] ${user?.email} - ${role?.name}`);
} else {
await EventsService.create({
request,
event: "role.unassigned",
tenantId: tenant.id,
userId: fromUser.id,
data: {
fromUser: { id: fromUser.id, email: fromUser.email },
toUser: { id: user.id, email: user.email },
role: { id: role.id, name: role.name, description: role.description },
} satisfies RoleUnassignedDto,
});
await deleteUserRole(userId, roleId, tenantId);
createAdminLog(request, "settings.memberRoles.deleted", `[${tenant?.name}] ${user?.email} - ${role?.name}`);
}
return Response.json({});
} else if (action === "impersonate") {
await verifyUserHasPermission(request, "app.settings.members.impersonate", tenantId);
const userId = form.get("user-id")?.toString();
const tenantMember = await getTenantMember(userId, tenantId);
const user = tenantMember ? await getUser(userId) : null;
if (!tenantMember || !user) {
return badRequest({ error: t("shared.notFound") });
}
const userSession = await setLoggedUser(user);
if (!userSession) {
return badRequest({ error: t("shared.notFound") });
}
const tenant = await getTenant(tenantId);
return createUserSession(
{
...userInfo,
...userSession,
impersonatingFromUserId: userInfo.userId,
impersonatingStartedAt: createImpersonationStartedAt(),
},
tenant ? appPath({ tenantSlug: tenant.slug, path: "dashboard", mode: "host-aware" }) : "/",
{ request },
);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function MembersSettingsRoute() {
const { t } = useTranslation();
const params = useParams();
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const rootData = useRootData();
const navigate = useNavigate();
const navigation = useNavigation();
const outlet = useOutlet();
const submit = useSubmit();
// Own fetcher for the invite: the create contract lives on the members/new
// route, which is a sibling of this index route and not reachable through the
// outlet below.
const inviteFetcher = useFetcher<{ error?: string }>();
const [inviteOpen, setInviteOpen] = useState(false);
const submitting = navigation.state === "submitting";
const lastAdminBlocked = actionData?.code === "last-admin";
useEffect(() => {
if (actionData?.success) {
toast.success(actionData.success);
} else if (actionData?.error && actionData.code !== "last-admin") {
toast.error(actionData.error);
}
}, [actionData]);
function post(fields: Record<string, string>) {
const formData = new FormData();
if (rootData.csrf) formData.set("csrf", rootData.csrf);
for (const [name, value] of Object.entries(fields)) {
formData.set(name, value);
}
submit(formData, { method: "post" });
}
const actions: MembersActions = {
onToggleRole: ({ userId, roleId, add }) => post({ action: "edit", "user-id": userId, "role-id": roleId, add: String(add) }),
onDeactivate: ({ userId }) => post({ action: "deactivate", "user-id": userId }),
onReactivate: ({ userId }) => post({ action: "reactivate", "user-id": userId }),
onDeleteInvitation: ({ invitationId }) => post({ action: "delete-invitation", "invitation-id": invitationId }),
onInvite: () => setInviteOpen(true),
};
function invite(input: InviteMemberInput) {
const formData = new FormData();
if (rootData.csrf) formData.set("csrf", rootData.csrf);
formData.set("email", input.email);
formData.set("first-name", input.firstName);
formData.set("last-name", input.lastName);
if (input.sendInvitationEmail) formData.set("send-invitation-email", "on");
inviteFetcher.submit(formData, { method: "post", action: UrlUtils.currentTenantUrl(params, "settings/team/members/new") });
}
const canInvite = data.vm.status === "ready" ? (data.vm.data?.canInvite ?? false) : false;
return (
<>
<EditPageLayout fullWidth>
{/* AK-SET-01: the Team-Hub owns the page header; the invite CTA is
re-hosted here rather than dropped with it. */}
<div className="mobile:flex-col mobile:items-start flex w-full items-start justify-between gap-4">
<PageIntro uiId="ui.settings.members.intro">{t("settings.members.description")}</PageIntro>
{canInvite ? (
<Button icon={<FeatherPlus />} onClick={actions.onInvite} data-ui-id="ui.settings.members.invite">
{t("settings.members.actions.new")}
</Button>
) : null}
</div>
<MembersPage
vm={data.vm}
actions={actions}
rolesTabHref={data.canViewRoles ? UrlUtils.currentTenantUrl(params, "settings/team/roles") : null}
editRouteFor={(tenantUserId) => UrlUtils.currentTenantUrl(params, `settings/team/members/edit/${tenantUserId}`)}
submitting={submitting}
lastAdminBlocked={lastAdminBlocked}
/>
{canInvite ? (
<InviteMemberDialog
open={inviteOpen}
onOpenChange={setInviteOpen}
featurePlanUsage={data.featurePlanUsage}
submitting={inviteFetcher.state !== "idle"}
errorMessage={inviteFetcher.data?.error ?? null}
onInvite={invite}
/>
) : null}
{/* Child routes (member edit, group forms) render in a real Dialog (S 560). */}
<Dialog
open={!!outlet}
onOpenChange={(open: boolean) => {
if (!open) navigate(".", { replace: true });
}}
>
<Dialog.Content className="w-[560px] max-w-[90vw] p-6" aria-label={t("settings.members.form.newTitle")}>
<div className="w-full">{outlet}</div>
</Dialog.Content>
</Dialog>
</EditPageLayout>
</>
);
}
@@ -0,0 +1,308 @@
import { useTranslation } from "react-i18next";
import { useEffect, useRef } from "react";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
import ConfirmModal, { RefConfirmModal } from "~/components/ui/modals/ConfirmModal";
import ErrorModal, { RefErrorModal } from "~/components/ui/modals/ErrorModal";
import SuccessModal, { RefSuccessModal } from "~/components/ui/modals/SuccessModal";
import { useEscapeKeypress } from "~/utils/shared/KeypressUtils";
import type { TenantUser, User } from "@hivegrid/db/prisma-browser";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData } from "react-router";
import { Form, useActionData, useParams, useSubmit, useNavigation, useNavigate } from "react-router";
import { deleteTenantUser, getTenantUser, getTenantUsers } from "~/utils/db/tenants.db.server";
import { getTranslations } from "~/locale/i18next.server";
import clsx from "clsx";
import { useAppData } from "~/utils/data/useAppData";
import UrlUtils from "~/utils/app/UrlUtils";
import ButtonSecondary from "~/components/ui/buttons/ButtonSecondary";
import InputText from "~/components/ui/input/InputText";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { MetaTagsDto } from "~/application/dtos/seo/MetaTagsDto";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { useRootData } from "~/utils/data/useRootData";
import { DefaultAppRoles } from "~/application/dtos/shared/DefaultAppRoles";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
type LoaderData = {
metatags: MetaTagsDto;
member: (TenantUser & { user: User }) | null;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.members.update", tenantId);
const { t } = await getTranslations(request);
const member = await getTenantUser(params.id, tenantId);
const data: LoaderData = {
metatags: [{ title: `${t("settings.members.actions.edit")} | ${process.env.APP_NAME}` }],
member,
};
return data;
};
type ActionData = {
error?: string;
success?: string;
fields?: {
email: string;
firstName: string;
lastName: string;
role: number;
};
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.members.update", tenantId);
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
// const tenantId = await getTenantIdFromUrl(params);
const { id } = params;
if (!id) {
return badRequest({
error: t("shared.notFound"),
});
}
const form = await request.formData();
const action = form.get("action")?.toString();
// const email = form.get("email")?.toString().toLowerCase().trim();
// const firstName = form.get("firstName")?.toString() ?? "";
// const lastName = Number(form.get("lastName")) ?? "";
// const tenantUsers = await getTenantUsers(tenantId);
// const owners = tenantUsers?.filter((f) => f.type === TenantUserType.OWNER);
// if (owners?.length === 1 && owners?.find((f) => f.user.email === email) && type !== TenantUserType.OWNER) {
// return badRequest({
// error: t("api.errors.cannotBeWithoutOwner"),
// });
// }
if (action === "edit") {
const tenantUser = await getTenantUser(id, tenantId);
if (!tenantUser) {
return badRequest({
error: t("shared.notFound"),
});
}
return redirect(`${UrlUtils.currentTenantUrl(params, "settings/team")}?toast=${encodeURIComponent("settings.members.toast.memberSaved")}`);
} else if (action === "delete") {
await verifyUserHasPermission(request, "app.settings.members.delete", tenantId);
const tenantUser = await getTenantUser(id, tenantId);
if (!tenantUser) {
return badRequest({
error: t("shared.notFound"),
});
}
if (tenantUser.userId === userInfo.userId) {
return badRequest({
error: t("settings.members.errors.cannotRemoveSelf"),
});
}
const allMembers = await getTenantUsers(tenantId);
const targetMember = allMembers.find((member) => member.id === tenantUser.id);
const targetIsSuperUser = targetMember?.user.roles.some((role) => role.tenantId === tenantId && role.role.name === DefaultAppRoles.SuperUser) ?? false;
if (targetIsSuperUser) {
const activeMembers = allMembers.filter((member) => member.status === TenantUserStatus.ACTIVE);
const superUsers = activeMembers.filter((member) =>
member.user.roles.some((role) => role.tenantId === tenantId && role.role.name === DefaultAppRoles.SuperUser)
);
if (superUsers.length <= 1) {
return badRequest({
error: t("settings.members.errors.atLeastOneSuperAdmin"),
});
}
}
try {
const deleted = await deleteTenantUser(id, tenantId);
if ("count" in deleted && deleted.count !== 1) {
return badRequest({
error: t("shared.notFound"),
});
}
} catch (e: any) {
return badRequest({
error: e.toString(),
});
}
return redirect(`${UrlUtils.currentTenantUrl(params, "settings/team")}?toast=${encodeURIComponent("settings.members.toast.memberRemoved")}`);
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => data?.metatags ?? [];
interface Props {
maxSize?: string;
}
export default function EditMemberRoute({ maxSize: _maxSize = "sm:max-w-lg" }: Props) {
const params = useParams();
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const appData = useAppData();
const rootData = useRootData();
const { t } = useTranslation();
const navigate = useNavigate();
const submit = useSubmit();
const navigation = useNavigation();
const loading = navigation.state === "submitting";
const errorModal = useRef<RefErrorModal>(null);
const successModal = useRef<RefSuccessModal>(null);
const confirmRemove = useRef<RefConfirmModal>(null);
// const [item, setItem] = useState<TenantUserDto | null>(null);
// const [loading, setLoading] = useState(false);
// const [email, setEmail] = useState("");
// const [firstName, setFirstName] = useState("");
// const [lastName, setLastName] = useState("");
// const [phone, setPhone] = useState("");
useEffect(() => {
if (actionData?.error) {
errorModal.current?.show(actionData.error);
}
if (actionData?.success) {
successModal.current?.show(t("shared.success"), actionData.success);
}
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [actionData]);
function close() {
navigate(UrlUtils.currentTenantUrl(params, "settings/team"));
}
function remove() {
if (!data.member) {
return;
}
confirmRemove.current?.show(
t("shared.confirmRemove"),
t("shared.remove"),
t("shared.cancel"),
t("settings.members.actions.removeConfirm", { email: data.member?.user.email })
);
}
function yesRemove() {
if (appData.currentRole === TenantUserType.MEMBER) {
errorModal.current?.show(t("account.tenant.onlyAdmin"));
} else {
const form = new FormData();
form.set("action", "delete");
if (rootData.csrf) {
form.set("csrf", rootData.csrf);
}
submit(form, {
method: "post",
});
}
}
useEscapeKeypress(close);
return (
<div>
{(() => {
if (!data.member) {
return <div>{t("shared.notFound")}</div>;
} else if (data.member) {
return (
<Form method="post" className="space-y-4">
<input hidden type="text" name="action" value="edit" readOnly />
{rootData.csrf && <input type="hidden" name="csrf" value={rootData.csrf} />}
<div className="grid grid-cols-2 gap-2">
{/*Email */}
<InputText
className="col-span-2"
disabled={!getUserHasPermission(appData, "app.settings.members.update")}
name="email"
title={t("models.user.email")}
autoComplete="off"
readOnly
defaultValue={data.member?.user.email || actionData?.fields?.email}
/>
{/*Email: End */}
{/*User First Name */}
<InputText
type="text"
disabled={!getUserHasPermission(appData, "app.settings.members.update")}
name="first-name"
title={t("models.user.firstName")}
autoComplete="off"
readOnly
defaultValue={data.member?.user.firstName || actionData?.fields?.firstName}
/>
{/*User First Name: End */}
{/*User Last Name */}
<InputText
disabled={!getUserHasPermission(appData, "app.settings.members.update")}
type="text"
title={t("models.user.lastName")}
name="last-name"
autoComplete="off"
readOnly
defaultValue={data.member?.user.lastName || actionData?.fields?.lastName}
/>
{/*User Last Name: End */}
</div>
<div className="mt-4 flex items-center justify-between">
{(() => {
if (loading) {
return (
<div className="text-theme-700 text-sm">
<div>{t("shared.loading")}...</div>
</div>
);
} else {
return (
<div>
<ButtonSecondary
destructive
disabled={!getUserHasPermission(appData, "app.settings.members.delete")}
onClick={remove}
isLoading={loading}
>
<div>{t("shared.remove")}</div>
</ButtonSecondary>
</div>
);
}
})()}
<div className="flex items-center space-x-2">
<ButtonSecondary
disabled={loading}
className={clsx(
"focus:ring-ring hover:bg-secondary border-border bg-background text-foreground/80 inline-flex items-center space-x-2 border px-3 py-2 font-medium shadow-2xs focus:outline-hidden focus:ring-2 focus:ring-offset-2 sm:rounded-md sm:text-sm",
loading && "bg-secondary/90 cursor-not-allowed"
)}
type="button"
onClick={close}
>
<div>{t("shared.cancel")}</div>
</ButtonSecondary>
{/* <ButtonPrimary disabled={loading || !getUserHasPermission( appData,"app.settings.members.update")} type="submit">
<div>{t("shared.save")}</div>
</ButtonPrimary> */}
</div>
</div>
</Form>
);
} else {
return <div></div>;
}
})()}
<ConfirmModal ref={confirmRemove} onYes={yesRemove} />
<ErrorModal ref={errorModal} />
<SuccessModal ref={successModal} onClosed={close} />
</div>
);
}
@@ -0,0 +1,140 @@
import { randomUUID } from "node:crypto";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { useNavigate, useParams } from "react-router";
import GroupForm from "~/components/core/roles/GroupForm";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppData } from "~/utils/data/useAppData";
import { createLog } from "~/utils/db/logs.db.server";
import { getGroup, GroupWithDetails, updateGroup } from "~/utils/db/permissions/groups.db.server";
import { deletePermissionGroupAndSync, replaceGroupUsers } from "~/utils/db/permissions/userGroups.db.server";
import { getTenantUsers, TenantUserWithUser } from "~/utils/db/tenants.db.server";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { getUserPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
title: string;
item: GroupWithDetails;
tenantUsers: TenantUserWithUser[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const userInfo = await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const item = await getGroup(params.id ?? "", tenantId);
if (!item) {
throw redirect(UrlUtils.currentTenantUrl(params, "settings/team"));
}
const { userPermission: canManageGroups } = await getUserPermission({
userId: userInfo.userId,
tenantId,
permissionName: "app.settings.groups.full",
});
if (!canManageGroups && item.createdByUserId !== userInfo.userId) {
throw Response.json({ error: t("models.group.errors.manageForbidden") }, { status: 403 });
}
const data: LoaderData = {
title: `${item.name} | ${t("models.group.object")} | ${process.env.APP_NAME}`,
item,
tenantUsers: await getTenantUsers(tenantId),
};
return data;
};
type ActionData = {
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const userInfo = await requireAuth({ request, params });
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const existing = await getGroup(params.id ?? "", tenantId);
if (!existing) {
throw redirect(UrlUtils.currentTenantUrl(params, "settings/team"));
}
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const { userPermission: canManageGroups } = await getUserPermission({
userId: userInfo.userId,
tenantId,
permissionName: "app.settings.groups.full",
});
if (!canManageGroups && existing.createdByUserId !== userInfo.userId) {
throw Response.json({ error: t("models.group.errors.manageForbidden") }, { status: 403 });
}
if (action === "edit") {
const data = {
tenantId: tenantId,
name: form.get("name")?.toString() ?? "",
description: form.get("description")?.toString() ?? "",
color: Number(form.get("color")),
};
const updated = await updateGroup(existing.id, data, tenantId);
if ("count" in updated && updated.count !== 1) {
return badRequest({ error: t("shared.notFound") });
}
const userIds = form.getAll("users[]").map((f) => f.toString());
const tenantUsers = await getTenantUsers(tenantId);
const users = tenantUsers.filter((tenantUser) => userIds.includes(tenantUser.userId)).map((tenantUser) => tenantUser.user);
if (users.length !== userIds.length) {
return badRequest({ error: t("shared.invalidForm") });
}
await replaceGroupUsers(
existing.id,
tenantId,
users.map((user) => user.id),
{ actorUserId: userInfo.userId, requestId: `settings-group:${existing.id}:replace:${randomUUID()}` }
);
await createLog(request, tenantId, "settings.groups.updated", `${existing.name}: ${JSON.stringify({ ...data, users: users.map((f) => f.email) })}`);
} else if (action === "delete") {
const deleted = await deletePermissionGroupAndSync(existing.id, tenantId, {
actorUserId: userInfo.userId,
requestId: `settings-group:${existing.id}:delete:${randomUUID()}`,
});
if ("count" in deleted && deleted.count !== 1) {
return badRequest({ error: t("shared.notFound") });
}
await createLog(request, tenantId, "settings.groups.deleted", `${existing.name}`);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
const messageKey = action === "delete" ? "settings.members.toast.groupDeleted" : "settings.members.toast.groupSaved";
return redirect(`${UrlUtils.currentTenantUrl(params, "settings/team")}?toast=${encodeURIComponent(messageKey)}`);
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function AdminEditGroupRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const appData = useAppData();
const navigate = useNavigate();
const params = useParams();
return (
<SlideOverWideEmpty
title={t("settings.members.groups.editTitle")}
open={true}
className="sm:max-w-sm"
onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/team"))}
>
<GroupForm
allUsers={data.tenantUsers}
item={data.item}
canUpdate={getUserHasPermission(appData, "app.settings.groups.full") || data.item.createdByUserId === appData.user.id}
canDelete={getUserHasPermission(appData, "app.settings.groups.full") || data.item.createdByUserId === appData.user.id}
/>
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,98 @@
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { useNavigate, useParams } from "react-router";
import GroupForm from "~/components/core/roles/GroupForm";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { createLog } from "~/utils/db/logs.db.server";
import { createPermissionGroupWithUsers } from "~/utils/db/permissions/userGroups.db.server";
import { getTenantUsers, TenantUserWithUser } from "~/utils/db/tenants.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
tenantUsers: TenantUserWithUser[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.groups.full", tenantId);
const data: LoaderData = {
tenantUsers: await getTenantUsers(tenantId),
};
return data;
};
type ActionData = {
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.groups.full", tenantId);
await validateCSRFToken(request);
const userInfo = await getUserInfo(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "create") {
const data = {
createdByUserId: userInfo.userId,
tenantId: tenantId,
name: form.get("name")?.toString() ?? "",
description: form.get("description")?.toString() ?? "",
color: Number(form.get("color")),
};
const userIds = form.getAll("users[]").map((f) => f.toString());
const selectedUserIds = new Set(userIds);
const tenantUsers = await getTenantUsers(tenantId);
const users = tenantUsers.filter((tenantUser) => selectedUserIds.has(tenantUser.userId)).map((tenantUser) => tenantUser.user);
if (users.length !== userIds.length) {
return badRequest({ error: t("shared.invalidForm") });
}
await createPermissionGroupWithUsers(
tenantId,
{
createdByUserId: data.createdByUserId,
name: data.name,
description: data.description,
color: data.color,
},
users.map((user) => user.id)
);
await createLog(
request,
tenantId,
"settings.groups.created",
`${JSON.stringify({
...data,
users: users.map((f) => f.email),
})}`
);
return redirect(`${UrlUtils.currentTenantUrl(params, "settings/team")}?toast=${encodeURIComponent("settings.members.toast.groupCreated")}`);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export default function NewGroupRoute() {
const { t } = useTranslation();
const navigate = useNavigate();
const params = useParams();
const data = useLoaderData<LoaderData>();
return (
<SlideOverWideEmpty
title={t("settings.members.groups.createTitle")}
open={true}
className="sm:max-w-sm"
onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/team"))}
>
<GroupForm allUsers={data.tenantUsers} />
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,26 @@
import { readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
const sourcePath = "apps/web/app/routes/app.$tenant/settings/team/members/new.tsx";
const source = readFileSync(sourcePath, "utf8");
describe("new member invitation mail outbox wiring", () => {
it("publishes the invitation email through the transactional outbox inside invite creation", () => {
expect(source).toContain("await db.$transaction");
expect(source.indexOf("const created = await createWorkspaceInvite")).toBeLessThan(source.indexOf("await publishOutboxEvent"));
expect(source).toContain('type: "mail.transactional.send"');
expect(source).toContain("text: rendered.text");
expect(source).toContain("`mail:workspace-invite:${created.id}`");
expect(source).toContain('priorityOverride: "critical"');
});
it("does not send invitation mail directly from the web action", () => {
expect(source).not.toContain("sendEmail({");
expect(source).not.toContain("sendEmailMailjet");
});
it("does not return raw exception messages to the member invitation UI", () => {
expect(source).not.toContain("error?.message");
expect(source).not.toContain("error.message");
});
});
@@ -0,0 +1,176 @@
import { ActionFunction, LoaderFunctionArgs, Navigate, redirect, MetaFunction, useParams } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenant, getTenantMember } from "~/utils/db/tenants.db.server";
import { getUser, getUserByEmail } from "~/utils/db/users.db.server";
import { createWorkspaceInvite, WorkspaceInviteError } from "@hivegrid/db/workspace-invites.server";
import { getDbClient } from "@hivegrid/db/client.server";
import { publishOutboxEvent, type OutboxPublisherTransaction } from "@hivegrid/db/outbox";
import type { Prisma } from "@hivegrid/db/prisma-browser";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto";
import { getPlanFeatureUsage } from "~/utils/services/.server/subscriptionService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { DefaultFeatures } from "~/application/dtos/shared/DefaultFeatures";
import { getAbsoluteUrl } from "~/utils/url.server";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
import ServerError from "~/components/ui/errors/ServerError";
import EventsService from "~/modules/events/services/.server/EventsService";
import { MemberInvitationCreatedDto } from "~/modules/events/dtos/MemberInvitationCreatedDto";
import { getUserInfo } from "~/utils/session.server";
import EmailTemplates from "~/modules/emails/utils/EmailTemplates";
import { getMailTranslator } from "~/locale/mail-translator.server";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
export type NewMemberLoaderData = {
title: string;
featurePlanUsage: PlanFeatureUsageDto | undefined;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.members.create", tenantId);
const featurePlanUsage = await getPlanFeatureUsage(tenantId, DefaultFeatures.Users);
const data: NewMemberLoaderData = {
title: `${t("settings.members.actions.new")} | ${process.env.APP_NAME}`,
featurePlanUsage,
};
return data;
};
export type NewMemberActionData = {
error?: string;
success?: string;
fields?: {
email: string;
firstName: string;
lastName: string;
role: number;
};
};
export const action: ActionFunction = async ({ request, params }) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await validateCSRFToken(request);
await verifyUserHasPermission(request, "app.settings.members.create", tenantId);
const { userId } = await getUserInfo(request);
const fromUser = await getUser(userId);
const tenant = await getTenant(tenantId);
if (!tenant || !fromUser) {
return Response.json({ error: t("settings.members.errors.tenantOrUserNotFound") });
}
const form = await request.formData();
const email = form.get("email")?.toString().toLowerCase().trim() ?? "";
const firstName = form.get("first-name")?.toString() ?? "";
const lastName = form.get("last-name")?.toString() ?? "";
const sendInvitationEmail = Boolean(form.get("send-invitation-email"));
try {
const user = await getUserByEmail(email);
if (user) {
const tenantUser = await getTenantMember(user.id, tenantId);
if (tenantUser) {
return Response.json({ error: t("settings.members.errors.userAlreadyInOrganization") });
}
}
const mailTranslator = sendInvitationEmail ? await getMailTranslator(fromUser.locale) : null;
const appConfiguration = sendInvitationEmail ? await getAppConfiguration({ request }) : null;
const db = getDbClient();
const invitation = await db.$transaction(async (tx) => {
const created = await createWorkspaceInvite(
{
tenantId,
email,
firstName,
lastName,
type: TenantUserType.MEMBER,
fromUserId: fromUser?.id ?? null,
// DoD "Einladung 48h": kein expliziter Wert mehr -> createWorkspaceInvite setzt den
// 48h-Default (WORKSPACE_INVITE_TTL_MS) als Single Source of Truth.
},
tx
);
if (sendInvitationEmail && mailTranslator && appConfiguration) {
const rendered = EmailTemplates.USER_INVITATION_EMAIL.parse({
appConfiguration,
data: {
name: firstName,
invite_sender_name: fromUser.firstName,
invite_sender_organization: tenant.name,
action_url: getAbsoluteUrl(request, `/invitation/${created.token}`),
},
t: mailTranslator.t,
locale: mailTranslator.locale,
});
await publishOutboxEvent(tx as OutboxPublisherTransaction, {
tenantId: tenant.id,
type: "mail.transactional.send",
dispatchKey: `mail:workspace-invite:${created.id}`,
payload: {
tenantId: tenant.id,
to: [email],
subject: rendered.subject,
text: rendered.text,
html: rendered.body,
priorityOverride: "critical",
metadata: {
source: "workspace-invitation",
alias: "user-invitation",
invitationId: created.id,
},
} satisfies Prisma.InputJsonValue,
});
}
return created;
});
await EventsService.create({
request,
event: "member.invitation.created",
tenantId: tenant.id,
userId: fromUser.id,
data: {
user: { email: invitation.email, firstName: invitation.firstName, lastName: invitation.lastName, type: TenantUserType[invitation.type] },
tenant: { id: tenant.id, name: tenant.name },
fromUser: { id: fromUser!.id, email: fromUser!.email },
} satisfies MemberInvitationCreatedDto,
});
return redirect(
`${appPath({ tenantSlug: params.tenant ?? "", path: "settings/team", mode: "host-aware" })}?toast=${encodeURIComponent("settings.members.toast.invitationSent")}`
);
} catch (error: any) {
if (error instanceof WorkspaceInviteError && error.code === "duplicate_active_invite") {
return Response.json({ error: t("settings.members.errors.invitationAlreadyExists") }, { status: 400 });
}
// eslint-disable-next-line no-console
console.error(error);
return Response.json({ error: t("settings.members.errors.createInvitationFailed") }, { status: 400 });
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
// Action-only route: the invite form is the InviteMemberDialog on the Mitarbeiter
// tab (see settings/team/index.tsx), which posts this action. The tab is an INDEX
// route and can carry no children, so the form cannot live in its outlet — the
// dialog posts here with a fetcher instead. Opening the URL directly lands on the
// tab that owns the dialog.
export default function NewMemberRoute() {
const params = useParams();
return <Navigate to={UrlUtils.currentTenantUrl(params, "settings/team")} replace />;
}
export function ErrorBoundary() {
return <ServerError />;
}
@@ -0,0 +1,333 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: (key: string) => key })),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/services/workspaceRoles.server", () => ({
createWorkspaceRole: vi.fn(),
deleteWorkspaceRole: vi.fn(),
requireWorkspaceRolesBuilderAccess: vi.fn(),
updateWorkspaceRole: vi.fn(),
}));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({
getAllRolesWithUsers: vi.fn(),
getTenantMutableAppRole: vi.fn(),
}));
vi.mock("~/utils/db/permissions/permissions.db.server", () => ({
getAllPermissions: vi.fn(),
}));
vi.mock("~/utils/app/UrlUtils", () => ({
default: {
currentTenantUrl: vi.fn((_params: Record<string, string | undefined>, path: string) => `/acme/${path}`),
slugify: vi.fn((value: string) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")),
},
}));
vi.mock("~/utils/session.server", () => ({
validateCSRFToken: vi.fn(),
}));
import { getAllPermissions } from "~/utils/db/permissions/permissions.db.server";
import { getAllRolesWithUsers, getTenantMutableAppRole } from "~/utils/db/permissions/roles.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { createWorkspaceRole, deleteWorkspaceRole, requireWorkspaceRolesBuilderAccess, updateWorkspaceRole } from "~/utils/services/workspaceRoles.server";
import { action as editAction, loader as editLoader } from "./roles/$id";
import { loader as listLoader } from "./roles";
import { action as newAction, loader as newLoader } from "./roles/new";
const params = { tenant: "acme", id: "role_1" };
const request = new Request("https://app.example.test/acme/settings/roles-and-permissions/roles");
const now = new Date("2026-01-01T00:00:00.000Z");
const appPermission = {
id: "perm_1",
name: "app.settings.members.view",
type: "app",
description: "View members",
order: 1,
inRoles: [],
createdAt: now,
updatedAt: now,
entityId: null,
isDefault: false,
};
const adminPermission = {
id: "perm_2",
name: "admin.roles.delete",
type: "admin",
description: "Delete admin roles",
order: 2,
inRoles: [],
createdAt: now,
updatedAt: now,
entityId: null,
isDefault: false,
};
const role = {
id: "role_1",
name: "Workspace editor",
description: "Can edit workspace data",
type: "app",
isDefault: false,
assignToNewUsers: false,
order: 1,
createdAt: now,
updatedAt: now,
tenantId: "tenant_1",
permissions: [{ id: "role_perm_1", roleId: "role_1", permissionId: "perm_1", permission: appPermission }],
users: [],
};
async function callListLoader() {
return listLoader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles" } as LoaderFunctionArgs);
}
async function callNewLoader() {
return newLoader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/new" } as LoaderFunctionArgs);
}
async function callNewAction(form: FormData) {
return newAction({
request: new Request(request.url, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(form as unknown as Record<string, string>) }),
params,
context: {},
unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/new",
} as ActionFunctionArgs);
}
async function callEditAction(form: FormData) {
return editAction({
request: new Request(`${request.url}/role_1`, { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(form as unknown as Record<string, string>) }),
params,
context: {},
unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/$id",
} as ActionFunctionArgs);
}
async function callEditLoader() {
return editLoader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/roles-and-permissions/roles/$id" } as LoaderFunctionArgs);
}
function roleForm(overrides?: Record<string, string>) {
const form = new FormData();
form.set("action", "edit");
form.set("name", "Workspace editor");
form.set("description", "Can edit workspace data");
form.set("type", "app");
form.append("permissions[]", "app.settings.members.view");
Object.entries(overrides ?? {}).forEach(([key, value]) => form.set(key, value));
return form;
}
async function responseJson(result: unknown) {
expect(result).toBeInstanceOf(Response);
return (result as Response).json();
}
describe("tenant workspace role routes", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant_1");
vi.mocked(requireWorkspaceRolesBuilderAccess).mockResolvedValue({ tenantId: "tenant_1" });
vi.mocked(getAllRolesWithUsers).mockResolvedValue([role] as Awaited<ReturnType<typeof getAllRolesWithUsers>>);
vi.mocked(getAllPermissions).mockResolvedValue([appPermission] as Awaited<ReturnType<typeof getAllPermissions>>);
vi.mocked(getTenantMutableAppRole).mockResolvedValue(role as Awaited<ReturnType<typeof getTenantMutableAppRole>>);
});
it("blocks the list loader through the workspace-role feature gate", async () => {
const disabled = new Response("Workspace roles are not enabled", { status: 404 });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(disabled);
await expect(callListLoader()).rejects.toBe(disabled);
expect(getAllRolesWithUsers).not.toHaveBeenCalled();
});
it("builds the roles VM from default and tenant-owned app roles after requiring builder access", async () => {
const defaultRole = { ...role, id: "role_default", isDefault: true, tenantId: null };
vi.mocked(getAllRolesWithUsers).mockResolvedValueOnce([role, defaultRole] as Awaited<ReturnType<typeof getAllRolesWithUsers>>);
const data = (await callListLoader()) as { vm: { status: string; data?: { rows: { id: string; typeKey: string }[] } }; editorCatalog: unknown; rolePermissionNames: Record<string, string[]> };
expect(requireWorkspaceRolesBuilderAccess).toHaveBeenCalledWith({ request, params, tenantId: "tenant_1" });
expect(getAllRolesWithUsers).toHaveBeenCalledWith("app", undefined, "tenant_1");
expect(data.vm.status).toBe("ready");
expect(data.vm.data?.rows.map((row) => ({ id: row.id, typeKey: row.typeKey }))).toEqual([
{ id: "role_1", typeKey: "custom" },
{ id: "role_default", typeKey: "system" },
]);
// Editor prefill data: catalog is app-only, per-role permission names are exposed by id.
expect(data.editorCatalog).toEqual([{ name: "app.settings.members.view", description: "View members" }]);
expect(data.rolePermissionNames).toEqual({ role_1: ["app.settings.members.view"], role_default: ["app.settings.members.view"] });
});
it("new role loader exposes only app permissions", async () => {
vi.mocked(getAllPermissions).mockResolvedValueOnce([appPermission, adminPermission] as Awaited<ReturnType<typeof getAllPermissions>>);
const data = await callNewLoader();
expect(getAllPermissions).toHaveBeenCalledWith("app");
expect(JSON.stringify(data)).not.toContain("admin.roles.delete");
});
it("create action delegates mutation to the workspace role service", async () => {
const form = new FormData();
form.set("action", "create");
form.set("name", " Workspace editor ");
form.set("description", "Can edit workspace data");
form.set("type", "app");
form.append("permissions[]", "app.settings.members.view");
const result = await callNewAction(form);
expect(createWorkspaceRole).toHaveBeenCalledWith({
request: expect.any(Request),
tenantId: "tenant_1",
data: {
name: " Workspace editor ",
description: "Can edit workspace data",
assignToNewUsers: false,
type: "app",
permissionNames: ["app.settings.members.view"],
},
});
expect(result).toBeInstanceOf(Response);
expect((result as Response).status).toBe(302);
});
it("create action returns bounded 400 JSON for service-denied admin type tampering", async () => {
vi.mocked(createWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin capabilities", { status: 400 }));
const form = new FormData();
form.set("action", "create");
form.set("name", "Escalate");
form.set("description", "Tampered payload");
form.set("type", "admin");
form.append("permissions[]", "app.settings.members.view");
const result = await callNewAction(form);
expect(createWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ type: "admin" }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin capabilities" });
});
it("create action returns bounded 400 JSON for service-denied admin permission tampering", async () => {
vi.mocked(createWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin permissions", { status: 400 }));
const form = new FormData();
form.set("action", "create");
form.set("name", "Escalate");
form.set("description", "Tampered payload");
form.set("type", "app");
form.append("permissions[]", "admin.roles.delete");
const result = await callNewAction(form);
expect(createWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ permissionNames: ["admin.roles.delete"] }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin permissions" });
});
it("create action propagates access denial before parsing or mutating", async () => {
const denied = new Response(null, { status: 302, headers: { Location: "/login?redirectTo=%2Facme%2Fsettings%2Froles" } });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(denied);
const form = new FormData();
form.set("action", "create");
form.set("name", "No access");
form.set("type", "admin");
await expect(callNewAction(form)).rejects.toBe(denied);
expect(createWorkspaceRole).not.toHaveBeenCalled();
});
it("edit action returns bounded 400 responses for service validation errors", async () => {
vi.mocked(updateWorkspaceRole).mockRejectedValueOnce(new Response("Default roles cannot be changed", { status: 400 }));
const result = await callEditAction(roleForm({ name: "Default", description: "Protected" }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Default roles cannot be changed" });
});
it("edit action returns bounded 400 JSON for service-denied admin type tampering", async () => {
vi.mocked(updateWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin capabilities", { status: 400 }));
const result = await callEditAction(roleForm({ type: "admin" }));
expect(updateWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ type: "admin" }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin capabilities" });
});
it("edit action returns bounded 400 JSON for service-denied admin permission tampering", async () => {
vi.mocked(updateWorkspaceRole).mockRejectedValueOnce(new Response("Workspace roles cannot grant admin permissions", { status: 400 }));
const form = roleForm();
form.delete("permissions[]");
form.append("permissions[]", "admin.roles.delete");
const result = await callEditAction(form);
expect(updateWorkspaceRole).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({ permissionNames: ["admin.roles.delete"] }) }));
expect((result as Response).status).toBe(400);
await expect(responseJson(result)).resolves.toEqual({ error: "Workspace roles cannot grant admin permissions" });
});
it("edit action propagates access denial before mutation", async () => {
const denied = new Response("Forbidden", { status: 403 });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(denied);
await expect(callEditAction(roleForm({ type: "admin" }))).rejects.toBe(denied);
expect(updateWorkspaceRole).not.toHaveBeenCalled();
});
it("delete action propagates access denial before mutation", async () => {
const denied = new Response("Forbidden", { status: 403 });
vi.mocked(requireWorkspaceRolesBuilderAccess).mockRejectedValueOnce(denied);
const form = new FormData();
form.set("action", "delete");
await expect(callEditAction(form)).rejects.toBe(denied);
expect(deleteWorkspaceRole).not.toHaveBeenCalled();
});
it("edit loader exposes only app permissions", async () => {
vi.mocked(getAllPermissions).mockResolvedValueOnce([appPermission, adminPermission] as Awaited<ReturnType<typeof getAllPermissions>>);
const data = await callEditLoader();
expect(getTenantMutableAppRole).toHaveBeenCalledWith("role_1", "tenant_1");
expect(getAllPermissions).toHaveBeenCalledWith("app");
expect(JSON.stringify(data)).not.toContain("admin.roles.delete");
});
it("edit loader redirects guessed roles outside the tenant scope", async () => {
vi.mocked(getTenantMutableAppRole).mockResolvedValueOnce(null);
await expect(callEditLoader()).rejects.toMatchObject({ status: 302 });
expect(getAllPermissions).not.toHaveBeenCalled();
});
it("edit loader rejects default roles before exposing permission data", async () => {
vi.mocked(getTenantMutableAppRole).mockResolvedValueOnce({ ...role, isDefault: true } as Awaited<ReturnType<typeof getTenantMutableAppRole>>);
const result = callEditLoader();
await expect(result).rejects.toMatchObject({ status: 400 });
await result.catch(async (response: Response) => {
await expect(response.text()).resolves.toBe("settings.rolesAndPermissions.errors.onlyNonDefaultAppRolesEditable");
});
expect(getAllPermissions).not.toHaveBeenCalled();
});
it("edit loader rejects non-app roles before exposing permission data", async () => {
vi.mocked(getTenantMutableAppRole).mockResolvedValueOnce({ ...role, type: "admin" } as Awaited<ReturnType<typeof getTenantMutableAppRole>>);
const result = callEditLoader();
await expect(result).rejects.toMatchObject({ status: 400 });
await result.catch(async (response: Response) => {
await expect(response.text()).resolves.toBe("settings.rolesAndPermissions.errors.onlyNonDefaultAppRolesEditable");
});
expect(getAllPermissions).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,123 @@
import { useEffect, useRef, useState } from "react";
import { LoaderFunctionArgs, MetaFunction, useFetcher, useLoaderData, useParams } from "react-router";
import { toast } from "sonner";
import { buildRolesListVM, type RoleEditorInputPermission, type RolesListVM } from "@hivegrid/view-models";
import { getTranslations } from "~/locale/i18next.server";
import { getAllRolesWithUsers } from "~/utils/db/permissions/roles.db.server";
import { getAllPermissions } from "~/utils/db/permissions/permissions.db.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { useRootData } from "~/utils/data/useRootData";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { requireWorkspaceRolesBuilderAccess } from "~/utils/services/workspaceRoles.server";
import { RolesPage, type RolesActions, type RoleMutationInput } from "~/components/screens/users/RolesPage";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
// R-P2b — D-P2 S02 "Rollen und Berechtigungen": the list route builds the VM,
// the RolesPage dialogs (M04A/M04B/M02/D03) post to the existing new/$id
// actions via fetcher — the create/update/delete contracts stay untouched.
type LoaderData = {
title: string;
vm: RolesListVM;
editorCatalog: RoleEditorInputPermission[];
rolePermissionNames: Record<string, string[]>;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await requireWorkspaceRolesBuilderAccess({ request, params, tenantId });
const { t } = await getTranslations(request);
const [items, permissions] = await Promise.all([getAllRolesWithUsers("app", undefined, tenantId), getAllPermissions("app")]);
const vm = buildRolesListVM({
rows: items.map((role) => ({
id: role.id,
name: role.name,
description: role.description,
isDefault: role.isDefault,
tenantId: role.tenantId ?? null,
memberCount: role.users.filter((user) => user.tenantId === tenantId).length,
permissionCount: role.permissions.length,
})),
tenantId,
// The builder gate (app.settings.roles.set) already passed above.
canManageRoles: true,
});
const data: LoaderData = {
title: `${t("models.role.plural")} | ${process.env.APP_NAME}`,
vm,
editorCatalog: permissions.filter((permission) => permission.type === "app").map(({ name, description }) => ({ name, description })),
rolePermissionNames: Object.fromEntries(items.map((role) => [role.id, role.permissions.map((entry) => entry.permission.name)])),
};
return data;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
type MutationResponse = { error?: string; success?: string };
export default function RolesRoute() {
const data = useLoaderData<LoaderData>();
const params = useParams();
const fetcher = useFetcher<MutationResponse>();
const rootData = useRootData();
const [closeSignal, setCloseSignal] = useState(0);
const hadSubmission = useRef(false);
const submitting = fetcher.state !== "idle";
const errorMessage = fetcher.data?.error ?? null;
// Close the dialogs (and toast) once a mutation went through without an error.
useEffect(() => {
if (fetcher.state !== "idle") {
hadSubmission.current = true;
return;
}
if (hadSubmission.current) {
hadSubmission.current = false;
if (!fetcher.data?.error) {
setCloseSignal((value) => value + 1);
if (fetcher.data?.success) toast.success(fetcher.data.success);
}
}
}, [fetcher.state, fetcher.data]);
function post(target: string, fields: Record<string, string>, permissionNames?: string[]) {
const formData = new FormData();
if (rootData.csrf) formData.set("csrf", rootData.csrf);
for (const [name, value] of Object.entries(fields)) {
formData.set(name, value);
}
for (const permissionName of permissionNames ?? []) {
formData.append("permissions[]", permissionName);
}
fetcher.submit(formData, { method: "post", action: UrlUtils.currentTenantUrl(params, `settings/team/roles/${target}`) });
}
const actions: RolesActions = {
onCreate: (input: RoleMutationInput) => post("new", { action: "create", name: input.name, description: input.description, type: "app" }, input.permissionNames),
onUpdate: (roleId: string, input: RoleMutationInput) =>
post(roleId, { action: "edit", name: input.name, description: input.description, type: "app" }, input.permissionNames),
onDelete: (roleId: string) => post(roleId, { action: "delete" }),
};
return (
<>
<EditPageLayout fullWidth>
{/* AK-SET-01: the Team-Hub owns the page header; intro and create CTA
share a row inside the screen, as on the Mitglieder tab. */}
<RolesPage
vm={data.vm}
editorCatalog={data.editorCatalog}
rolePermissionNames={data.rolePermissionNames}
actions={actions}
submitting={submitting}
errorMessage={errorMessage}
closeSignal={closeSignal}
/>
</EditPageLayout>
</>
);
}
@@ -0,0 +1,118 @@
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData, useNavigate, useParams } from "react-router";
import { useEffect } from "react";
import { toast } from "sonner";
import RoleForm from "~/components/core/roles/RoleForm";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { getAllPermissions, PermissionWithRoles } from "~/utils/db/permissions/permissions.db.server";
import { getTenantMutableAppRole, RoleWithPermissions } from "~/utils/db/permissions/roles.db.server";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { useAppData } from "~/utils/data/useAppData";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { deleteWorkspaceRole, requireWorkspaceRolesBuilderAccess, updateWorkspaceRole } from "~/utils/services/workspaceRoles.server";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
title: string;
item: RoleWithPermissions;
permissions: PermissionWithRoles[];
};
type ActionData = {
success?: string;
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
const rolesPath = (params: Record<string, string | undefined>) => UrlUtils.currentTenantUrl(params, "settings/team/roles");
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await requireWorkspaceRolesBuilderAccess({ request, params, tenantId });
const { t } = await getTranslations(request);
const item = await getTenantMutableAppRole(params.id ?? "", tenantId);
if (!item) {
throw redirect(rolesPath(params));
}
if (item.type !== "app" || item.isDefault) {
throw new Response(t("settings.rolesAndPermissions.errors.onlyNonDefaultAppRolesEditable"), { status: 400 });
}
const permissions = (await getAllPermissions("app")).filter((permission) => permission.type === "app");
const data: LoaderData = {
title: `${item.name} | ${t("models.role.object")} | ${process.env.APP_NAME}`,
item,
permissions,
};
return data;
};
export const action: ActionFunction = async ({ request, params }) => {
const tenantId = await getTenantIdFromUrl(params);
await requireWorkspaceRolesBuilderAccess({ request, params, tenantId });
const { t } = await getTranslations(request);
const roleId = params.id ?? "";
if (!roleId) {
return badRequest({ error: t("shared.invalidForm") });
}
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
try {
if (action === "edit") {
await updateWorkspaceRole({
request,
tenantId,
roleId,
data: {
name: form.get("name")?.toString() ?? "",
description: form.get("description")?.toString() ?? "",
assignToNewUsers: Boolean(form.get("assign-to-new-users")),
type: form.get("type")?.toString() === "admin" ? "admin" : "app",
permissionNames: form.getAll("permissions[]").map((permission) => permission.toString()),
},
});
return Response.json({ success: t("shared.updated") });
}
if (action === "delete") {
await deleteWorkspaceRole({ request, tenantId, roleId });
return redirect(`${rolesPath(params)}?toast=${encodeURIComponent("settings.members.toast.roleDeleted")}`);
}
} catch (error) {
if (error instanceof Response && error.status >= 400 && error.status < 500) {
return badRequest({ error: await error.text() });
}
throw error;
}
return badRequest({ error: t("shared.invalidForm") });
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function EditWorkspaceRoleRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const appData = useAppData();
const navigate = useNavigate();
const params = useParams();
const canUpdate = getUserHasPermission(appData, "app.settings.roles.set");
useEffect(() => {
if (actionData?.success) {
toast.success(actionData.success);
} else if (actionData?.error) {
toast.error(actionData.error);
}
}, [actionData]);
function goBack() {
navigate(rolesPath(params));
}
return <RoleForm item={data.item} permissions={data.permissions} onCancel={goBack} canUpdate={canUpdate} canDelete={canUpdate} defaultType="app" lockType />;
}
@@ -0,0 +1,81 @@
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData, useNavigate, useParams } from "react-router";
import RoleForm from "~/components/core/roles/RoleForm";
import { getTranslations } from "~/locale/i18next.server";
import { getAllPermissions, PermissionWithRoles } from "~/utils/db/permissions/permissions.db.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { createWorkspaceRole, requireWorkspaceRolesBuilderAccess } from "~/utils/services/workspaceRoles.server";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
title: string;
permissions: PermissionWithRoles[];
};
type ActionData = {
error?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
const rolesPath = (params: Record<string, string | undefined>) => UrlUtils.currentTenantUrl(params, "settings/team/roles");
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await requireWorkspaceRolesBuilderAccess({ request, params, tenantId });
const { t } = await getTranslations(request);
const permissions = (await getAllPermissions("app")).filter((permission) => permission.type === "app");
const data: LoaderData = {
title: `${t("models.role.object")} | ${process.env.APP_NAME}`,
permissions,
};
return data;
};
export const action: ActionFunction = async ({ request, params }) => {
const tenantId = await getTenantIdFromUrl(params);
await requireWorkspaceRolesBuilderAccess({ request, params, tenantId });
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action !== "create") {
return badRequest({ error: t("shared.invalidForm") });
}
try {
await createWorkspaceRole({
request,
tenantId,
data: {
name: form.get("name")?.toString() ?? "",
description: form.get("description")?.toString() ?? "",
assignToNewUsers: Boolean(form.get("assign-to-new-users")),
type: form.get("type")?.toString() === "admin" ? "admin" : "app",
permissionNames: form.getAll("permissions[]").map((permission) => permission.toString()),
},
});
} catch (error) {
if (error instanceof Response && error.status >= 400 && error.status < 500) {
return badRequest({ error: await error.text() });
}
throw error;
}
return redirect(`${rolesPath(params)}?toast=${encodeURIComponent("settings.members.toast.roleCreated")}`);
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function NewWorkspaceRoleRoute() {
const data = useLoaderData<LoaderData>();
const navigate = useNavigate();
const params = useParams();
function goBack() {
navigate(rolesPath(params));
}
return <RoleForm permissions={data.permissions} onCancel={goBack} defaultType="app" lockType />;
}