Track HiveGrid Cloud planning reference

This commit is contained in:
david committed 2026-06-26 20:48:01 +02:00
1 parent b3d5ea6764
commit e341c5938a
5784 files changed
+1104929 -3

No files matched your search

@@ -0,0 +1,211 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } from "react-router";
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
vi.mock("~/utils/session.server", () => ({ getUserInfo: vi.fn(), validateCSRFToken: vi.fn() }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn() }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: vi.fn() }));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn() }));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenant: vi.fn(),
getTenantBySlug: vi.fn(),
updateTenant: vi.fn(),
}));
vi.mock("~/utils/db/logs.db.server", () => ({ createLog: vi.fn() }));
vi.mock("~/utils/db/entities/entities.db.server", () => ({ findEntityByName: vi.fn() }));
vi.mock("~/utils/api/.server/RowsApi", () => ({ RowsApi: { createCustom: vi.fn() } }));
vi.mock("~/utils/integrations/storageService", () => ({ storeFile: vi.fn() }));
vi.mock("~/utils/integrations/storageAudit.server", () => ({ auditRejectedUpload: vi.fn(() => vi.fn()) }));
vi.mock("~/modules/events/services/.server/EventsService", () => ({ default: { create: vi.fn() } }));
vi.mock("~/utils/services/tenantService", () => ({
deleteAndCancelTenant: vi.fn(),
isReservedTenantSlug: vi.fn(),
normalizeTenantSlug: vi.fn((value: string) => value.trim().toLowerCase()),
}));
vi.mock("~/utils/services/.server/subscriptionService", () => ({ getActiveTenantSubscriptions: vi.fn() }));
vi.mock("~/utils/db/tenants/tenantTypes.db.server", () => ({ getTenantTypeOptions: vi.fn() }));
vi.mock("@toolctrl/config", () => ({ loadRequiredWebConfig: vi.fn(() => ({ routing: { mode: "path" } })) }));
import EventsService from "~/modules/events/services/.server/EventsService";
import { getTranslations } from "~/locale/i18next.server";
import { createLog } from "~/utils/db/logs.db.server";
import { getTenant, getTenantBySlug, updateTenant } from "~/utils/db/tenants.db.server";
import { findEntityByName } from "~/utils/db/entities/entities.db.server";
import { getUser } from "~/utils/db/users.db.server";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import { storeFile } from "~/utils/integrations/storageService";
import { deleteAndCancelTenant, isReservedTenantSlug } from "~/utils/services/tenantService";
import { getActiveTenantSubscriptions } from "~/utils/services/.server/subscriptionService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { action } from "./account";
const params = { tenant: "acme" };
const user = { id: "user_1", email: "ada@example.test" };
const tenant = {
id: "tenant_1",
name: "Acme",
slug: "acme",
icon: null,
tenantSettingsRow: null,
};
function createRequest(form: FormData) {
return new Request("https://app.example.test/acme/settings/account", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(Array.from(form.entries()).map(([key, value]) => [key, String(value)])),
});
}
function createEditForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", "edit");
form.set("name", "Acme GmbH");
form.set("slug", "acme");
form.set("icon", "");
for (const [key, value] of Object.entries(overrides)) {
form.set(key, value);
}
return form;
}
function createDeleteForm() {
const form = new FormData();
form.set("action", "delete");
return form;
}
async function callAction(form: FormData) {
return action({
request: createRequest(form),
params,
context: {},
unstable_pattern: "app.$tenant/settings/account",
} as ActionFunctionArgs) as Promise<Response>;
}
describe("tenant account settings action", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTranslations).mockResolvedValue({
t: (key: string, values?: Record<string, unknown>) => (values?.slug ? `${key}:${values.slug}` : key),
} as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue({ userId: user.id } as never);
vi.mocked(getUser).mockResolvedValue(user as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue(tenant.id);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTenant).mockResolvedValue(tenant as never);
vi.mocked(getTenantBySlug).mockResolvedValue(null as never);
vi.mocked(findEntityByName).mockResolvedValue(null as never);
vi.mocked(updateTenant).mockResolvedValue({ ...tenant, name: "Acme GmbH" } as never);
vi.mocked(EventsService.create).mockResolvedValue(undefined as never);
vi.mocked(createLog).mockResolvedValue({} as never);
vi.mocked(storeFile).mockImplementation(async ({ content }) => String(content));
vi.mocked(isReservedTenantSlug).mockReturnValue(false);
vi.mocked(RowsApi.createCustom).mockResolvedValue({} as never);
vi.mocked(getActiveTenantSubscriptions).mockResolvedValue({ products: [] } as never);
vi.mocked(deleteAndCancelTenant).mockResolvedValue(undefined as never);
});
it("updates account details without changing slug and records audit side effects", async () => {
const response = await callAction(createEditForm());
const data = await response.json();
expect(response.status).toBe(200);
expect(data).toEqual({ success: "settings.tenant.updated" });
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.account.update", tenant.id);
expect(createLog).toHaveBeenCalledWith(expect.any(Request), tenant.id, "settings.tenant.updateDetails", JSON.stringify({ name: "Acme GmbH", slug: "acme" }));
expect(updateTenant).toHaveBeenCalledWith(tenant, { name: "Acme GmbH", icon: "", slug: "acme" });
expect(EventsService.create).toHaveBeenCalledWith(
expect.objectContaining({
event: "account.updated",
tenantId: tenant.id,
userId: user.id,
})
);
expect(getTenantBySlug).not.toHaveBeenCalled();
});
it("redirects to the new tenant route when the slug changes", async () => {
const response = await callAction(createEditForm({ slug: "new-acme" }));
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("/new-acme/settings/account");
expect(getTenantBySlug).toHaveBeenCalledWith("new-acme");
expect(updateTenant).toHaveBeenCalledWith(tenant, { name: "Acme GmbH", icon: "", slug: "new-acme" });
});
it("rejects duplicate slugs before mutating the tenant or publishing events", async () => {
vi.mocked(getTenantBySlug).mockResolvedValueOnce({ id: "tenant_2", slug: "new-acme" } as never);
const response = await callAction(createEditForm({ slug: "new-acme" }));
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ updateDetailsError: "settings.tenant.errors.slugTaken" });
expect(updateTenant).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("rejects reserved slugs before logs, row properties, storage, and tenant mutation", async () => {
vi.mocked(isReservedTenantSlug).mockReturnValueOnce(true);
const response = await callAction(createEditForm({ slug: "admin" }));
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ updateDetailsError: "settings.tenant.errors.reservedSlug:admin" });
expect(createLog).not.toHaveBeenCalled();
expect(RowsApi.createCustom).not.toHaveBeenCalled();
expect(storeFile).not.toHaveBeenCalled();
expect(updateTenant).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("keeps tenant settings row internals out of update errors", async () => {
vi.mocked(findEntityByName).mockResolvedValueOnce({ id: "entity_1" } as never);
vi.mocked(RowsApi.createCustom).mockRejectedValueOnce(new Error("raw row settings failure"));
const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
const response = await callAction(createEditForm());
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ updateDetailsError: "shared.unexpectedError" });
expect(JSON.stringify(data)).not.toContain("raw row settings failure");
expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
consoleError.mockRestore();
});
it("stops on CSRF failure before permission checks and mutations", async () => {
const csrfError = new Response("csrf", { status: 403 });
vi.mocked(validateCSRFToken).mockRejectedValueOnce(csrfError as never);
await expect(callAction(createEditForm())).rejects.toBe(csrfError);
expect(getUserInfo).not.toHaveBeenCalled();
expect(getTenantIdFromUrl).not.toHaveBeenCalled();
expect(verifyUserHasPermission).not.toHaveBeenCalled();
expect(updateTenant).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("rejects account deletion with active subscriptions before delete side effects", async () => {
vi.mocked(getActiveTenantSubscriptions).mockResolvedValueOnce({
products: [{ id: "subscription_product_1", cancelledAt: null }],
} as never);
const response = await callAction(createDeleteForm());
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ deleteError: "settings.tenant.errors.cannotDeleteWithActiveSubscriptions" });
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.account.delete", tenant.id);
expect(deleteAndCancelTenant).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalledWith(expect.objectContaining({ event: "account.deleted" }));
});
});
@@ -0,0 +1,296 @@
import { useTranslation } from "react-i18next";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData } from "react-router";
import { useActionData, useSubmit } from "react-router";
import { useAppData } from "~/utils/data/useAppData";
import { getTranslations } from "~/locale/i18next.server";
import { getTenant, getTenantBySlug, updateTenant, type TenantWithDetails } from "~/utils/db/tenants.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import UpdateTenantDetailsForm from "~/components/core/tenants/UpdateTenantDetailsForm";
import { createLog } from "~/utils/db/logs.db.server";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import ButtonPrimary from "~/components/ui/buttons/ButtonPrimary";
import { useEffect, useRef } from "react";
import ConfirmModal, { RefConfirmModal } from "~/components/ui/modals/ConfirmModal";
import { deleteAndCancelTenant, isReservedTenantSlug, normalizeTenantSlug } from "~/utils/services/tenantService";
import EventsService from "~/modules/events/services/.server/EventsService";
import { getUser } from "~/utils/db/users.db.server";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getActiveTenantSubscriptions } from "~/utils/services/.server/subscriptionService";
import { RowsApi } from "~/utils/api/.server/RowsApi";
import { findEntityByName, type EntityWithDetails } from "~/utils/db/entities/entities.db.server";
import { storeFile } from "~/utils/integrations/storageService";
import { auditRejectedUpload } from "~/utils/integrations/storageAudit.server";
import { getTenantTypeOptions } from "~/utils/db/tenants/tenantTypes.db.server";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import SettingSection from "~/components/ui/sections/SettingSection";
import { AccountUpdatedDto } from "~/modules/events/dtos/AccountUpdatedDto";
import { AccountDeletedDto } from "~/modules/events/dtos/AccountDeletedDto";
import toast from "react-hot-toast";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { useRootData } from "~/utils/data/useRootData";
import { loadRequiredWebConfig } from "@toolctrl/config";
import { absoluteAppRootPath } from "~/utils/app/CrossHostUrls";
type LoaderData = {
title: string;
tenantSettingsEntity: EntityWithDetails | null;
tenant: TenantWithDetails;
tenantTypes: Awaited<ReturnType<typeof getTenantTypeOptions>>;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.account.view", tenantId);
const { t } = await getTranslations(request);
const [tenantSettingsEntity, tenant, tenantTypes] = await Promise.all([
findEntityByName({ tenantId, name: "tenantSettings" }),
getTenant(tenantId),
getTenantTypeOptions(),
]);
if (!tenant) {
throw Error(t("shared.notFound"));
}
const data: LoaderData = {
title: `${t("models.tenant.object")} | ${process.env.APP_NAME}`,
tenantSettingsEntity,
tenant,
tenantTypes,
};
return data;
};
type ActionData = {
updateDetailsError?: string;
deleteError?: string;
success?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const userInfo = await getUserInfo(request);
const currentUser = await getUser(userInfo.userId);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const tenant = await getTenant(tenantId);
if (!tenant || !currentUser) {
return redirect(absoluteAppRootPath(loadRequiredWebConfig().routing));
}
if (action === "edit") {
const name = form.get("name")?.toString() ?? "";
const slug = normalizeTenantSlug(form.get("slug")?.toString() ?? "");
const icon = form.get("icon")?.toString() ?? "";
if ((name?.length ?? 0) < 1) {
return badRequest({
updateDetailsError: t("settings.tenant.errors.nameRequired"),
});
}
if (!slug || slug.length < 1) {
return badRequest({ updateDetailsError: t("settings.tenant.errors.slugRequired") });
}
if (isReservedTenantSlug(slug)) {
return badRequest({
updateDetailsError: t("settings.tenant.errors.reservedSlug", { slug }),
});
}
if (slug.includes(" ")) {
return badRequest({
updateDetailsError: t("settings.tenant.errors.slugWhitespace"),
});
}
const existing = await getTenant(tenantId);
if (!existing) {
return badRequest({ updateDetailsError: t("settings.tenant.errors.notFound") });
}
await createLog(request, tenantId, "settings.tenant.updateDetails", JSON.stringify({ name, slug }));
const tenantSettingsEntity = await findEntityByName({ tenantId, name: "tenantSettings" });
if (tenantSettingsEntity) {
try {
await RowsApi.createCustom({
entity: tenantSettingsEntity,
tenantId,
t,
form,
row: existing?.tenantSettingsRow?.row as Parameters<typeof RowsApi.createCustom>[0]["row"],
rowCreateInput: { tenantSettingsRow: { create: { tenantId } } },
request,
});
} catch (error) {
console.error(error);
return badRequest({ updateDetailsError: t("shared.unexpectedError") });
}
}
if (existing?.slug !== slug) {
const existingSlug = await getTenantBySlug(slug);
if (existingSlug) {
return badRequest({
updateDetailsError: t("settings.tenant.errors.slugTaken"),
});
}
let iconStored = icon
? await storeFile({
bucket: "accounts-icons",
content: icon,
id: tenantId,
scan: { context: "avatar", enqueuePostScan: true, onReject: auditRejectedUpload(request, "tenant.account.icon"), filename: `${tenantId}.icon` },
})
: icon;
await updateTenant(existing, { name, icon: iconStored, slug });
await EventsService.create({
request,
event: "account.updated",
tenantId: tenant.id,
userId: currentUser.id,
data: {
id: tenant.id,
new: { name, slug },
old: { name: tenant.name, slug: tenant.slug },
user: { id: currentUser.id ?? "", email: currentUser.email },
} satisfies AccountUpdatedDto,
});
return redirect(appPath({ tenantSlug: slug, path: "settings/account", mode: "host-aware" }));
} else {
let iconStored = icon
? await storeFile({
bucket: "accounts-icons",
content: icon,
id: tenantId,
scan: { context: "avatar", enqueuePostScan: true, onReject: auditRejectedUpload(request, "tenant.account.icon"), filename: `${tenantId}.icon` },
})
: icon;
await updateTenant(existing, { name, icon: iconStored, slug });
await EventsService.create({
request,
event: "account.updated",
tenantId: tenant.id,
userId: currentUser.id,
data: {
id: tenant.id,
new: { name, slug },
old: { name: tenant.name, slug: tenant.slug },
user: { id: currentUser.id, email: currentUser.email },
} satisfies AccountUpdatedDto,
});
const actionData: ActionData = {
success: t("settings.tenant.updated"),
};
return Response.json(actionData);
}
} else if (action === "delete") {
await verifyUserHasPermission(request, "app.settings.account.delete", tenantId);
const activeSubscriptions = await getActiveTenantSubscriptions(tenantId);
if (activeSubscriptions && activeSubscriptions.products.find((f) => !f.cancelledAt)) {
return badRequest({
deleteError: t("settings.tenant.errors.cannotDeleteWithActiveSubscriptions"),
});
}
await EventsService.create({
request,
event: "account.deleted",
tenantId: null,
userId: currentUser.id,
data: {
tenant: { id: tenant.id, name: tenant.name },
user: { id: currentUser.id, email: currentUser.email },
} satisfies AccountDeletedDto,
});
await deleteAndCancelTenant({ tenantId, userId: userInfo.userId, t });
return redirect(absoluteAppRootPath(loadRequiredWebConfig().routing));
} else {
return badRequest({ updateDetailsError: t("shared.invalidForm") });
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function TenantRoute() {
const data = useLoaderData<LoaderData>();
const appData = useAppData();
const actionData = useActionData<ActionData>();
const { t } = useTranslation();
const submit = useSubmit();
const rootData = useRootData();
const confirmDelete = useRef<RefConfirmModal>(null);
useEffect(() => {
if (actionData?.success) {
toast.success(actionData.success);
} else if (actionData?.updateDetailsError) {
toast.error(actionData.updateDetailsError);
} else if (actionData?.deleteError) {
toast.error(actionData.deleteError);
}
}, [actionData]);
function deleteAccount() {
confirmDelete.current?.show(t("settings.danger.confirmDeleteTenant"), t("shared.confirm"), t("shared.cancel"), t("shared.warningCannotUndo"));
}
function confirmDeleteTenant() {
const form = new FormData();
form.set("action", "delete");
if (rootData.csrf) {
form.set("csrf", rootData.csrf);
}
submit(form, { method: "post" });
}
return (
<EditPageLayout>
<SettingSection title={t("settings.tenant.general")} description={t("settings.tenant.generalDescription")}>
<UpdateTenantDetailsForm
disabled={!getUserHasPermission(appData, "app.settings.account.update")}
tenant={data.tenant}
tenantSettingsEntity={data.tenantSettingsEntity}
tenantTypes={data.tenantTypes}
options={{
canChangeType: false,
}}
/>
</SettingSection>
{/*Separator */}
<div className="block">
<div className="py-5">
<div className="border-border border-t"></div>
</div>
</div>
{/*Danger */}
<SettingSection title={t("settings.danger.title")} description={t("settings.danger.description")}>
<div className="mt-12 md:col-span-2 md:mt-0">
<div>
<input hidden type="text" name="action" value="deleteAccount" readOnly />
<div className="">
<div className="">
<div className="">
<ButtonPrimary
disabled={!getUserHasPermission(appData, "app.settings.account.delete")}
destructive={true}
onClick={deleteAccount}
dataUiId="ui.settings.account.delete"
>
{t("settings.danger.deleteWorkspace")}
</ButtonPrimary>
</div>
</div>
</div>
</div>
</div>
</SettingSection>
<ConfirmModal ref={confirmDelete} onYes={confirmDeleteTenant} />
</EditPageLayout>
);
}
@@ -0,0 +1,70 @@
import type { LoaderFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("~/modules/api/services/ApiSpecsService", () => ({
default: {
generateSpecs: vi.fn(async () => ({
openApi: { openapi: "3.1.0" },
postmanCollection: { info: {}, item: [] },
apiDocsUrl: "https://api.example.com/v1/docs",
})),
},
}));
vi.mock("~/utils/db/appConfiguration.db.server", () => ({
getAppConfiguration: vi.fn(async () => ({ app: { features: { tenantApiKeys: true } } })),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: vi.fn(async () => undefined) }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn(async () => "tenant-1") }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string) => (key === "settings.api.errors.tenantApiKeysNotEnabled" ? "API keys are not enabled" : key),
})),
}));
import ApiSpecsService from "~/modules/api/services/ApiSpecsService";
import { getTranslations } from "~/locale/i18next.server";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { loader } from "./docs";
describe("tenant API docs route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(getAppConfiguration).mockResolvedValue({ app: { features: { tenantApiKeys: true } } } as never);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
});
it("checks tenant permission and feature gate before generating docs", async () => {
const request = new Request("https://app.example.com/acme/settings/api/docs");
const data = await loader({ request, params: { tenant: "acme" }, context: {} } as unknown as LoaderFunctionArgs);
expect(getTenantIdFromUrl).toHaveBeenCalledWith({ tenant: "acme" });
expect(verifyUserHasPermission).toHaveBeenCalledWith(request, "app.settings.apiKeys.view", "tenant-1");
expect(getAppConfiguration).toHaveBeenCalledWith({ request });
expect(ApiSpecsService.generateSpecs).toHaveBeenCalledWith({ request });
expect(data).toMatchObject({ apiSpecs: { apiDocsUrl: "https://api.example.com/v1/docs" } });
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(
vi.mocked(ApiSpecsService.generateSpecs).mock.invocationCallOrder[0]
);
});
it("does not generate docs when tenant API keys are disabled", async () => {
vi.mocked(getAppConfiguration).mockResolvedValue({ app: { features: { tenantApiKeys: false } } } as never);
try {
await loader({ request: new Request("https://app.example.com/acme/settings/api/docs"), params: { tenant: "acme" }, context: {} } as never);
throw new Error("Expected loader to throw");
} catch (error) {
expect(error).toBeInstanceOf(Response);
const response = error as Response;
expect(response.status).toBe(404);
await expect(response.json()).resolves.toEqual({ error: "API keys are not enabled" });
}
expect(getTranslations).toHaveBeenCalledWith(expect.any(Request));
expect(ApiSpecsService.generateSpecs).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,61 @@
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getTranslations } from "~/locale/i18next.server";
import ApiSpecs from "~/modules/api/components/ApiSpecs";
import ApiSpecsService, { ApiSpecsDto } from "~/modules/api/services/ApiSpecsService";
import UrlUtils from "~/utils/app/UrlUtils";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
type LoaderData = {
apiSpecs: ApiSpecsDto;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.apiKeys.view", tenantId);
const appConfiguration = await getAppConfiguration({ request });
if (!appConfiguration.app.features.tenantApiKeys) {
throw Response.json({ error: t("settings.api.errors.tenantApiKeysNotEnabled") }, { status: 404 });
}
const apiSpecs = await ApiSpecsService.generateSpecs({ request });
const data: LoaderData = {
apiSpecs,
};
return data;
};
export default function AdminApiDocsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<>
<EditPageLayout
tabs={[
{
name: t("shared.overview"),
routePath: UrlUtils.getModulePath(params, "api"),
},
{
name: t("models.apiCall.plural"),
routePath: UrlUtils.getModulePath(params, "api/logs"),
},
{
name: t("models.apiKey.plural"),
routePath: UrlUtils.getModulePath(params, "api/keys"),
},
{
name: t("docs.title"),
routePath: UrlUtils.getModulePath(params, "api/docs"),
},
]}
>
<ApiSpecs item={data.apiSpecs} postmanCollectionUrl={null} showPostmanCollection={false} />
</EditPageLayout>
</>
);
}
@@ -0,0 +1,55 @@
import type { LoaderFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("~/modules/api/services/ApiKeyLogService", () => ({
default: {
getSummary: vi.fn(async () => ({ items: [], filterableProperties: [] })),
},
}));
vi.mock("~/utils/db/appConfiguration.db.server", () => ({
getAppConfiguration: vi.fn(async () => ({ app: { features: { tenantApiKeys: true } } })),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: vi.fn(async () => undefined) }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn(async () => "tenant-1") }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string) => (key === "settings.api.errors.tenantApiKeysNotEnabled" ? "API keys are not enabled" : key),
})),
}));
import ApiKeyLogService from "~/modules/api/services/ApiKeyLogService";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { loader } from "./index";
describe("tenant API settings overview route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(getAppConfiguration).mockResolvedValue({ app: { features: { tenantApiKeys: true } } } as never);
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
});
it("checks tenant permission and feature gate before loading API key logs", async () => {
const request = new Request("https://app.example.com/acme/settings/api");
const data = await loader({ request, params: { tenant: "acme" }, context: {} } as unknown as LoaderFunctionArgs);
expect(getTenantIdFromUrl).toHaveBeenCalledWith({ tenant: "acme" });
expect(verifyUserHasPermission).toHaveBeenCalledWith(request, "app.settings.apiKeys.view", "tenant-1");
expect(ApiKeyLogService.getSummary).toHaveBeenCalledWith({ request, params: { tenant: "acme" } });
expect(data).toMatchObject({ items: [], filterableProperties: [] });
});
it("returns an i18n key when tenant API keys are disabled", async () => {
vi.mocked(getAppConfiguration).mockResolvedValue({ app: { features: { tenantApiKeys: false } } } as never);
const response = await loader({ request: new Request("https://app.example.com/acme/settings/api"), params: { tenant: "acme" }, context: {} } as never);
expect(response).toBeInstanceOf(Response);
expect((response as Response).status).toBe(400);
await expect((response as Response).json()).resolves.toEqual({ error: "settings.api.errors.tenantApiKeysNotEnabled" });
expect(ApiKeyLogService.getSummary).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,88 @@
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { Link, useParams } from "react-router";
import { Fragment } from "react";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import ErrorBanner from "~/components/ui/banners/ErrorBanner";
import ServerError from "~/components/ui/errors/ServerError";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import ApiKeyLogsSummary from "~/modules/api/components/ApiKeyLogsSummary";
import { ApiCallSummaryDto } from "~/modules/api/dtos/ApiCallSummaryDto";
import ApiKeyLogService from "~/modules/api/services/ApiKeyLogService";
import UrlUtils from "~/utils/app/UrlUtils";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
type LoaderData =
| { error: string }
| {
items: ApiCallSummaryDto[];
allTenants: { id: string; name: string }[];
filterableProperties: FilterablePropertyDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.apiKeys.view", tenantId);
try {
const appConfiguration = await getAppConfiguration({ request });
if (!appConfiguration.app.features.tenantApiKeys) {
return Response.json({ error: "settings.api.errors.tenantApiKeysNotEnabled" }, { status: 400 });
}
const { items, filterableProperties } = await ApiKeyLogService.getSummary({ request, params });
const data: LoaderData = {
items,
allTenants: [],
filterableProperties,
};
return data;
} catch (error) {
// eslint-disable-next-line no-console
console.error(error);
return Response.json({ error: "shared.unexpectedError" }, { status: 400 });
}
};
export default function () {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
tabs={[
{
name: t("shared.overview"),
routePath: UrlUtils.getModulePath(params, "api"),
},
{
name: t("models.apiCall.plural"),
routePath: UrlUtils.getModulePath(params, "api/logs"),
},
{
name: t("models.apiKey.plural"),
routePath: UrlUtils.getModulePath(params, "api/keys"),
},
{
name: t("docs.title"),
routePath: UrlUtils.getModulePath(params, "api/docs"),
},
]}
>
{"error" in data ? (
<ErrorBanner title={t(data.error)}>
<Link to="." className="underline">
{t("shared.clickHereToTryAgain")}
</Link>
</ErrorBanner>
) : (
<Fragment>
<ApiKeyLogsSummary data={data} />
</Fragment>
)}
</EditPageLayout>
);
}
export function ErrorBoundary() {
return <ServerError />;
}
@@ -0,0 +1,48 @@
import { LoaderFunctionArgs, Outlet, useLoaderData, useParams } from "react-router";
import { useTranslation } from "react-i18next";
import ApiKeysTable from "~/components/core/apiKeys/ApiKeysTable";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppData } from "~/utils/data/useAppData";
import { RedactedApiKeyWithDetails, getApiKeys } from "~/utils/db/apiKeys.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
type LoaderData = {
apiKeys: RedactedApiKeyWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.apiKeys.view", tenantId);
const data: LoaderData = {
apiKeys: await getApiKeys(tenantId),
};
return data;
};
export default function ApiKeysRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const appData = useAppData();
const params = useParams();
return (
<EditPageLayout
tabs={[
{ name: t("shared.overview"), routePath: UrlUtils.getModulePath(params, "api") },
{ name: t("models.apiCall.plural"), routePath: UrlUtils.getModulePath(params, "api/logs") },
{ name: t("models.apiKey.plural"), routePath: UrlUtils.getModulePath(params, "api/keys") },
{ name: t("docs.title"), routePath: UrlUtils.getModulePath(params, "api/docs") },
]}
>
<ApiKeysTable
canCreate={getUserHasPermission(appData, "app.settings.apiKeys.create")}
entities={appData.entities}
items={data.apiKeys}
/>
<Outlet />
</EditPageLayout>
);
}
@@ -0,0 +1,225 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } from "react-router";
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenant: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: vi.fn(),
}));
vi.mock("~/utils/db/apiKeys.db.server", () => ({
countApiKeyLogsForKey: vi.fn(),
deleteApiKey: vi.fn(),
getApiKeys: vi.fn(),
getTenantApiKeyById: vi.fn(),
rotateApiKey: vi.fn(),
updateApiKey: vi.fn(),
}));
vi.mock("~/utils/db/logs.db.server", () => ({
createLog: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/ApiKeyHelperService", () => ({
getApiKeyEntityPermissions: vi.fn(),
}));
vi.mock("~/modules/events/services/.server/EventsService", () => ({
default: { create: vi.fn() },
}));
vi.mock("~/utils/app/UrlUtils", () => ({
default: { currentTenantUrl: vi.fn((_params: Record<string, string | undefined>, path: string) => `/acme/${path}`) },
}));
vi.mock("~/components/core/apiKeys/ApiKeyCreatedModal", () => ({ default: () => null }));
vi.mock("~/components/core/apiKeys/ApiKeyForm", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/OpenModal", () => ({ default: ({ children }: { children: React.ReactNode }) => children }));
vi.mock("~/utils/data/useAppData", () => ({ useAppData: () => ({ entities: [] }) }));
vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getUserHasPermission: vi.fn(() => true) }));
import EventsService from "~/modules/events/services/.server/EventsService";
import { getTranslations } from "~/locale/i18next.server";
import { countApiKeyLogsForKey, deleteApiKey, getApiKeys, getTenantApiKeyById, rotateApiKey, updateApiKey } from "~/utils/db/apiKeys.db.server";
import { createLog } from "~/utils/db/logs.db.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { getUser } from "~/utils/db/users.db.server";
import { getApiKeyEntityPermissions } from "~/utils/helpers/.server/ApiKeyHelperService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { action } from "./$id";
const params = { tenant: "acme", id: "api-key-1" };
const tenant = { id: "tenant-1", name: "Acme", slug: "acme" };
const user = { id: "user-1", email: "ada@example.test" };
const entityPermission = { entityId: "entity-1", create: true, read: true, update: false, delete: false };
const existingApiKey = {
id: "api-key-1",
tenantId: "tenant-1",
alias: "Primary integration",
expires: null,
active: true,
entities: [entityPermission],
};
const rotatedApiKey = { ...existingApiKey, key: "tc_live_rotated_plaintext_once" };
function createRequest(form: FormData) {
return new Request("https://app.example.test/acme/settings/api/keys/api-key-1", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
});
}
function createForm(actionName: "edit" | "delete" | "rotate" = "edit", overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", actionName);
form.set("alias", "Primary integration updated");
form.set("active", "on");
form.append("entities[]", JSON.stringify(entityPermission));
Object.entries(overrides).forEach(([key, value]) => form.set(key, value));
return form;
}
async function callAction(form: FormData) {
return action({
request: createRequest(form),
params,
context: {},
unstable_pattern: "app.$tenant/settings/api/keys/$id",
} as ActionFunctionArgs) as Promise<Response>;
}
async function responseJson(response: Response) {
return response.json() as Promise<Record<string, unknown>>;
}
describe("tenant API key edit route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTranslations).mockResolvedValue({ t: (key: string) => `translated:${key}` } as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue({ userId: "user-1" } as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(getTenant).mockResolvedValue(tenant as never);
vi.mocked(getUser).mockResolvedValue(user as never);
vi.mocked(getTenantApiKeyById).mockResolvedValue(existingApiKey as never);
vi.mocked(getApiKeys).mockResolvedValue([existingApiKey] as never);
vi.mocked(updateApiKey).mockResolvedValue({ ...existingApiKey, alias: "Primary integration updated" } as never);
vi.mocked(rotateApiKey).mockResolvedValue(rotatedApiKey as never);
vi.mocked(deleteApiKey).mockResolvedValue(existingApiKey as never);
vi.mocked(countApiKeyLogsForKey).mockResolvedValue(0 as never);
vi.mocked(getApiKeyEntityPermissions).mockImplementation(async (permissions) => permissions as never);
vi.mocked(EventsService.create).mockResolvedValue(undefined as never);
vi.mocked(createLog).mockResolvedValue({} as never);
});
it("rejects keys outside the tenant scope before update, rotation, or delete", async () => {
vi.mocked(getTenantApiKeyById).mockResolvedValue(null as never);
for (const actionName of ["edit", "rotate", "delete"] as const) {
const response = await callAction(createForm(actionName));
const data = await responseJson(response);
expect(response.status).toBe(400);
expect(data).toEqual({ error: "translated:shared.notFound" });
}
expect(updateApiKey).not.toHaveBeenCalled();
expect(rotateApiKey).not.toHaveBeenCalled();
expect(deleteApiKey).not.toHaveBeenCalled();
});
it("returns one-time plaintext only after successful rotation", async () => {
const response = await callAction(createForm("rotate"));
const data = await responseJson(response);
expect(response.status).toBe(200);
expect(data).toEqual({ apiKey: { key: rotatedApiKey.key, alias: rotatedApiKey.alias } });
expect(rotateApiKey).toHaveBeenCalledWith("api-key-1", "tenant-1");
expect(createLog).toHaveBeenCalledWith(
expect.any(Request),
"tenant-1",
"settings.apiKeys.rotated",
expect.stringContaining('"alias":"Primary integration"')
);
expect(updateApiKey).not.toHaveBeenCalled();
expect(deleteApiKey).not.toHaveBeenCalled();
});
it("checks delete permission only for delete actions", async () => {
await callAction(createForm("edit"));
await callAction(createForm("rotate"));
await callAction(createForm("delete"));
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.apiKeys.update", "tenant-1");
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.apiKeys.delete", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.calls.filter((call) => call[1] === "app.settings.apiKeys.delete")).toHaveLength(1);
});
it("checks delete permission before probing delete usage logs", async () => {
vi.mocked(verifyUserHasPermission).mockImplementation(async (_request, permission) => {
if (permission === "app.settings.apiKeys.delete") {
throw new Response("Forbidden", { status: 403 });
}
return true;
});
await expect(callAction(createForm("delete"))).rejects.toMatchObject({ status: 403 });
expect(countApiKeyLogsForKey).not.toHaveBeenCalled();
expect(deleteApiKey).not.toHaveBeenCalled();
});
it("scopes delete usage-log checks to the current tenant", async () => {
const response = await callAction(createForm("delete"));
expect(response.status).toBe(302);
expect(countApiKeyLogsForKey).toHaveBeenCalledWith("api-key-1", "tenant-1");
expect(deleteApiKey).toHaveBeenCalledWith("api-key-1", "tenant-1");
expect(createLog).toHaveBeenCalledWith(expect.any(Request), "tenant-1", "settings.apiKeys.deleted", "");
});
it("preserves edited scope changes in logs and events", async () => {
const response = await callAction(createForm("edit", { alias: "Primary integration updated" }));
expect(response.status).toBe(302);
expect(updateApiKey).toHaveBeenCalledWith(
"api-key-1",
{
tenantId: "tenant-1",
alias: "Primary integration updated",
expires: null,
active: true,
},
[entityPermission]
);
expect(createLog).toHaveBeenCalledWith(
expect.any(Request),
"tenant-1",
"settings.apiKeys.updated",
expect.stringContaining('"entities":[{"entityId":"entity-1","create":true,"read":true,"update":false,"delete":false}]')
);
expect(createLog).toHaveBeenCalledTimes(1);
expect(EventsService.create).toHaveBeenCalledWith(
expect.objectContaining({
event: "api_key.updated",
data: expect.objectContaining({
new: expect.objectContaining({ entities: [entityPermission] }),
old: expect.objectContaining({ entities: [entityPermission] }),
}),
})
);
});
});
@@ -0,0 +1,198 @@
import { ActionFunction, LoaderFunctionArgs, redirect, useActionData, useLoaderData } from "react-router";
import { useNavigate, useParams } from "react-router";
import ApiKeyCreatedModal from "~/components/core/apiKeys/ApiKeyCreatedModal";
import ApiKeyForm from "~/components/core/apiKeys/ApiKeyForm";
import OpenModal from "~/components/ui/modals/OpenModal";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppData } from "~/utils/data/useAppData";
import {
RedactedApiKeyWithDetails,
countApiKeyLogsForKey,
deleteApiKey,
getApiKeys,
getTenantApiKeyById,
rotateApiKey,
updateApiKey,
} from "~/utils/db/apiKeys.db.server";
import { createLog } from "~/utils/db/logs.db.server";
import { getUser } from "~/utils/db/users.db.server";
import { getApiKeyEntityPermissions } from "~/utils/helpers/.server/ApiKeyHelperService";
import EventsService from "~/modules/events/services/.server/EventsService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { ApiKeyUpdatedDto } from "~/modules/events/dtos/ApiKeyUpdatedDto";
import { getTenant } from "~/utils/db/tenants.db.server";
import { ApiKeyDeletedDto } from "~/modules/events/dtos/ApiKeyDeletedDto";
type LoaderData = {
item: RedactedApiKeyWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.apiKeys.update", tenantId);
const item = await getTenantApiKeyById(params.id ?? "", tenantId);
if (!item) {
return redirect(UrlUtils.currentTenantUrl(params, "settings/api/keys"));
}
const data: LoaderData = {
item,
};
return data;
};
type ActionData = {
error?: string;
apiKey?: {
key: string;
alias: 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);
const userInfo = await getUserInfo(request);
const currentUser = await getUser(userInfo.userId);
const tenant = await getTenant(tenantId);
if (!tenant || !currentUser) {
return badRequest({ error: t("shared.notFound") });
}
await verifyUserHasPermission(request, "app.settings.apiKeys.update", tenantId);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const existing = await getTenantApiKeyById(params.id ?? "", tenantId);
if (!existing) {
return badRequest({ error: t("shared.notFound") });
}
if (action === "edit") {
const entities: { entityId: string; create: boolean; read: boolean; update: boolean; delete: boolean }[] = form
.getAll("entities[]")
.map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
let expirationDate: Date | null = null;
let expires = form.get("expires")?.toString();
if (expires) {
expirationDate = new Date(expires);
}
const alias = form.get("alias")?.toString() ?? "";
const existingAlias = await getApiKeys(existing.tenantId);
if (existingAlias.filter((f) => f.id !== existing.id && f.alias === alias).length > 0) {
return badRequest({ error: t("models.apiKey.errors.aliasExists", { alias }) });
}
const active = Boolean(form.get("active"));
await updateApiKey(
params.id ?? "",
{
tenantId: tenantId,
alias,
expires: expirationDate,
active,
},
entities
);
await createLog(request, tenantId, "settings.apiKeys.updated", JSON.stringify({ tenantId, alias, expirationDate, active, entities }));
await EventsService.create({
request,
event: "api_key.updated",
tenantId: tenant.id,
userId: currentUser.id,
data: {
id: existing.id,
new: {
alias: alias,
expires: expirationDate,
active: active,
entities: await getApiKeyEntityPermissions(entities),
},
old: {
alias: existing.alias,
expires: existing.expires,
active: existing.active,
entities: await getApiKeyEntityPermissions(existing.entities),
},
user: { id: currentUser?.id ?? "", email: currentUser?.email ?? "" },
} satisfies ApiKeyUpdatedDto,
});
return redirect(UrlUtils.currentTenantUrl(params, "settings/api/keys"));
} else if (action === "rotate") {
const apiKey = await rotateApiKey(existing.id, tenantId);
await createLog(request, tenantId, "settings.apiKeys.rotated", JSON.stringify({ tenantId, alias: existing.alias }));
await EventsService.create({
request,
event: "api_key.updated",
tenantId: tenant.id,
userId: currentUser.id,
data: {
id: existing.id,
new: {
alias: existing.alias,
expires: existing.expires,
active: existing.active,
entities: await getApiKeyEntityPermissions(existing.entities),
},
old: {
alias: existing.alias,
expires: existing.expires,
active: existing.active,
entities: await getApiKeyEntityPermissions(existing.entities),
},
user: { id: currentUser?.id ?? "", email: currentUser?.email ?? "" },
} satisfies ApiKeyUpdatedDto,
});
return Response.json({ apiKey: { key: apiKey.key, alias: apiKey.alias } } satisfies ActionData);
} else if (action === "delete") {
await verifyUserHasPermission(request, "app.settings.apiKeys.delete", tenantId);
const logs = await countApiKeyLogsForKey(params.id ?? "", tenantId);
if (logs > 0) {
return badRequest({ error: t("models.apiKey.errors.cannotDeleteUsed") });
}
await deleteApiKey(params.id ?? "", tenantId);
await createLog(request, tenantId, "settings.apiKeys.deleted", "");
await EventsService.create({
request,
event: "api_key.deleted",
tenantId: tenant.id,
userId: currentUser.id,
data: {
id: existing.id,
alias: existing.alias,
expires: existing.expires,
active: existing.active,
entities: await getApiKeyEntityPermissions(existing.entities),
user: { id: currentUser?.id ?? "", email: currentUser?.email ?? "" },
} satisfies ApiKeyDeletedDto,
});
return redirect(UrlUtils.currentTenantUrl(params, "settings/api/keys"));
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export default function ApiEditKeyRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const navigate = useNavigate();
const appData = useAppData();
const params = useParams();
return (
<>
<OpenModal className="sm:max-w-xl" onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/api/keys"))}>
<ApiKeyForm
entities={appData.entities}
item={data.item}
canUpdate={getUserHasPermission(appData, "app.settings.apiKeys.update")}
canDelete={getUserHasPermission(appData, "app.settings.apiKeys.delete")}
canRotate={getUserHasPermission(appData, "app.settings.apiKeys.update")}
/>
{actionData?.apiKey !== undefined && (
<ApiKeyCreatedModal apiKey={actionData?.apiKey} redirectTo={UrlUtils.currentTenantUrl(params, "settings/api/keys")} action="rotated" />
)}
</OpenModal>
</>
);
}
@@ -0,0 +1,169 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } from "react-router";
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenant: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: vi.fn(),
}));
vi.mock("~/utils/db/apiKeys.db.server", () => ({
createApiKey: vi.fn(),
getApiKeyByAlias: vi.fn(),
}));
vi.mock("~/utils/db/logs.db.server", () => ({
createLog: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/ApiKeyHelperService", () => ({
getApiKeyEntityPermissions: vi.fn(),
}));
vi.mock("~/modules/events/services/.server/EventsService", () => ({
default: { create: vi.fn() },
}));
vi.mock("~/utils/app/UrlUtils", () => ({
default: { currentTenantUrl: vi.fn((_params: Record<string, string | undefined>, path: string) => `/acme/${path}`) },
}));
vi.mock("~/components/core/apiKeys/ApiKeyCreatedModal", () => ({ default: () => null }));
vi.mock("~/components/core/apiKeys/ApiKeyForm", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/OpenModal", () => ({ default: ({ children }: { children: React.ReactNode }) => children }));
vi.mock("~/utils/data/useAppData", () => ({ useAppData: () => ({ entities: [] }) }));
import EventsService from "~/modules/events/services/.server/EventsService";
import { getTranslations } from "~/locale/i18next.server";
import { createApiKey, getApiKeyByAlias } from "~/utils/db/apiKeys.db.server";
import { createLog } from "~/utils/db/logs.db.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { getUser } from "~/utils/db/users.db.server";
import { getApiKeyEntityPermissions } from "~/utils/helpers/.server/ApiKeyHelperService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { action } from "./new";
const params = { tenant: "acme" };
const tenant = { id: "tenant-1", name: "Acme", slug: "acme" };
const user = { id: "user-1", email: "ada@example.test" };
const apiKey = {
id: "api-key-1",
alias: "Primary integration",
key: "tc_live_plaintext_secret_once",
active: true,
};
const entityPermission = { entityId: "entity-1", create: true, read: true, update: false, delete: false };
function createRequest(form: FormData) {
return new Request("https://app.example.test/acme/settings/api/keys/new", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
});
}
function createForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", "create");
form.set("alias", "Primary integration");
form.set("active", "on");
form.append("entities[]", JSON.stringify(entityPermission));
Object.entries(overrides).forEach(([key, value]) => form.set(key, value));
return form;
}
async function callAction(form: FormData) {
return action({
request: createRequest(form),
params,
context: {},
unstable_pattern: "app.$tenant/settings/api/keys/new",
} as ActionFunctionArgs) as Promise<Response>;
}
async function responseJson(response: Response) {
return response.json() as Promise<Record<string, unknown>>;
}
describe("tenant API key create route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTranslations).mockResolvedValue({
t: (key: string, values?: Record<string, unknown>) =>
key === "models.apiKey.errors.aliasExists" ? `API key with this alias already exists: ${values?.alias}` : `translated:${key}`,
} as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue({ userId: "user-1" } as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(getTenant).mockResolvedValue(tenant as never);
vi.mocked(getUser).mockResolvedValue(user as never);
vi.mocked(getApiKeyByAlias).mockResolvedValue(null as never);
vi.mocked(createApiKey).mockResolvedValue(apiKey as never);
vi.mocked(getApiKeyEntityPermissions).mockResolvedValue([entityPermission] as never);
vi.mocked(EventsService.create).mockResolvedValue(undefined as never);
vi.mocked(createLog).mockResolvedValue({} as never);
});
it("checks create permission before creating a key", async () => {
const response = await callAction(createForm());
expect(response.status).toBe(200);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.apiKeys.create", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(createApiKey).mock.invocationCallOrder[0]);
});
it("returns one-time plaintext only in successful create action JSON", async () => {
const response = await callAction(createForm());
const data = await responseJson(response);
expect(response.status).toBe(200);
expect(data).toEqual({ apiKey: { key: apiKey.key, alias: apiKey.alias } });
expect(createApiKey).toHaveBeenCalledTimes(1);
expect(EventsService.create).toHaveBeenCalledTimes(1);
expect(createLog).toHaveBeenCalledWith(
expect.any(Request),
"tenant-1",
"settings.apiKeys.created",
expect.stringContaining('"alias":"Primary integration"')
);
expect(createLog).toHaveBeenCalledTimes(1);
});
it("rejects duplicate aliases without creating or leaking generated key material", async () => {
vi.mocked(getApiKeyByAlias).mockResolvedValueOnce({ id: "existing-key", alias: "Primary integration" } as never);
const response = await callAction(createForm());
const data = await responseJson(response);
expect(response.status).toBe(400);
expect(data).toEqual({ error: "API key with this alias already exists: Primary integration" });
expect(JSON.stringify(data)).not.toContain(apiKey.key);
expect(createApiKey).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
expect(createLog).not.toHaveBeenCalled();
});
it("rejects invalid actions without creating or leaking generated key material", async () => {
const response = await callAction(createForm({ action: "rotate" }));
const data = await responseJson(response);
expect(response.status).toBe(400);
expect(data).toEqual({ error: "translated:shared.invalidForm" });
expect(JSON.stringify(data)).not.toContain(apiKey.key);
expect(createApiKey).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
expect(createLog).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,113 @@
import { ActionFunction, LoaderFunctionArgs } from "react-router";
import { useActionData, useNavigate, useParams } from "react-router";
import ApiKeyCreatedModal from "~/components/core/apiKeys/ApiKeyCreatedModal";
import ApiKeyForm from "~/components/core/apiKeys/ApiKeyForm";
import OpenModal from "~/components/ui/modals/OpenModal";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppData } from "~/utils/data/useAppData";
import { createApiKey, getApiKeyByAlias } from "~/utils/db/apiKeys.db.server";
import { createLog } from "~/utils/db/logs.db.server";
import { getUser } from "~/utils/db/users.db.server";
import { getApiKeyEntityPermissions } from "~/utils/helpers/.server/ApiKeyHelperService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import EventsService from "~/modules/events/services/.server/EventsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { ApiKeyCreatedDto } from "~/modules/events/dtos/ApiKeyCreatedDto";
import { getTenant } from "~/utils/db/tenants.db.server";
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.apiKeys.create", tenantId);
return Response.json({});
};
type ActionData = {
error?: string;
apiKey?: {
key: string;
alias: 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.apiKeys.create", tenantId);
await validateCSRFToken(request);
const userInfo = await getUserInfo(request);
const tenant = await getTenant(tenantId);
const currentUser = await getUser(userInfo.userId);
if (!tenant || !currentUser) {
return badRequest({ error: t("shared.notFound") });
}
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "create") {
const entities: { entityId: string; create: boolean; read: boolean; update: boolean; delete: boolean }[] = form
.getAll("entities[]")
.map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
let expirationDate: Date | null = null;
let expires = form.get("expires")?.toString();
if (expires) {
expirationDate = new Date(expires);
}
const alias = form.get("alias")?.toString() ?? "";
const existingAlias = await getApiKeyByAlias(tenantId, alias);
if (existingAlias) {
return badRequest({ error: t("models.apiKey.errors.aliasExists", { alias }) });
}
const active = Boolean(form.get("active"));
const apiKey = await createApiKey(
{
tenantId: tenantId,
createdByUserId: userInfo.userId,
alias,
expires: expirationDate,
active,
},
entities
);
await EventsService.create({
request,
event: "api_key.created",
tenantId: tenantId,
userId: currentUser.id,
data: {
id: apiKey.id,
alias: apiKey.alias,
expires: expirationDate,
active: active,
entities: await getApiKeyEntityPermissions(entities),
user: { id: currentUser?.id ?? "", email: currentUser?.email ?? "" },
} satisfies ApiKeyCreatedDto,
});
await createLog(request, tenantId, "settings.apiKeys.created", JSON.stringify({ id: apiKey.id, alias, expirationDate, active, entities }));
return Response.json({ apiKey: { key: apiKey.key, alias: apiKey.alias } } satisfies ActionData);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export default function ApiNewKeyRoute() {
const navigate = useNavigate();
const actionData = useActionData<ActionData>();
const params = useParams();
const appData = useAppData();
return (
<>
<OpenModal className="sm:max-w-xl" onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/api/keys"))}>
<ApiKeyForm entities={appData.entities} />
{actionData?.apiKey !== undefined && (
<ApiKeyCreatedModal apiKey={actionData?.apiKey} redirectTo={UrlUtils.currentTenantUrl(params, "settings/api/keys")} />
)}
</OpenModal>
</>
);
}
@@ -0,0 +1,59 @@
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import ApiKeyLogsDetails from "~/modules/api/components/ApiKeyLogsDetails";
import { ApiKeyLogDto } from "~/modules/api/dtos/ApiKeyLogDto";
import ApiKeyLogService from "~/modules/api/services/ApiKeyLogService";
import UrlUtils from "~/utils/app/UrlUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
type LoaderData = {
items: ApiKeyLogDto[];
filterableProperties: FilterablePropertyDto[];
pagination: PaginationDto;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.apiKeys.view", tenantId);
const { items, filterableProperties, pagination } = await ApiKeyLogService.getDetails({ request, params });
const data: LoaderData = {
items,
filterableProperties,
pagination,
};
return data;
};
export default function AdminApiLogsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
tabs={[
{
name: t("shared.overview"),
routePath: UrlUtils.getModulePath(params, "api"),
},
{
name: t("models.apiCall.plural"),
routePath: UrlUtils.getModulePath(params, "api/logs"),
},
{
name: t("models.apiKey.plural"),
routePath: UrlUtils.getModulePath(params, "api/keys"),
},
{
name: t("docs.title"),
routePath: UrlUtils.getModulePath(params, "api/docs"),
},
]}
>
<ApiKeyLogsDetails data={data} />
</EditPageLayout>
);
}
@@ -0,0 +1,18 @@
import fs from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
const sourcePath = path.resolve(process.cwd(), "apps/web/app/routes/app.$tenant/settings/audit-export.tsx");
describe("tenant audit export i18n", () => {
it("uses semantic keys for filter option labels", () => {
const source = fs.readFileSync(sourcePath, "utf8");
expect(source).toContain("auditExport.scopes.soc2");
expect(source).toContain("auditExport.actorTypes.apiKey");
expect(source).not.toContain(">soc2<");
expect(source).not.toContain(">gdpr<");
expect(source).not.toContain(">api_key<");
});
});
@@ -0,0 +1,85 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./audit-export";
import { getDbClient } from "@toolctrl/db/client.server";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
vi.mock("@toolctrl/db/client.server", () => ({
getDbClient: vi.fn(),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
const params = { tenant: "acme" };
const findMany = vi.fn();
function callLoader(url: string) {
const request = new Request(url);
return loader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/audit-export" } as LoaderFunctionArgs);
}
describe("tenant audit export route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "ToolCTRL";
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTranslations).mockResolvedValue({ t: (key: string) => `translated:${key}` } as never);
findMany.mockResolvedValue([]);
vi.mocked(getDbClient).mockReturnValue({ auditEvent: { findMany } } as never);
});
it("checks tenant audit-trail permission before returning export defaults", async () => {
const response = (await callLoader("https://app.example.test/acme/settings/audit-export")) as Response;
const data = await response.json();
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(findMany).not.toHaveBeenCalled();
expect(data).toMatchObject({
title: "translated:models.log.plural | ToolCTRL",
tenantSlug: "acme",
maxRows: expect.any(Number),
});
});
it("keeps CSV export tenant-scoped and permission-gated", async () => {
const response = (await callLoader(
"https://app.example.test/acme/settings/audit-export?export=csv&tenantId=other-tenant&from=2026-05-01&to=2026-05-31",
)) as Response;
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(findMany.mock.invocationCallOrder[0]);
expect(findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: expect.objectContaining({ tenantId: "tenant-1" }),
orderBy: { createdAt: "asc" },
}),
);
expect(JSON.stringify(findMany.mock.calls[0]?.[0])).not.toContain("other-tenant");
expect(response.headers.get("Content-Type")).toBe("text/csv; charset=utf-8");
expect(response.headers.get("Content-Disposition")).toContain("audit-export-tenant-1-2026-05-01_2026-05-31.csv");
});
it("rejects export reads without touching audit rows when permission is missing", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader("https://app.example.test/acme/settings/audit-export?export=csv")).rejects.toBe(rejection);
expect(findMany).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,167 @@
/**
* Phase 10 Task #67 — Tenant Compliance-Audit-Export.
*
* Per-tenant self-service variant of the admin audit-export. Identical
* filter surface but tenantId-locked: a tenant admin can only see their
* own AuditEvent rows. Used for SOC2-Type-II evidence collection by
* tenants who need to deliver their own privileged-action report.
*/
import type { LoaderFunctionArgs } from "react-router";
import { useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { getDbClient } from "@toolctrl/db/client.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getTranslations } from "~/locale/i18next.server";
import { useLocaleFormatters } from "~/locale/format";
import { AUDIT_EXPORT_MAX_ROWS, buildAuditExportWhere, computeAuditIntegritySummary, parseAuditExportFilters, renderAuditExportCsv, type AuditExportRow } from "~/routes/admin/audit-export.helpers.server";
import { buildAuditPdfLabels, renderAuditExportPdfResponse } from "~/utils/audit/pdfRender";
type LoaderData = {
title: string;
tenantSlug: string;
defaultFrom: string;
defaultTo: string;
maxRows: number;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const { t } = await getTranslations(request);
const url = new URL(request.url);
if (url.searchParams.get("export") === "csv") {
return streamTenantAuditExport(tenantId, url);
}
if (url.searchParams.get("export") === "pdf" || url.searchParams.get("format") === "pdf") {
return streamTenantAuditPdfExport(tenantId, url, t);
}
const today = new Date();
const fromDate = new Date(today);
fromDate.setDate(fromDate.getDate() - 30);
const data: LoaderData = {
title: `${t("models.log.plural")} | ${process.env.APP_NAME}`,
tenantSlug: params.tenant ?? "",
defaultFrom: fromDate.toISOString().slice(0, 10),
defaultTo: today.toISOString().slice(0, 10),
maxRows: AUDIT_EXPORT_MAX_ROWS,
};
return Response.json(data);
};
async function streamTenantAuditExport(tenantId: string, url: URL): Promise<Response> {
// Force tenantId scope onto the URL filters so a request that tries to
// smuggle a different tenantId via query string is silently ignored.
const filters = { ...parseAuditExportFilters(url), tenantId };
const db = getDbClient();
const rows = (await db.auditEvent.findMany({
where: buildAuditExportWhere(filters),
orderBy: { createdAt: "asc" },
take: AUDIT_EXPORT_MAX_ROWS,
})) as unknown as AuditExportRow[];
const integrity = computeAuditIntegritySummary(rows);
const csv = renderAuditExportCsv(rows, integrity);
return new Response(csv, {
headers: {
"Content-Type": "text/csv; charset=utf-8",
"Content-Disposition": `attachment; filename="audit-export-${tenantId}-${url.searchParams.get("from") ?? "all"}_${url.searchParams.get("to") ?? "all"}.csv"`,
"X-Audit-Chain-Status": integrity.ok ? "ok" : "broken",
},
});
}
async function streamTenantAuditPdfExport(tenantId: string, url: URL, t: Awaited<ReturnType<typeof getTranslations>>["t"]): Promise<Response> {
const filters = { ...parseAuditExportFilters(url), tenantId };
const db = getDbClient();
const rows = (await db.auditEvent.findMany({
where: buildAuditExportWhere(filters),
orderBy: { createdAt: "asc" },
take: AUDIT_EXPORT_MAX_ROWS,
})) as unknown as AuditExportRow[];
const integrity = computeAuditIntegritySummary(rows);
return renderAuditExportPdfResponse(
{
tenantId,
filters,
integrity,
rows,
labels: buildAuditPdfLabels(t),
},
{ filenamePrefix: "audit-export" }
);
}
export default function TenantAuditExportRoute() {
const data = useLoaderData<LoaderData>();
const { t } = useTranslation(["settings", "translations"]);
const formatters = useLocaleFormatters();
return (
<div data-ui-id="ui.settings.auditExport.page" className="space-y-6 p-6">
<header>
<h1 className="text-xl font-semibold">{t("translations:models.log.plural")}</h1>
<p className="text-sm text-gray-500">
{t(
"auditExport.description",
{ tenantSlug: data.tenantSlug, maxRows: formatters.number(data.maxRows) },
)}
</p>
</header>
<form data-ui-id="ui.settings.auditExport.form" method="get" className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3" action="">
<input type="hidden" name="export" value="csv" />
<label className="text-sm">
<span className="block">{t("auditExport.filters.fromUtc")}</span>
<input data-ui-id="ui.settings.auditExport.from" type="date" name="from" defaultValue={data.defaultFrom} className="mt-1 w-full rounded border px-2 py-1" />
</label>
<label className="text-sm">
<span className="block">{t("auditExport.filters.toUtc")}</span>
<input data-ui-id="ui.settings.auditExport.to" type="date" name="to" defaultValue={data.defaultTo} className="mt-1 w-full rounded border px-2 py-1" />
</label>
<label className="text-sm">
<span className="block">{t("auditExport.filters.regulatoryScope")}</span>
<select data-ui-id="ui.settings.auditExport.regulatoryScope" name="regulatoryScope" className="mt-1 w-full rounded border px-2 py-1" defaultValue="">
<option value="">{t("auditExport.filters.any")}</option>
<option value="soc2">{t("auditExport.scopes.soc2")}</option>
<option value="gdpr">{t("auditExport.scopes.gdpr")}</option>
<option value="hipaa">{t("auditExport.scopes.hipaa")}</option>
<option value="pci">{t("auditExport.scopes.pci")}</option>
</select>
</label>
<label className="text-sm">
<span className="block">{t("auditExport.filters.actorType")}</span>
<select data-ui-id="ui.settings.auditExport.actorType" name="actorType" className="mt-1 w-full rounded border px-2 py-1" defaultValue="">
<option value="">{t("auditExport.filters.any")}</option>
<option value="user">{t("auditExport.actorTypes.user")}</option>
<option value="admin">{t("auditExport.actorTypes.admin")}</option>
<option value="api_key">{t("auditExport.actorTypes.apiKey")}</option>
<option value="system">{t("auditExport.actorTypes.system")}</option>
<option value="plugin">{t("auditExport.actorTypes.plugin")}</option>
</select>
</label>
<label className="text-sm">
<span className="block">{t("auditExport.filters.outcome")}</span>
<select data-ui-id="ui.settings.auditExport.outcome" name="outcome" className="mt-1 w-full rounded border px-2 py-1" defaultValue="">
<option value="">{t("auditExport.filters.any")}</option>
<option value="success">{t("auditExport.outcomes.success")}</option>
<option value="failure">{t("auditExport.outcomes.failure")}</option>
<option value="blocked">{t("auditExport.outcomes.blocked")}</option>
</select>
</label>
<div className="sm:col-span-2 lg:col-span-3 flex flex-wrap gap-3">
<button data-ui-id="ui.settings.auditExport.downloadCsv" type="submit" className="rounded bg-blue-600 px-4 py-2 text-sm font-medium text-white hover:bg-blue-500">
{t("auditExport.downloadCsv")}
</button>
<button
type="submit"
name="export"
value="pdf"
data-ui-id="ui.settings.auditExport.downloadPdf"
className="rounded border border-blue-600 bg-white px-4 py-2 text-sm font-medium text-blue-600 hover:bg-blue-50"
>
{t("auditExport.downloadPdf")}
</button>
</div>
</form>
</div>
);
}
@@ -0,0 +1,78 @@
import { LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { useTranslation } from "react-i18next";
import CreditsList from "~/modules/usage/components/CreditsList";
import { CreditWithDetails, getAllCredits } from "~/modules/usage/db/credits.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { CreditTypes } from "~/modules/usage/dtos/CreditType";
import UrlUtils from "~/utils/app/UrlUtils";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantUsers } from "~/utils/db/tenants.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTranslations } from "~/locale/i18next.server";
type LoaderData = {
items: CreditWithDetails[];
filterableProperties: FilterablePropertyDto[];
pagination: PaginationDto;
canDelete: boolean;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAuth({ request, params });
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.subscription.view", tenantId);
if (CreditTypes.length === 0) {
return redirect(UrlUtils.currentTenantUrl(params, "settings/subscription"));
}
const tenantUsers = await getTenantUsers(tenantId);
const filterableProperties: FilterablePropertyDto[] = [
{
name: "userId",
title: "models.user.object",
options: [
{ value: "null", name: t("models.credit.filters.noUser") },
...tenantUsers.map((item) => {
return {
value: item.user.id,
name: item.user.email,
};
}),
],
},
{
name: "type",
title: "models.credit.type",
options: CreditTypes.map((item) => {
return {
value: item.value,
name: t(item.name),
};
}),
},
];
const urlSearchParams = new URL(request.url).searchParams;
const currentPagination = getPaginationFromCurrentUrl(urlSearchParams);
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const { items, pagination } = await getAllCredits({ tenantId, filters, filterableProperties, pagination: currentPagination });
const data: LoaderData = {
items,
filterableProperties,
pagination,
canDelete: false,
};
return data;
};
export default function () {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
return (
<EditPageLayout title={t("models.credit.plural")}>
<CreditsList data={data} />
</EditPageLayout>
);
}
@@ -0,0 +1,112 @@
import { useTranslation } from "react-i18next";
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { Outlet, useParams } from "react-router";
import { PlusIcon } from "~/components/ui/icons/vendor";
import ButtonTertiary from "~/components/ui/buttons/ButtonTertiary";
import TableSimple from "~/components/ui/tables/TableSimple";
import { EntityWithDetails, getEntityBySlug } from "~/utils/db/entities/entities.db.server";
import { EntityTemplate } from "@toolctrl/db/prisma-browser";
import { getEntityTemplates } from "~/utils/db/entities/entityTemplates.db.server";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import ShowPayloadModalButton from "~/components/ui/json/ShowPayloadModalButton";
import { PropertyType } from "~/application/enums/entities/PropertyType";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UrlUtils from "~/utils/app/UrlUtils";
import { requireAuth } from "~/utils/loaders.middleware";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
type LoaderData = {
entity: EntityWithDetails;
items: EntityTemplate[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const items = await getEntityTemplates(entity.id, { tenantId });
const data: LoaderData = {
entity,
items,
};
return data;
};
export default function EntityTemplatesIndex() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
function getConfig(item: EntityTemplate) {
try {
const config = JSON.parse(item.config);
const values: string[] = [];
data.entity.properties
.filter((f) => !f.isDefault)
.sort((a, b) => a.order - b.order)
.forEach((property) => {
let value = config[property.name];
if (value) {
if (property.type === PropertyType.SELECT) {
const option = property.options.find((f) => f.value === value);
if (option) {
value = option.name || option.value;
}
}
values.push(t(property.title) + ": " + value);
}
});
return values.join(", ");
} catch (e) {
return "";
}
}
return (
<EditPageLayout
title={t(data.entity.titlePlural) + " - " + t("models.entity.templates")}
withHome={false}
menu={[
{
title: t("models.entity.plural"),
routePath: UrlUtils.getModulePath(params, `entities`),
},
{
title: data.entity.titlePlural,
routePath: UrlUtils.getModulePath(params, `entities/${data.entity.slug}/templates`),
},
]}
>
<div className="space-y-3">
<TableSimple
headers={[
{
name: "title",
title: t("models.entityTemplate.title"),
value: (item) => item.title,
},
{
title: t("models.entityTemplate.object"),
name: "template",
className: "max-w-xs",
value: (item) => <ShowPayloadModalButton title={t("models.entityTemplate.templateWithTitle", { title: item.title })} payload={getConfig(item)} />,
},
]}
items={data.items}
actions={[
{
title: t("shared.edit"),
onClickRoute: (idx, item) => item.id,
},
]}
></TableSimple>
<div className="w-fu flex justify-start">
<ButtonTertiary to="new">
<PlusIcon className="h-5 w-5" />
<span className="font-medium uppercase">{t("shared.add")}</span>
</ButtonTertiary>
</div>
</div>
<Outlet />
</EditPageLayout>
);
}
@@ -0,0 +1,90 @@
import { EntityTemplate } from "@toolctrl/db/prisma-browser";
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useNavigate, useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EntityTemplateForm from "~/components/entities/entityTemplates/EntityTemplateForm";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { EntityWithDetails, getEntityBySlug } from "~/utils/db/entities/entities.db.server";
import { deleteScopedEntityTemplate, getEntityTemplate, updateScopedEntityTemplate } from "~/utils/db/entities/entityTemplates.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
entity: EntityWithDetails;
item: EntityTemplate;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const templateScope = { id: params.id ?? "", tenantId, entityId: entity.id };
const item = await getEntityTemplate(templateScope.id, { tenantId, entityId: entity.id });
if (!item) {
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}/templates`));
}
const data: LoaderData = {
entity,
item,
};
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 getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
await validateCSRFToken(request);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const templateScope = { id: params.id ?? "", tenantId, entityId: entity.id };
const existing = await getEntityTemplate(templateScope.id, { tenantId, entityId: entity.id });
if (!existing) {
return badRequest({ error: t("shared.notFound") });
}
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const config = form.get("config")?.toString() ?? "";
if (action === "edit") {
try {
await updateScopedEntityTemplate(templateScope, {
title,
config,
});
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}/templates`));
} catch {
return badRequest({ error: t("models.entityTemplate.errors.updateFailed") });
}
} else if (action === "delete") {
await deleteScopedEntityTemplate(templateScope);
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}/templates`));
}
return badRequest({ error: t("shared.invalidForm") });
};
export default function EditEntityTemplateRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
const navigate = useNavigate();
function close() {
navigate(UrlUtils.getModulePath(params, `entities/${params.entity}/templates`));
}
return (
<SlideOverWideEmpty title={t("models.entityTemplate.edit")} open={true} className="sm:max-w-lg" onClose={close}>
<EntityTemplateForm entity={data.entity} item={data.item} />
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,79 @@
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useNavigate, useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EntityTemplateForm from "~/components/entities/entityTemplates/EntityTemplateForm";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { EntityWithDetails, getEntityBySlug } from "~/utils/db/entities/entities.db.server";
import { createEntityTemplate } from "~/utils/db/entities/entityTemplates.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
title: string;
entity: EntityWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const data: LoaderData = {
title: t("models.entityTemplate.metaTitle", { appName: process.env.APP_NAME }),
entity,
};
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 getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
await validateCSRFToken(request);
const entity = await getEntityBySlug({ tenantId, slug: params.entity! });
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const config = form.get("config")?.toString() ?? "";
if (action === "create") {
try {
await createEntityTemplate({
entityId: entity.id,
tenantId,
title,
config,
});
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}/templates`));
} catch {
return badRequest({ error: t("models.entityTemplate.errors.createFailed") });
}
}
return badRequest({ error: t("shared.invalidForm") });
};
export default function NewEntityTemplateRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
const navigate = useNavigate();
function close() {
navigate(UrlUtils.getModulePath(params, `entities/${params.entity}/templates`));
}
return (
<SlideOverWideEmpty title={t("models.entityTemplate.new")} open={true} className="sm:max-w-lg" onClose={close}>
<EntityTemplateForm entity={data.entity} />
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,158 @@
import { ActionFunction, LoaderFunctionArgs, useLoaderData, useNavigate, useOutlet } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import TenantPropertiesList from "~/components/entities/properties/TenantPropertiesList";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getTranslations } from "~/locale/i18next.server";
import { PropertiesApi } from "~/utils/api/.server/PropertiesApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppData } from "~/utils/data/useAppData";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { PropertyWithDetails, getEntityBySlug, EntityWithDetails, getAllEntities } from "~/utils/db/entities/entities.db.server";
import { deleteScopedProperty, getScopedProperty, updateScopedProperty, updateScopedPropertyOrder } from "~/utils/db/entities/properties.db.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
entity: EntityWithDetails;
properties: PropertyWithDetails[];
allEntities: EntityWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAuth({ request, params });
const appConfiguration = await getAppConfiguration({ request });
if (!appConfiguration.app.features.tenantEntityCustomization) {
throw Error(t("settings.entities.errors.tenantEntityCustomizationNotEnabled"));
}
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const data: LoaderData = {
entity,
properties: entity.properties,
allEntities: await getAllEntities({ tenantId }),
};
return success(data);
};
type ActionData = {
error?: string;
properties?: PropertyWithDetails[];
created?: boolean;
updated?: boolean;
deleted?: boolean;
};
const success = (data: ActionData) => Response.json(data, { status: 200 });
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 getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
await validateCSRFToken(request);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "set-orders") {
const items: { id: string; order: number }[] = form.getAll("orders[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
const allowedPropertyIds = new Set(entity.properties.map((property) => property.id));
if (items.some(({ id }) => !allowedPropertyIds.has(id))) {
return badRequest({ error: t("shared.notFound") });
}
await Promise.all(
items.map(async ({ id, order }) => {
await updateScopedPropertyOrder({ id, tenantId, entityId: entity.id }, Number(order));
})
);
return Response.json({ updated: true });
} else if (action === "delete") {
const id = form.get("id")?.toString() ?? "";
const propertyScope = { id, tenantId, entityId: entity.id };
const existingProperty = await getScopedProperty(propertyScope);
if (!existingProperty) {
return badRequest({ error: t("shared.notFound") });
}
await deleteScopedProperty(propertyScope);
return success({
properties: (await getEntityBySlug({ tenantId, slug: params.entity ?? "" }))?.properties,
deleted: true,
});
// return redirect(adminPath(`entities/${params.entity}/properties`, { mode: "host-aware" }));
} else if (action === "toggle-display") {
const id = form.get("id")?.toString() ?? "";
const propertyScope = { id, tenantId, entityId: entity.id };
const existingProperty = await getScopedProperty(propertyScope);
if (!existingProperty) {
return badRequest({ error: t("shared.notFound") });
}
await updateScopedProperty(propertyScope, {
isDisplay: !existingProperty.isDisplay,
});
return Response.json({});
// return redirect(adminPath(`entities/${params.entity}/properties`, { mode: "host-aware" }));
} else if (action === "duplicate") {
try {
const propertyId = form.get("id")?.toString() ?? "";
const existingProperty = await getScopedProperty({ id: propertyId, tenantId, entityId: entity.id });
if (!existingProperty) {
return badRequest({ error: t("shared.notFound") });
}
await PropertiesApi.duplicate({ entity, propertyId });
return Response.json({ created: true });
} catch {
return badRequest({ error: t("models.property.errors.duplicateFailed") });
}
}
return badRequest({ error: t("shared.invalidForm") });
};
export default function () {
const { t } = useTranslation();
const appData = useAppData();
const data = useLoaderData<LoaderData>();
const navigate = useNavigate();
const outlet = useOutlet();
const params = useParams();
return (
<EditPageLayout
title={`${t(data.entity.title)} - ${t("models.property.plural")}`}
withHome={false}
menu={[
{
title: t("models.entity.plural"),
routePath: UrlUtils.getModulePath(params, `entities`),
},
{
title: data.entity.titlePlural,
routePath: UrlUtils.getModulePath(params, `entities/${data.entity.slug}`),
},
]}
>
<TenantPropertiesList tenantId={appData.currentTenant.id} items={data.properties} />
<SlideOverWideEmpty
title={params.id ? t("shared.edit") : t("shared.new")}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-sm"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
</EditPageLayout>
);
}
@@ -0,0 +1,153 @@
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useNavigate, useParams } from "react-router";
import { PropertyType } from "~/application/enums/entities/PropertyType";
import { Colors } from "~/application/enums/shared/Colors";
import PropertyForm from "~/components/entities/properties/PropertyForm";
import { getTranslations } from "~/locale/i18next.server";
import { getAllFormulas } from "~/modules/formulas/db/formulas.db.server";
import { FormulaDto } from "~/modules/formulas/dtos/FormulaDto";
import FormulaHelpers from "~/modules/formulas/utils/FormulaHelpers";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppOrAdminData } from "~/utils/data/useAppOrAdminData";
import { PropertyWithDetails, EntityWithDetails, getEntityBySlug } from "~/utils/db/entities/entities.db.server";
import {
deleteScopedProperty,
getScopedProperty,
updateScopedProperty,
updateScopedPropertyAttributes,
updateScopedPropertyOptions,
} from "~/utils/db/entities/properties.db.server";
import { validateProperty } from "~/utils/helpers/PropertyHelper";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
entity: EntityWithDetails;
item: PropertyWithDetails;
formulas: FormulaDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const propertyScope = { id: params.id ?? "", tenantId, entityId: entity.id };
const item = await getScopedProperty(propertyScope);
if (!item) {
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}`));
}
const data: LoaderData = {
entity,
item,
formulas: (await getAllFormulas()).map((formula) => FormulaHelpers.getFormulaDto(formula)),
};
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 getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
await validateCSRFToken(request);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const propertyScope = { id: params.id ?? "", tenantId, entityId: entity.id };
const existing = await getScopedProperty(propertyScope);
if (!existing) {
return badRequest({ error: t("shared.notFound") });
}
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const name = form.get("name")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const type = Number(form.get("type")) as PropertyType;
const subtype = form.get("subtype")?.toString() ?? null;
const order = Number(form.get("order"));
let isRequired = Boolean(form.get("is-required"));
const isHidden = Boolean(form.get("is-hidden"));
const isDisplay = Boolean(form.get("is-display"));
const isReadOnly = Boolean(form.get("is-read-only"));
const canUpdate = Boolean(form.get("can-update"));
let showInCreate = Boolean(form.get("show-in-create"));
let formulaId = form.get("formula-id")?.toString() ?? null;
if (["id", "folio", "createdAt", "createdByUser", "sort", "page", "q", "v", "redirect", "tags"].includes(name)) {
return badRequest({ error: t("models.property.errors.reservedName", { name }) });
}
const options: { order: number; value: string; name?: string; color?: Colors }[] = form.getAll("options[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
const attributes: { name: string; value: string }[] = form.getAll("attributes[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
if ([PropertyType.SELECT, PropertyType.MULTI_SELECT].includes(type) && options.length === 0) {
// return badRequest({ error: "Add at least one option" });
}
if (type !== PropertyType.FORMULA) {
formulaId = null;
} else {
isRequired = false;
}
if ([PropertyType.FORMULA].includes(type) && !formulaId) {
return badRequest({ error: t("models.property.errors.selectFormula") });
}
const errors = await validateProperty(name, title, entity.properties, existing, t);
if (errors.length > 0) {
return badRequest({ error: errors.join(", ") });
}
if (action === "edit") {
if (name?.includes(" ")) {
return badRequest({ error: t("models.property.errors.nameNoSpaces") });
}
if (name?.includes("-")) {
return badRequest({ error: t("models.property.errors.nameNoHyphen") });
}
try {
await updateScopedProperty(propertyScope, {
name,
title,
type,
subtype,
order,
isDefault: existing?.isDefault ?? false,
isRequired,
isHidden,
isDisplay,
isReadOnly,
canUpdate,
showInCreate,
formulaId,
});
await updateScopedPropertyOptions(propertyScope, options);
await updateScopedPropertyAttributes(propertyScope, attributes);
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}`));
} catch {
return badRequest({ error: t("models.property.errors.updateFailed") });
}
} else if (action === "delete") {
await deleteScopedProperty(propertyScope);
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}`));
}
return badRequest({ error: t("shared.invalidForm") });
};
export default function EditEntityPropertyRoute() {
const data = useLoaderData<LoaderData>();
const appOrAdminData = useAppOrAdminData();
return <PropertyForm item={data.item} properties={[]} entities={appOrAdminData.entities} formulas={data.formulas} />;
}
@@ -0,0 +1,132 @@
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { PropertyType } from "~/application/enums/entities/PropertyType";
import { Colors } from "~/application/enums/shared/Colors";
import PropertyForm from "~/components/entities/properties/PropertyForm";
import { getTranslations } from "~/locale/i18next.server";
import { getAllFormulas } from "~/modules/formulas/db/formulas.db.server";
import { FormulaDto } from "~/modules/formulas/dtos/FormulaDto";
import FormulaHelpers from "~/modules/formulas/utils/FormulaHelpers";
import { PropertiesApi } from "~/utils/api/.server/PropertiesApi";
import UrlUtils from "~/utils/app/UrlUtils";
import { useAppOrAdminData } from "~/utils/data/useAppOrAdminData";
import { PropertyWithDetails, getEntityBySlug, EntityWithDetails } from "~/utils/db/entities/entities.db.server";
import { validateProperty } from "~/utils/helpers/PropertyHelper";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
entity: EntityWithDetails;
properties: PropertyWithDetails[];
formulas: FormulaDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const data: LoaderData = {
entity,
properties: entity?.properties ?? [],
formulas: (await getAllFormulas()).map((formula) => FormulaHelpers.getFormulaDto(formula)),
};
return success(data);
};
type ActionData = {
error?: string;
properties?: PropertyWithDetails[];
};
const success = (data: ActionData) => Response.json(data, { status: 200 });
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 getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
await validateCSRFToken(request);
const entity = await getEntityBySlug({ tenantId, slug: params.entity ?? "" });
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
const name = form.get("name")?.toString() ?? "";
const title = form.get("title")?.toString() ?? "";
const type = Number(form.get("type")) as PropertyType;
const subtype = form.get("subtype")?.toString() ?? null;
const order = Number(form.get("order"));
const isDefault = Boolean(form.get("is-default"));
let isRequired = Boolean(form.get("is-required"));
const isHidden = Boolean(form.get("is-hidden"));
const isDisplay = Boolean(form.get("is-display"));
const isReadOnly = Boolean(form.get("is-read-only"));
const canUpdate = Boolean(form.get("can-update"));
let showInCreate = Boolean(form.get("show-in-create"));
let formulaId = form.get("formula-id")?.toString() ?? null;
if (["id", "folio", "createdAt", "createdByUser", "sort", "page", "q", "v", "redirect", "tags"].includes(name)) {
return badRequest({ error: t("models.property.errors.reservedName", { name }) });
}
const options: { order: number; value: string; name?: string; color?: Colors }[] = form.getAll("options[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
const attributes: { name: string; value: string }[] = form.getAll("attributes[]").map((f: FormDataEntryValue) => {
return JSON.parse(f.toString());
});
if ([PropertyType.SELECT, PropertyType.MULTI_SELECT].includes(type) && options.length === 0) {
// return badRequest({ error: "Add at least one option" });
}
if (type !== PropertyType.FORMULA) {
formulaId = null;
} else {
isRequired = false;
showInCreate = false;
}
if ([PropertyType.FORMULA].includes(type) && !formulaId) {
return badRequest({ error: t("models.property.errors.selectFormula") });
}
const errors = await validateProperty(name, title, entity.properties, null, t);
if (errors.length > 0) {
return badRequest({ error: errors.join(", ") });
}
if (action === "create") {
try {
await PropertiesApi.create({
entityId: entity.id,
name,
title,
type,
subtype,
order,
isDefault,
isRequired,
isHidden,
isDisplay,
isReadOnly,
canUpdate,
showInCreate,
formulaId,
options,
attributes,
tenantId,
});
return redirect(UrlUtils.getModulePath(params, `entities/${params.entity}`));
} catch {
return badRequest({ error: t("models.property.errors.createFailed") });
}
}
return badRequest({ error: t("shared.invalidForm") });
};
export default function NewEntityPropertyRoute() {
const data = useLoaderData<LoaderData>();
const appOrAdminData = useAppOrAdminData();
return <PropertyForm properties={data.properties} entities={appOrAdminData.entities} formulas={data.formulas} />;
}
@@ -0,0 +1,90 @@
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { Link } from "react-router";
import { useTranslation } from "react-i18next";
import { DefaultEntityTypes } from "~/application/dtos/shared/DefaultEntityTypes";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import TableSimple from "~/components/ui/tables/TableSimple";
import { getTranslations } from "~/locale/i18next.server";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { EntityWithDetails, getAllEntities } from "~/utils/db/entities/entities.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdOrNull } from "~/utils/services/.server/urlService";
type LoaderData = {
allEntities: EntityWithDetails[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
await requireAuth({ request, params });
const appConfiguration = await getAppConfiguration({ request });
if (!appConfiguration.app.features.tenantEntityCustomization) {
throw Error(t("settings.entities.errors.tenantEntityCustomizationNotEnabled"));
}
const tenantId = await getTenantIdOrNull({ request, params });
await verifyUserHasPermission(request, "app.settings.account.update", tenantId);
const allEntities = await getAllEntities({ tenantId, active: true, types: [DefaultEntityTypes.All, DefaultEntityTypes.AppOnly] });
const data: LoaderData = {
allEntities,
};
return data;
};
export default function () {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
return (
<EditPageLayout title={t("models.entity.plural")}>
<div className="space-y-2">
<TableSimple
items={data.allEntities}
actions={[
{
title: t("models.entity.templates"),
onClickRoute: (_, item) => item.slug + "/templates",
},
{
title: t("models.property.plural"),
onClickRoute: (_, item) => item.slug,
},
]}
headers={[
{
name: "title",
title: t("models.entity.title"),
value: (item) => (
<div>
<div className="flex items-center space-x-1">
<Link to={item.slug} className="font-medium hover:underline">
{t(item.titlePlural)}
</Link>
</div>
</div>
),
},
{
name: "properties",
title: t("models.property.plural"),
className: "w-full text-xs",
value: (item) => (
<div className="max-w-xs truncate">
{item.properties.filter((f) => !f.isDefault).length > 0 ? (
<Link className="truncate pb-1 hover:underline" to={item.slug}>
{item.properties
.filter((f) => !f.isDefault)
.map((f) => t(f.title) + (f.isRequired ? "*" : ""))
.join(", ")}
</Link>
) : (
<Link className="text-muted-foreground truncate pb-1 hover:underline" to={item.slug}>
{t("shared.setCustomProperties")}
</Link>
)}
</div>
),
},
]}
/>
</div>
</EditPageLayout>
);
}
@@ -0,0 +1,65 @@
import { LoaderFunctionArgs, MetaFunction, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { Outlet } from "react-router";
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 { getUserInfo } from "~/utils/session.server";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import GroupsListView from "~/modules/users/components/GroupsListView";
import { useRootData } from "~/utils/data/useRootData";
import { useAppData } from "~/utils/data/useAppData";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import InfoBanner from "~/components/ui/banners/InfoBanner";
import { requireAuth } from "~/utils/loaders.middleware";
type LoaderData = {
title: string;
items: GroupWithDetails[];
};
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 { permission, userPermission } = await getUserPermission({
userId: userInfo.userId,
permissionName: "app.settings.groups.full",
tenantId: tenantId,
});
let items: GroupWithDetails[];
if (!permission || userPermission) {
items = await getAllGroups(tenantId);
} else {
items = await getMyGroups(userInfo.userId, tenantId);
}
const data: LoaderData = {
title: `${t("models.group.plural")} | ${process.env.APP_NAME}`,
items,
};
return data;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function RolesRoute() {
const data = useLoaderData<LoaderData>();
const rootData = useRootData();
const appData = useAppData();
const { t } = useTranslation();
return (
<EditPageLayout>
{rootData.featureFlags?.includes("row-groups") ? (
<GroupsListView items={data.items} canManage={getUserHasPermission(appData, "app.settings.groups.full")} />
) : (
<InfoBanner title={t("settings.groups.disabled.title")} text={t("settings.groups.disabled.description")} />
)}
<Outlet />
</EditPageLayout>
);
}
@@ -0,0 +1,135 @@
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 { deleteGroup, getGroup, GroupWithDetails, updateGroup } from "~/utils/db/permissions/groups.db.server";
import { 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/members"));
}
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/members"));
}
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)
);
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 deleteGroup(existing.id, tenantId);
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") });
}
return redirect(UrlUtils.currentTenantUrl(params, "settings/members"));
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function AdminEditGroupRoute() {
const data = useLoaderData<LoaderData>();
const appData = useAppData();
const navigate = useNavigate();
const params = useParams();
const { t } = useTranslation();
return (
<SlideOverWideEmpty
title={t("settings.members.groups.editTitle")}
open={true}
className="sm:max-w-sm"
onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/members"))}
>
<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,93 @@
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 { createGroup } from "~/utils/db/permissions/groups.db.server";
import { createUserGroups } 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 group = await createGroup(data);
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 createUserGroups(
group.id,
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/members"));
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export default function NewGroupRoute() {
const navigate = useNavigate();
const params = useParams();
const data = useLoaderData<LoaderData>();
const { t } = useTranslation();
return (
<SlideOverWideEmpty
title={t("settings.members.groups.createTitle")}
open={true}
className="sm:max-w-sm"
onClose={() => navigate(UrlUtils.currentTenantUrl(params, "settings/members"))}
>
<GroupForm allUsers={data.tenantUsers} />
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,110 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./events.$id";
import { getEvent } from "~/modules/events/db/events.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
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,
Link: () => null,
useLoaderData: () => ({}),
useParams: () => ({ tenant: "acme", id: "event-1" }),
};
});
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/modules/events/components/EventDetails", () => ({ default: () => null }));
vi.mock("~/modules/events/db/events.db.server", () => ({
getEvent: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
const params = { tenant: "acme", id: "event-1" };
const event = {
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "account.created",
data: "{}",
description: null,
createdAt: new Date("2026-05-08T10:00:00.000Z"),
tenant: { id: "tenant-1", name: "Acme", slug: "acme" },
user: { id: "user-1", email: "ada@example.test" },
};
function callLoader(routeParams = params) {
const request = new Request("https://app.example.test/acme/settings/logs/events/event-1");
return loader({ request, params: routeParams, context: {}, unstable_pattern: "app.$tenant/settings/logs/events.$id" } as LoaderFunctionArgs);
}
describe("tenant settings event detail route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getEvent).mockResolvedValue(event as never);
});
it("checks tenant-scoped audit-trail permission before reading the requested event", async () => {
const data = await callLoader();
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getEvent).mock.invocationCallOrder[0]);
expect(getEvent).toHaveBeenCalledWith("event-1", "tenant-1");
expect(data).toEqual({ item: event });
});
it("rejects event detail reads without permission before downstream helper calls", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader()).rejects.toBe(rejection);
expect(getEvent).not.toHaveBeenCalled();
});
it("redirects missing events to the tenant events path after permission", async () => {
vi.mocked(getEvent).mockResolvedValue(null as never);
await expect(callLoader()).rejects.toMatchObject({
status: 302,
headers: expect.objectContaining({}),
});
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getEvent).mock.invocationCallOrder[0]);
expect(getEvent).toHaveBeenCalledWith("event-1", "tenant-1");
try {
await callLoader();
} catch (error) {
expect(error).toBeInstanceOf(Response);
expect((error as Response).headers.get("Location")).toBe("/acme/settings/logs/events");
}
});
it("uses an empty id after permission when the route id param is absent", async () => {
const data = await callLoader({ tenant: "acme", id: undefined as unknown as string });
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(getEvent).toHaveBeenCalledWith("", "tenant-1");
expect(data).toEqual({ item: event });
});
});
@@ -0,0 +1,50 @@
import { LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import EventDetails from "~/modules/events/components/EventDetails";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UrlUtils from "~/utils/app/UrlUtils";
import { EventWithDetails, getEvent } from "~/modules/events/db/events.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import EventUtils from "~/modules/events/utils/EventUtils";
type LoaderData = {
item: EventWithDetails;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const item = await getEvent(params.id ?? "", tenantId);
if (!item) {
throw redirect(UrlUtils.getModulePath(params, "logs/events"));
}
const data: LoaderData = {
item,
};
return data;
};
export default function AppEventDetailsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
title={t("models.event.object")}
withHome={false}
menu={[
{
title: t("models.event.plural"),
routePath: UrlUtils.getModulePath(params, "logs/events"),
},
{
title: EventUtils.parseName(data.item.name, t),
},
]}
>
<EventDetails item={data.item} />
</EditPageLayout>
);
}
@@ -0,0 +1,141 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./events";
import { getTranslations } from "~/locale/i18next.server";
import { getEvents } from "~/modules/events/db/events.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUsersByTenant } from "~/utils/db/users.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
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,
Link: () => null,
useLoaderData: () => ({}),
useParams: () => ({ tenant: "acme" }),
};
});
vi.mock("~/components/ui/input/InputFilters", () => ({ default: () => null }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/components/ui/tabs/Tabs", () => ({ default: () => null }));
vi.mock("~/modules/events/components/EventsTable", () => ({ default: () => null }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/modules/events/db/events.db.server", () => ({
getEvents: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUsersByTenant: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
const params = { tenant: "acme" };
const users = [
{ id: "user-1", email: "ada@example.test" },
{ id: "user-2", email: "grace@example.test" },
];
const events = [
{
id: "event-1",
tenantId: "tenant-1",
userId: "user-1",
name: "account.created",
data: "{}",
description: null,
createdAt: new Date("2026-05-08T10:00:00.000Z"),
tenant: { id: "tenant-1", name: "Acme", slug: "acme" },
user: { id: "user-1", email: "ada@example.test" },
},
];
function callLoader(url: string) {
const request = new Request(url);
return loader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/logs/events" } as LoaderFunctionArgs);
}
describe("tenant settings event list route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "ToolCTRL";
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTranslations).mockResolvedValue({
t: (key: string, values?: Record<string, string>) =>
key === "settings.logs.events.filters.eventOption" && values
? `formatted:${values.eventValue} -> ${values.eventLabel}`
: `translated:${key}`,
} as never);
vi.mocked(getUsersByTenant).mockResolvedValue(users as never);
vi.mocked(getEvents).mockResolvedValue({
items: events,
pagination: { page: 2, pageSize: 25, totalItems: 1, totalPages: 1 },
} as never);
});
it("checks tenant-scoped audit-trail permission before user and event helpers", async () => {
const data = await callLoader(
"https://app.example.test/acme/settings/logs/events?q=account&name=account.created&data=secret&userId=user-1&page=2&pageSize=25",
);
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getUsersByTenant).mock.invocationCallOrder[0]);
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getEvents).mock.invocationCallOrder[0]);
expect(getUsersByTenant).toHaveBeenCalledWith("tenant-1");
expect(getEvents).toHaveBeenCalledWith(
{
current: expect.objectContaining({ page: 2, pageSize: 25 }),
filters: expect.objectContaining({
query: "account",
properties: expect.arrayContaining([
expect.objectContaining({ name: "name", value: "account.created" }),
expect.objectContaining({ name: "data", value: "secret" }),
expect.objectContaining({ name: "userId", value: "user-1" }),
]),
}),
},
"tenant-1",
);
expect(data).toMatchObject({
title: "translated:models.event.plural | ToolCTRL",
items: events,
pagination: { page: 2, pageSize: 25, totalItems: 1, totalPages: 1 },
});
expect(data.filterableProperties).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "name",
options: expect.arrayContaining([expect.objectContaining({ value: "account.created", name: "formatted:account.created -> translated:events.names.account_created" })]),
}),
]),
);
});
it("rejects event list reads without permission before downstream helper calls", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader("https://app.example.test/acme/settings/logs/events?name=account.created")).rejects.toBe(rejection);
expect(getUsersByTenant).not.toHaveBeenCalled();
expect(getEvents).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,104 @@
import { LoaderFunctionArgs, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import { ApplicationEvents, getApplicationEventNameKey } from "~/modules/events/types/ApplicationEvent";
import EventsTable from "~/modules/events/components/EventsTable";
import InputFilters from "~/components/ui/input/InputFilters";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import { getTranslations } from "~/locale/i18next.server";
import UrlUtils from "~/utils/app/UrlUtils";
import { EventWithAttempts, getEvents } from "~/modules/events/db/events.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUsersByTenant } from "~/utils/db/users.db.server";
import Tabs from "~/components/ui/tabs/Tabs";
type LoaderData = {
title: string;
items: EventWithAttempts[];
pagination: PaginationDto;
filterableProperties: FilterablePropertyDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const { t } = await getTranslations(request);
const urlSearchParams = new URL(request.url).searchParams;
const current = getPaginationFromCurrentUrl(urlSearchParams);
const filterableProperties: FilterablePropertyDto[] = [
{
name: "name",
title: "settings.logs.events.filters.event",
options: ApplicationEvents.filter((f) => !f.adminOnly || !params.tenant).map((item) => {
return {
value: item.value,
name: t("settings.logs.events.filters.eventOption", { eventValue: item.value, eventLabel: t(getApplicationEventNameKey(item.value)) }),
};
}),
},
{
name: "data",
title: "settings.logs.events.filters.data",
},
{
name: "userId",
title: "models.user.object",
options: (await getUsersByTenant(tenantId)).map((item) => {
return {
value: item.id,
name: item.email,
};
}),
},
];
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const { items, pagination } = await getEvents({ current, filters }, tenantId);
const data: LoaderData = {
title: `${t("models.event.plural")} | ${process.env.APP_NAME}`,
items,
pagination,
filterableProperties,
};
return data;
};
export default function AppEventsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout>
<div data-ui-id="ui.settings.logs.events.page" className="space-y-2">
<div className="flex justify-between gap-2">
<div data-ui-id="ui.settings.logs.tabs" className="grow">
<Tabs
tabs={[
{
name: t("models.log.plural"),
routePath: UrlUtils.getModulePath(params, "logs"),
},
{
name: t("models.event.plural"),
routePath: UrlUtils.getModulePath(params, "logs/events"),
},
]}
/>
</div>
<div data-ui-id="ui.settings.logs.filters">
<InputFilters size="sm" filters={data.filterableProperties} />
</div>
</div>
<div data-ui-id="ui.settings.logs.events.table">
<EventsTable items={data.items} pagination={data.pagination} />
</div>
</div>
</EditPageLayout>
);
}
@@ -0,0 +1,175 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { loader } from "./index";
import { getTenantAuditLogList, serializeAdminAuditLogsCsv } from "@toolctrl/db/logs.server";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { readRepoFile } from "~/utils/testing/repoPaths";
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,
Link: () => null,
useLoaderData: () => ({}),
useParams: () => ({ tenant: "acme" }),
};
});
vi.mock("~/components/activity/TenantActivityLogToolbar", () => ({ default: () => null }));
vi.mock("~/components/app/events/LogsTable", () => ({ default: () => null }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/components/ui/tabs/Tabs", () => ({ default: () => null }));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("@toolctrl/db/logs.server", () => ({
getTenantAuditLogList: vi.fn(),
serializeAdminAuditLogsCsv: vi.fn(),
}));
const params = { tenant: "acme" };
const auditRows = [
{
id: "log-1",
createdAt: new Date("2026-05-08T10:00:00.000Z"),
tenantId: "tenant-1",
userId: "user-1",
apiKeyId: null,
action: "create",
url: "/acme/contacts",
details: "redacted details",
rowId: null,
commentId: null,
tenant: { id: "tenant-1", name: "Acme", slug: "acme" },
user: { id: "user-1", email: "admin@example.test", firstName: "Ada", lastName: "Admin" },
apiKey: null,
comment: null,
},
];
function callLoader(url: string) {
const request = new Request(url);
return loader({ request, params, context: {}, unstable_pattern: "app.$tenant/settings/logs" } as LoaderFunctionArgs);
}
function readTenantLogsRoute() {
return readRepoFile("apps/web/app/routes/app.$tenant/settings/logs/index.tsx");
}
describe("tenant settings logs route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "ToolCTRL";
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTranslations).mockResolvedValue({ t: (key: string) => `translated:${key}` } as never);
vi.mocked(getTenantAuditLogList).mockResolvedValue({ rows: auditRows, total: 1, take: 25, skip: 25 } as never);
vi.mocked(serializeAdminAuditLogsCsv).mockReturnValue("csv-body\n");
});
it("checks permission before reading the tenant-scoped filtered table data", async () => {
const data = await callLoader(
"https://app.example.test/acme/settings/logs?q=contact&action=create&url=%2Fcontacts&tenantId=other-tenant&userId=user-1&createdAtFrom=2026-05-01&createdAtTo=2026-05-08&page=2&pageSize=25",
);
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getTenantAuditLogList).mock.invocationCallOrder[0]);
expect(getTenantAuditLogList).toHaveBeenCalledWith("tenant-1", {
q: "contact",
action: "create",
url: "/contacts",
userId: "user-1",
createdAtFrom: "2026-05-01",
createdAtTo: "2026-05-08",
take: 25,
skip: 25,
});
expect(JSON.stringify(vi.mocked(getTenantAuditLogList).mock.calls[0]?.[1])).not.toContain("other-tenant");
expect(data).toMatchObject({
title: "translated:models.log.plural | ToolCTRL",
items: auditRows,
pagination: { page: 2, pageSize: 25, totalItems: 1, totalPages: 1 },
});
});
it("exports CSV with the same tenant filters and a capped export window", async () => {
const response = (await callLoader(
"https://app.example.test/acme/settings/logs?export=csv&q=login&action=auth&url=%2Flogin&tenantId=other-tenant&userId=user-2&createdAtFrom=bad-date&createdAtTo=2026-05-08&page=9&pageSize=5",
)) as Response;
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "tenant-1");
expect(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(getTenantAuditLogList).mock.invocationCallOrder[0]);
expect(getTenantAuditLogList).toHaveBeenCalledWith("tenant-1", {
q: "login",
action: "auth",
url: "/login",
userId: "user-2",
createdAtFrom: "bad-date",
createdAtTo: "2026-05-08",
take: 500,
skip: 0,
});
expect(JSON.stringify(vi.mocked(getTenantAuditLogList).mock.calls[0]?.[1])).not.toContain("other-tenant");
expect(serializeAdminAuditLogsCsv).toHaveBeenCalledWith(auditRows);
expect(response.headers.get("Content-Type")).toBe("text/csv; charset=utf-8");
expect(response.headers.get("Content-Disposition")).toBe('attachment; filename="tenant-audit-logs.csv"');
expect(await response.text()).toBe("csv-body\n");
});
it("rejects table and CSV reads without permission before helper calls", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValue(rejection as never);
await expect(callLoader("https://app.example.test/acme/settings/logs?export=csv")).rejects.toBe(rejection);
expect(getTenantAuditLogList).not.toHaveBeenCalled();
expect(serializeAdminAuditLogsCsv).not.toHaveBeenCalled();
});
it("does not crash on malformed numeric and date filters", async () => {
vi.mocked(getTenantAuditLogList).mockResolvedValue({ rows: [], total: 0, take: 10, skip: 0 } as never);
const data = await callLoader("https://app.example.test/acme/settings/logs?page=abc&pageSize=-5&createdAtFrom=not-a-date&createdAtTo=also-bad");
expect(getTenantAuditLogList).toHaveBeenCalledWith("tenant-1", {
q: null,
action: null,
url: null,
userId: null,
createdAtFrom: "not-a-date",
createdAtTo: "also-bad",
take: 10,
skip: 0,
});
expect(data).toMatchObject({ pagination: { page: 1, pageSize: 10, totalItems: 0, totalPages: 0 } });
});
it("uses the package audit-log boundary instead of the legacy app DB helper", () => {
const source = readTenantLogsRoute();
expect(source).toContain('from "@toolctrl/db/logs.server"');
expect(source).toContain("getTenantAuditLogList");
expect(source).toContain("serializeAdminAuditLogsCsv");
expect(source).toContain("TenantActivityLogToolbar");
expect(source).not.toContain("getLogs");
expect(source).not.toContain('from "~/utils/db/logs.db.server"');
});
});
@@ -0,0 +1,150 @@
import type { AdminAuditLogFilters, AdminAuditLogRow } from "@toolctrl/db/logs.server";
import { getTenantAuditLogList, serializeAdminAuditLogsCsv } from "@toolctrl/db/logs.server";
import { LoaderFunctionArgs, MetaFunction, useLoaderData } from "react-router";
import { useParams } from "react-router";
import { useTranslation } from "react-i18next";
import { FilterablePropertyDto } from "~/application/dtos/data/FilterablePropertyDto";
import { PaginationDto } from "~/application/dtos/data/PaginationDto";
import TenantActivityLogToolbar from "~/components/activity/TenantActivityLogToolbar";
import LogsTable from "~/components/app/events/LogsTable";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getFiltersFromCurrentUrl, getPaginationFromCurrentUrl } from "~/utils/helpers/RowPaginationHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import Tabs from "~/components/ui/tabs/Tabs";
const CSV_EXPORT_TAKE = 500;
type LoaderData = {
title: string;
items: AdminAuditLogRow[];
pagination: PaginationDto;
filterableProperties: FilterablePropertyDto[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const { t } = await getTranslations(request);
const filterableProperties = getAuditLogFilterableProperties();
const filters = getFiltersFromCurrentUrl(request, filterableProperties);
const urlSearchParams = new URL(request.url).searchParams;
const auditLogFilters = getAuditLogFiltersFromUrl(urlSearchParams);
if (urlSearchParams.get("export") === "csv") {
const { rows } = await getTenantAuditLogList(tenantId, { ...auditLogFilters, take: CSV_EXPORT_TAKE, skip: 0 });
return new Response(serializeAdminAuditLogsCsv(rows), {
headers: {
"Content-Type": "text/csv; charset=utf-8",
"Content-Disposition": 'attachment; filename="tenant-audit-logs.csv"',
},
});
}
const currentPagination = getPaginationFromCurrentUrl(urlSearchParams);
const pageSize = normalizePositiveInteger(currentPagination.pageSize, 10);
const page = normalizePositiveInteger(currentPagination.page, 1);
const { rows, total, take } = await getTenantAuditLogList(tenantId, {
...auditLogFilters,
take: pageSize,
skip: pageSize * (page - 1),
});
const data: LoaderData = {
title: `${t("models.log.plural")} | ${process.env.APP_NAME}`,
items: rows,
pagination: {
page,
pageSize: take,
totalItems: total,
totalPages: Math.ceil(total / take),
sortedBy: currentPagination.sortedBy,
query: currentPagination.query,
},
filterableProperties: filters.properties,
};
return data;
};
function getAuditLogFilterableProperties(): FilterablePropertyDto[] {
return [
{
name: "action",
title: "models.log.action",
},
{
name: "url",
title: "models.log.url",
},
{
name: "userId",
title: "shared.createdBy",
},
{
name: "createdAtFrom",
title: "shared.createdAt",
},
{
name: "createdAtTo",
title: "shared.createdAt",
},
];
}
function getAuditLogFiltersFromUrl(urlSearchParams: URLSearchParams): AdminAuditLogFilters {
return {
q: urlSearchParams.get("q"),
action: urlSearchParams.get("action"),
url: urlSearchParams.get("url"),
userId: urlSearchParams.get("userId"),
createdAtFrom: urlSearchParams.get("createdAtFrom"),
createdAtTo: urlSearchParams.get("createdAtTo"),
};
}
function normalizePositiveInteger(value: number | null | undefined, fallback: number): number {
if (!Number.isFinite(value) || !value || value < 1) return fallback;
return Math.trunc(value);
}
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function Events() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const params = useParams();
return (
<EditPageLayout
// title={t("models.log.plural")}
>
<div data-ui-id="ui.settings.logs.page" className="space-y-2">
<div className="flex justify-between gap-2">
<div data-ui-id="ui.settings.logs.tabs" className="grow">
<Tabs
tabs={[
{
name: t("models.log.plural"),
routePath: UrlUtils.getModulePath(params, "logs"),
},
{
name: t("models.event.plural"),
routePath: UrlUtils.getModulePath(params, "logs/events"),
},
]}
/>
</div>
<div data-ui-id="ui.settings.logs.filters">
<TenantActivityLogToolbar filters={data.filterableProperties} />
</div>
</div>
<div data-ui-id="ui.settings.logs.table">
<LogsTable withTenant={false} items={data.items} pagination={data.pagination} />
</div>
</div>
</EditPageLayout>
);
}
@@ -0,0 +1,350 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } 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(),
useOutlet: () => null,
useParams: () => ({}),
useSubmit: () => vi.fn(),
};
});
vi.mock("~/components/core/roles/GroupsTable", () => ({ default: () => null }));
vi.mock("~/components/core/roles/RoleBadge", () => ({ default: () => null }));
vi.mock("~/components/core/roles/RolesAndPermissionsMatrix", () => ({ default: () => null }));
vi.mock("~/components/core/roles/UserRolesTable", () => ({ default: () => null }));
vi.mock("~/components/core/settings/members/MemberInvitationsListAndTable", () => ({ default: () => null }));
vi.mock("~/components/ui/input/InputSearch", () => ({ default: () => null }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/ActionResultModal", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/ConfirmModal", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/ErrorModal", () => ({ default: () => null }));
vi.mock("~/components/ui/modals/Modal", () => ({ default: () => null }));
vi.mock("~/components/ui/sections/SettingSection", () => ({ default: () => null }));
vi.mock("~/components/ui/slideOvers/SlideOverWideEmpty", () => ({ default: () => null }));
vi.mock("~/components/ui/tables/TableSimple", () => ({ default: () => null }));
vi.mock("~/utils/app/UrlUtils", () => ({ default: { currentTenantUrl: vi.fn(() => "/acme/settings/subscription") } }));
vi.mock("~/utils/data/useAppData", () => ({ useAppData: () => ({}) }));
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({}) }));
vi.mock("~/utils/db/logs.db.server", () => ({ createAdminLog: vi.fn() }));
vi.mock("~/utils/db/permissions/groups.db.server", () => ({ getAllGroups: vi.fn(), getMyGroups: vi.fn() }));
vi.mock("~/utils/db/permissions/permissions.db.server", () => ({ getAllPermissions: vi.fn() }));
vi.mock("~/utils/db/permissions/roles.db.server", () => ({ getAllRoles: vi.fn(), getTenantAssignableAppRole: 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/PermissionsHelper", () => ({ getUserHasPermission: 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/auth/mfa/enforcement.server", () => ({ enforceAdminMfa: vi.fn() }));
vi.mock("~/utils/auth/mfa/step-up.server", () => ({ checkMfaStepUpState: vi.fn() }));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn(), getUserTotpStatus: vi.fn() }));
vi.mock("~/utils/session.server", () => ({
createImpersonationStartedAt: vi.fn(() => "2026-05-08T17:00:00.000Z"),
createUserSession: vi.fn(),
getUserInfo: vi.fn(),
getUserSession: vi.fn(),
setLoggedUser: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("@toolctrl/config", () => ({
loadRequiredWebConfig: () => ({
routing: {
protocol: "https",
webAppHost: "app.example.test",
adminAppHost: "admin.example.test",
apiHost: "api.example.test",
appBaseDomain: "example.test",
},
}),
}));
import { enforceAdminMfa } from "~/utils/auth/mfa/enforcement.server";
import { checkMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
import { getAllRoles, getTenantAssignableAppRole } from "~/utils/db/permissions/roles.db.server";
import { getAllGroups, getMyGroups } from "~/utils/db/permissions/groups.db.server";
import { getAllPermissions } from "~/utils/db/permissions/permissions.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 { getUser, getUserTotpStatus } from "~/utils/db/users.db.server";
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { createUserSession, getUserInfo, getUserSession, setLoggedUser, validateCSRFToken } from "~/utils/session.server";
import { action, loader } from "./members";
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: [],
};
const enabledTotpStatus = { enabled: true, pending: false, enabledAt: new Date("2026-05-08T12:00:00.000Z"), pendingCreatedAt: null };
const freshStepUp = { verified: true, state: { userId: actor.id, method: "totp", verifiedAt: "2026-05-08T16:59:00.000Z" }, ageMs: 60_000 };
function postRequest(form: Record<string, string> = { action: "impersonate", "user-id": targetUser.id }) {
return new Request("https://app.example.test/acme/settings/members?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/members",
} 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/members"),
params: { tenant: "acme" },
context: {},
});
}
describe("workspace members impersonation MFA guard", () => {
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(getUserSession).mockResolvedValue({ get: vi.fn() } as never);
vi.mocked(getUser).mockImplementation(async (id?: string) => (id === actor.id ? actor : id === targetUser.id ? targetUser : null) as never);
vi.mocked(getUserTotpStatus).mockResolvedValue(enabledTotpStatus as never);
vi.mocked(checkMfaStepUpState).mockReturnValue(freshStepUp as never);
vi.mocked(enforceAdminMfa).mockReturnValue({ allowed: true, reason: "allowed", redirectTo: "/acme/settings/members" } 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("requires fresh admin MFA step-up before creating a workspace member impersonation session", 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(getUserTotpStatus).toHaveBeenCalledWith(actor.id);
expect(checkMfaStepUpState).toHaveBeenCalledWith(expect.anything(), actor.id);
expect(enforceAdminMfa).toHaveBeenCalledWith({
requestUrl: "https://app.example.test/acme/settings/members?tab=active",
userId: actor.id,
isAdmin: true,
totpStatus: enabledTotpStatus,
stepUp: freshStepUp,
redirectMode: "host-aware",
appFallbackPath: "/acme/settings/members",
});
expect(setLoggedUser).toHaveBeenCalledWith(targetUser);
expect(createUserSession).toHaveBeenCalledWith(
expect.objectContaining({
userId: targetUser.id,
impersonatingFromUserId: actor.id,
impersonatingStartedAt: "2026-05-08T17:00:00.000Z",
}),
"/acme/dashboard"
);
expect(result.response.headers.get("Location")).toBe("/acme/dashboard");
});
it("redirects to the MFA challenge and does not switch sessions when step-up is missing", async () => {
vi.mocked(checkMfaStepUpState).mockReturnValue({ verified: false, reason: "missing" } as never);
vi.mocked(enforceAdminMfa).mockReturnValue({
allowed: false,
reason: "step-up-missing",
redirectTo: "/mfa-challenge?redirectTo=%2Facme%2Fsettings%2Fmembers%3Ftab%3Dactive",
} as never);
const result = await callAction();
expect(result.thrown).toBe(true);
expect(result.response.status).toBe(302);
expect(result.response.headers.get("Location")).toBe("https://admin.example.test/mfa-challenge?redirectTo=%2Facme%2Fsettings%2Fmembers%3Ftab%3Dactive");
expect(setLoggedUser).not.toHaveBeenCalled();
expect(createUserSession).not.toHaveBeenCalled();
});
it("keeps non-admin impersonation fallback on the app host", async () => {
vi.mocked(enforceAdminMfa).mockReturnValue({
allowed: false,
reason: "missing-admin",
redirectTo: "/acme/settings/members",
} as never);
const result = await callAction();
expect(result.thrown).toBe(true);
expect(result.response.status).toBe(302);
expect(result.response.headers.get("Location")).toBe("https://app.example.test/acme/settings/members");
expect(setLoggedUser).not.toHaveBeenCalled();
expect(createUserSession).not.toHaveBeenCalled();
});
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", 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" });
});
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" });
});
it("localizes the super-admin impersonation guard response", async () => {
const superAdminUser = { ...targetUser, admin: true };
vi.mocked(getUser).mockImplementation(async (id?: string) => (id === actor.id ? actor : id === targetUser.id ? superAdminUser : null) as never);
const result = await callAction();
expect(result.thrown).toBe(false);
expect(result.response.status).toBe(400);
await expect(result.response.json()).resolves.toEqual({ error: "settings.members.errors.cannotImpersonateSuperAdmin" });
expect(setLoggedUser).not.toHaveBeenCalled();
});
});
describe("workspace members loader", () => {
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(getTenantUsers).mockResolvedValue([{ id: "member-1", user: { id: "user-1" } }] as never);
vi.mocked(getUserInvitations).mockResolvedValue([{ id: "invite-1" }] as never);
vi.mocked(getAllRoles).mockResolvedValue([{ id: "role-1" }] as never);
vi.mocked(getAllPermissions).mockResolvedValue([{ name: "app.settings.members.view" }] as never);
vi.mocked(getUserPermission).mockResolvedValue({ permission: null, userPermission: null } as never);
vi.mocked(getAllGroups).mockResolvedValue([{ id: "group-1" }] as never);
vi.mocked(getMyGroups).mockResolvedValue([{ id: "my-group-1" }] as never);
});
it("loads independent members settings data in parallel before resolving groups", async () => {
const started: string[] = [];
vi.mocked(getTenantUsers).mockImplementation(async () => {
started.push("users");
return [{ id: "member-1", user: { id: "user-1" } }] as never;
});
vi.mocked(getUserInvitations).mockImplementation(async () => {
started.push("invitations");
return [{ id: "invite-1" }] as never;
});
vi.mocked(getAllRoles).mockImplementation(async () => {
started.push("roles");
return [{ id: "role-1" }] as never;
});
vi.mocked(getAllPermissions).mockImplementation(async () => {
started.push("permissions");
return [{ name: "app.settings.members.view" }] as never;
});
vi.mocked(getUserPermission).mockImplementation(async () => {
started.push("group-access");
return { permission: null, userPermission: null } as never;
});
const data = await callLoader();
expect(started).toEqual(["users", "invitations", "roles", "permissions", "group-access"]);
expect(getAllGroups).toHaveBeenCalledWith("tenant-1");
expect(getMyGroups).not.toHaveBeenCalled();
expect(data).toEqual(
expect.objectContaining({
users: [{ id: "member-1", user: { id: "user-1" } }],
pendingInvitations: [{ id: "invite-1" }],
roles: [{ id: "role-1" }],
permissions: [{ name: "app.settings.members.view" }],
groups: [{ id: "group-1" }],
})
);
});
it("loads only my groups when the current user lacks full group access", async () => {
vi.mocked(getUserPermission).mockResolvedValue({ permission: { name: "app.settings.groups.full" }, userPermission: null } as never);
const data = await callLoader();
expect(getAllGroups).not.toHaveBeenCalled();
expect(getMyGroups).toHaveBeenCalledWith(actor.id, "tenant-1");
expect(data).toEqual(expect.objectContaining({ groups: [{ id: "my-group-1" }] }));
});
});
@@ -0,0 +1,422 @@
import ConfirmModal, { RefConfirmModal } from "~/components/ui/modals/ConfirmModal";
import ErrorModal, { RefErrorModal } from "~/components/ui/modals/ErrorModal";
import { Fragment, useEffect, useMemo, useRef, useState } from "react";
import { getTenant, getTenantMember, getTenantUsers, TenantUserWithUser } from "~/utils/db/tenants.db.server";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData } from "react-router";
import { useNavigate, useOutlet, useParams } from "react-router";
import { deleteUserInvitation, getUserInvitation, getUserInvitations } from "~/utils/db/tenantUserInvitations.db.server";
import MemberInvitationsListAndTable from "~/components/core/settings/members/MemberInvitationsListAndTable";
import { getTranslations } from "~/locale/i18next.server";
import { useLocaleFormatters } from "~/locale/format";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import InputSearch from "~/components/ui/input/InputSearch";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { useAppData } from "~/utils/data/useAppData";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import SettingSection from "~/components/ui/sections/SettingSection";
import { RoleWithPermissions, getAllRoles, getTenantAssignableAppRole } from "~/utils/db/permissions/roles.db.server";
import { Permission } from "@toolctrl/db/prisma-browser";
import { getUser, getUserTotpStatus } from "~/utils/db/users.db.server";
import { useTranslation } from "react-i18next";
import { createAdminLog } from "~/utils/db/logs.db.server";
import { createUserRole, deleteUserRole } from "~/utils/db/permissions/userRoles.db.server";
import { createImpersonationStartedAt, createUserSession, getUserInfo, getUserSession, setLoggedUser, validateCSRFToken } from "~/utils/session.server";
import MembersListView from "~/modules/users/components/MembersListView";
import Modal from "~/components/ui/modals/Modal";
import TableSimple from "~/components/ui/tables/TableSimple";
import RoleBadge from "~/components/core/roles/RoleBadge";
import { permissionDisplayDescription, permissionDisplayName, roleDisplayName } from "~/components/core/roles/roleDisplay";
import RolesAndPermissionsMatrix from "~/components/core/roles/RolesAndPermissionsMatrix";
import { getAllPermissions } from "~/utils/db/permissions/permissions.db.server";
import { GroupWithDetails, getAllGroups, getMyGroups } from "~/utils/db/permissions/groups.db.server";
import GroupsTable from "~/components/core/roles/GroupsTable";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
import { DefaultAppRoles } from "~/application/dtos/shared/DefaultAppRoles";
import ActionResultModal from "~/components/ui/modals/ActionResultModal";
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 { enforceAdminMfa } from "~/utils/auth/mfa/enforcement.server";
import { checkMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { loadRequiredWebConfig } from "@toolctrl/config";
import { absoluteAdminPath, absoluteAppPath } from "~/utils/app/CrossHostUrls";
import { TenantUserStatus } from "~/application/enums/tenants/TenantUserStatus";
type LoaderData = {
title: string;
users: TenantUserWithUser[];
mfaEnabledUserIds: string[];
pendingInvitations: Awaited<ReturnType<typeof getUserInvitations>>;
roles: RoleWithPermissions[];
permissions: Permission[];
groups: GroupWithDetails[];
};
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);
const [users, pendingInvitations, roles, permissions, groupAccess] = await Promise.all([
getTenantUsers(tenantId),
getUserInvitations(tenantId),
getAllRoles("app"),
getAllPermissions("app"),
getUserPermission({
userId: userInfo.userId,
permissionName: "app.settings.groups.full",
tenantId: tenantId,
}),
]);
const { permission, userPermission } = groupAccess;
let groups: GroupWithDetails[];
if (!permission || userPermission) {
groups = await getAllGroups(tenantId);
} else {
groups = await getMyGroups(userInfo.userId, tenantId);
}
const mfaEnabledUserIds = (
await Promise.all(users.map(async (member) => ((await getUserTotpStatus(member.user.id))?.enabled ? member.user.id : null)))
).filter((id): id is string => id !== null);
const data: LoaderData = {
title: `${t("settings.members.title")} | ${process.env.APP_NAME}`,
users,
mfaEnabledUserIds,
pendingInvitations,
roles,
permissions,
groups,
};
return data;
};
type ActionData = {
success?: string;
error?: 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 === "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) {
return badRequest({
error: t("settings.members.errors.atLeastOneSuperAdmin"),
});
}
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 ?? null,
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 session = await getUserSession(request);
const mfaEnforcement = enforceAdminMfa({
requestUrl: request.url,
userId: fromUser.id,
isAdmin: Boolean(fromUser.admin),
totpStatus: await getUserTotpStatus(fromUser.id),
stepUp: checkMfaStepUpState(session, fromUser.id),
redirectMode: "host-aware",
appFallbackPath: appPath({ tenantSlug: params.tenant ?? "", path: "settings/members", mode: "host-aware" }),
});
if (!mfaEnforcement.allowed) {
const routing = loadRequiredWebConfig().routing;
if (mfaEnforcement.reason === "missing-admin" || mfaEnforcement.reason === "missing-user") {
throw redirect(absoluteAppPath(routing, params.tenant ?? "", "settings/members"));
}
throw redirect(absoluteAdminPath(routing, mfaEnforcement.redirectTo));
}
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") });
}
if (user.admin) {
return badRequest({ error: t("settings.members.errors.cannotImpersonateSuperAdmin") });
}
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" }) : "/"
);
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function () {
const { t } = useTranslation();
const formatters = useLocaleFormatters();
const params = useParams();
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const rootData = useRootData();
const appData = useAppData();
const navigate = useNavigate();
const outlet = useOutlet();
const errorModal = useRef<RefErrorModal>(null);
const confirmUpgrade = useRef<RefConfirmModal>(null);
const [searchInput, setSearchInput] = useState("");
const [permissionsModalOpen, setPermissionsModalOpen] = useState(false);
const [selectedRole, setSelectedRole] = useState<RoleWithPermissions>();
const [showRolesAndPermissions, setShowRolesAndPermissions] = useState(false);
const formatPermissionCount = (count: number | undefined) => {
const value = count ?? 0;
return t("models.permission.count", { count: value, formattedCount: formatters.number(value) });
};
useEffect(() => {
setPermissionsModalOpen(selectedRole !== undefined);
}, [selectedRole]);
useEffect(() => {
if (!permissionsModalOpen) {
setSelectedRole(undefined);
}
}, [permissionsModalOpen]);
function yesUpdateSubscription() {
navigate(UrlUtils.currentTenantUrl(params, `settings/subscription`));
}
const sortedItems = useMemo(() => {
if (!data.users) {
return [];
}
const normalizedSearch = searchInput.toUpperCase();
return data.users
.filter(
(f) =>
f.user.firstName?.toString().toUpperCase().includes(normalizedSearch) ||
f.user.lastName?.toString().toUpperCase().includes(normalizedSearch) ||
f.user.email?.toString().toUpperCase().includes(normalizedSearch) ||
f.user.phone?.toString().toUpperCase().includes(normalizedSearch)
)
.slice()
.sort((x, y) => {
return x.type > y.type ? 1 : -1;
});
}, [data.users, searchInput]);
return (
<EditPageLayout>
<div data-ui-id="ui.settings.members.page" className="contents">
<SettingSection
size="lg"
title={t("settings.members.title")}
description={
<div className="flex flex-col space-y-1">
<div>{t("settings.members.description")}</div>
<div>
<button type="button" className="text-left underline" onClick={() => setShowRolesAndPermissions(true)}>
{t("settings.members.viewRolesAndPermissions")}
</button>
</div>
</div>
}
className="p-1"
>
<div className="grid grid-cols-1 space-y-2">
<div data-ui-id="ui.settings.members.search">
<InputSearch
value={searchInput}
setValue={setSearchInput}
onNewRoute={!getUserHasPermission(appData, "app.settings.members.create") ? "" : UrlUtils.currentTenantUrl(params, "settings/members/new")}
/>
</div>
<div className="space-y-2">
<div data-ui-id="ui.settings.members.table">
<MembersListView
items={sortedItems}
mfaEnabledUserIds={data.mfaEnabledUserIds}
tenantId={appData.currentTenant.id}
canEdit={getUserHasPermission(appData, "app.settings.roles.set")}
editRouteFor={(tenantUserId) => UrlUtils.currentTenantUrl(params, `settings/members/edit/${tenantUserId}`)}
rolesUrl={UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/users")}
/>
</div>
<Modal open={permissionsModalOpen} setOpen={setPermissionsModalOpen}>
<div className="space-y-2">
<div className="flex items-baseline justify-between space-x-2">
<h4 className="text-lg font-bold">{selectedRole ? roleDisplayName(selectedRole, t) : undefined}</h4>
<p className="text-muted-foreground text-sm">{formatPermissionCount(selectedRole?.permissions.length)}</p>
</div>
<div className="h-96 max-h-96 overflow-y-scroll p-1">
<TableSimple
headers={[
{
name: "name",
title: t("models.permission.name"),
value: (i) => permissionDisplayName(i.permission, t),
formattedValue: (i) => <RoleBadge item={i.permission} kind="permission" />,
},
{
name: "description",
title: t("models.permission.description"),
value: (i) => permissionDisplayDescription(i.permission, t) ?? "",
},
]}
items={selectedRole?.permissions ?? []}
/>
</div>
</div>
</Modal>
<Modal size="4xl" open={showRolesAndPermissions} setOpen={setShowRolesAndPermissions}>
<div className="space-y-2">
<div className="flex items-baseline justify-between space-x-2">
<h4 className="text-lg font-bold">{t("app.sidebar.rolesAndPermissions")}</h4>
<p className="text-muted-foreground text-sm">{formatPermissionCount(data.permissions.length)}</p>
</div>
<div className="p-1">
<RolesAndPermissionsMatrix roles={data.roles} permissions={data.permissions} className="h-96 max-h-96 overflow-y-scroll" />
</div>
</div>
</Modal>
{data.pendingInvitations.length > 0 && (
<div className="space-y-1">
<label className="text-foreground/80 block text-sm font-medium">{t("settings.members.pendingInvitations")}</label>
<MemberInvitationsListAndTable items={data.pendingInvitations} canDelete={getUserHasPermission(appData, "app.settings.members.delete")} />
</div>
)}
</div>
</div>
</SettingSection>
{rootData.featureFlags?.includes("row-groups") && (
<Fragment>
{/*Separator */}
<div className="block">
<div className="py-5">
<div className="border-border border-t"></div>{" "}
</div>
</div>
<SettingSection size="lg" title={t("settings.members.groups.title")} description={t("settings.members.groups.description")} className="p-1">
<GroupsTable items={data.groups} onNewRoute="groups/new" />
</SettingSection>
</Fragment>
)}
<SlideOverWideEmpty
title={params.id ? t("settings.members.form.editTitle") : t("settings.members.form.newTitle")}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-sm"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
<ActionResultModal actionData={actionData} showSuccess={false} />
<ErrorModal ref={errorModal} />
<ConfirmModal ref={confirmUpgrade} onYes={yesUpdateSubscription} />
</div>
</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 "@toolctrl/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/members"));
} 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/members"));
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => data?.metatags ?? [];
interface Props {
maxSize?: string;
}
export default function EditMemberRoute({ 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/members"));
}
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,135 @@
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 { deleteGroup, getGroup, GroupWithDetails, updateGroup } from "~/utils/db/permissions/groups.db.server";
import { createUserGroup, deleteGroupUsers } 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/members"));
}
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/members"));
}
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") });
}
await deleteGroupUsers(existing.id, tenantId);
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 Promise.all(
users.map(async (user) => {
return await createUserGroup(user.id, existing.id);
})
);
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 deleteGroup(existing.id, tenantId);
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") });
}
return redirect(UrlUtils.currentTenantUrl(params, "settings/members"));
};
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/members"))}
>
<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,95 @@
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 { createGroup } from "~/utils/db/permissions/groups.db.server";
import { createUserGroup } 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 group = await createGroup(data);
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 Promise.all(
users.map(async (user) => {
return await createUserGroup(user.id, group.id);
})
);
await createLog(
request,
tenantId,
"settings.groups.created",
`${JSON.stringify({
...data,
users: users.map((f) => f.email),
})}`
);
return redirect(UrlUtils.currentTenantUrl(params, "settings/members"));
} 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/members"))}
>
<GroupForm allUsers={data.tenantUsers} />
</SlideOverWideEmpty>
);
}
@@ -0,0 +1,25 @@
import { readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
const sourcePath = "apps/web/app/routes/app.$tenant/settings/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("`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,168 @@
import { ActionFunction, LoaderFunctionArgs, redirect, MetaFunction, useLoaderData } 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 "@toolctrl/db/workspace-invites.server";
import { getDbClient } from "@toolctrl/db/client.server";
import { publishOutboxEvent, type OutboxPublisherTransaction } from "@toolctrl/db/outbox";
import type { Prisma } from "@toolctrl/db/prisma-browser";
import NewMember from "~/components/core/settings/members/NewMember";
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,
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/members", mode: "host-aware" }));
} 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 }];
export default function NewMemberRoute() {
const data = useLoaderData<NewMemberLoaderData>();
return <NewMember featurePlanUsage={data.featurePlanUsage} />;
}
export function ErrorBoundary() {
return <ServerError />;
}
@@ -0,0 +1,220 @@
import "@testing-library/jest-dom";
import { render, screen } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { MemoryRouter } from "react-router";
vi.mock("@toolctrl/db/notifications.server", () => ({
getUserNotificationPreferences: vi.fn(),
upsertUserNotificationPreference: vi.fn(),
}));
vi.mock("~/utils/loaders.middleware", () => ({
requireAuth: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/data/useRootData", () => ({
useRootData: () => ({ csrf: "csrf-test-token" }),
}));
const routeTranslations: Record<string, string> = {
"settings.notifications.heading": "Notification preferences",
"settings.notifications.description": "Choose which workspace updates you receive in-app and by email. Preferences are scoped to your current workspace and user account.",
"settings.notifications.saved": "Notification preference saved.",
"settings.notifications.categories.default": "Default",
"settings.notifications.categories.billing": "Billing",
"settings.notifications.categories.team": "Team",
"settings.notifications.channels.inApp": "In-app",
"settings.notifications.channels.email": "Email",
"settings.notifications.errors.invalidPreferenceAction": "Invalid notification preference action.",
"settings.notifications.errors.invalidPreferenceCategory": "Invalid notification preference category.",
"settings.notifications.errors.invalidPreferenceChannel": "Invalid notification preference channel.",
"shared.save": "Save",
};
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string) => routeTranslations[key] ?? key,
})),
}));
vi.mock("react-i18next", () => ({
useTranslation: () => ({
t: (key: string, options?: Record<string, string>) => {
if (key === "settings.notifications.categoryDescription") {
return `Manage ${options?.category ?? ""} workspace notifications.`;
}
return routeTranslations[key] ?? key;
},
}),
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
useActionData: () => routeActionData,
useLoaderData: () => routeLoaderData,
};
});
import { getUserNotificationPreferences, upsertUserNotificationPreference } from "@toolctrl/db/notifications.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo } from "~/utils/session.server";
import WorkspaceNotificationSettingsRoute, { action, loader } from "./notifications";
let routeLoaderData: unknown;
let routeActionData: unknown;
const request = new Request("https://app.example.test/acme/settings/notifications");
const params = { tenant: "acme" };
function routeArgs(customRequest: Request = request) {
return { request: customRequest, params, context: {}, unstable_pattern: "app.$tenant/settings/notifications" };
}
function postFormRequest(formData: FormData) {
return new Request(request.url, {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(formData as unknown as Record<string, string>),
});
}
function preferenceForm(overrides?: Record<string, string>) {
const form = new FormData();
form.set("action", "update-preference");
form.set("category", "billing");
form.set("channel", "EMAIL");
form.set("enabled", "on");
Object.entries(overrides ?? {}).forEach(([key, value]) => form.set(key, value));
return form;
}
describe("workspace notification settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant_1");
vi.mocked(getUserInfo).mockResolvedValue({ userId: "user_1" } as never);
vi.mocked(getUserNotificationPreferences).mockResolvedValue([]);
vi.mocked(upsertUserNotificationPreference).mockResolvedValue({ id: "pref_1" });
routeLoaderData = {
preferences: {
default: { IN_APP: true, EMAIL: true },
billing: { IN_APP: true, EMAIL: false },
team: { IN_APP: false, EMAIL: true },
},
};
routeActionData = undefined;
});
it("requires auth and loads notification preferences only for the current tenant and user", async () => {
vi.mocked(getUserNotificationPreferences).mockResolvedValue([
{ tenantId: "tenant_1", userId: "user_1", category: "billing", channel: "EMAIL", enabled: false },
{ tenantId: "tenant_1", userId: "user_1", category: "team", channel: "IN_APP", enabled: false },
{ tenantId: "tenant_1", userId: "user_1", category: "unknown", channel: "EMAIL", enabled: false },
] as never);
const response = (await loader(routeArgs())) as Response;
const body = await response.json();
expect(requireAuth).toHaveBeenCalledWith({ request, params });
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(getUserInfo).toHaveBeenCalledWith(request);
expect(getUserNotificationPreferences).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1" });
expect(body).toEqual({
preferences: {
default: { IN_APP: true, EMAIL: true },
billing: { IN_APP: true, EMAIL: false },
team: { IN_APP: false, EMAIL: true },
},
});
expect(JSON.stringify(body)).not.toContain("unknown");
});
it("shows category preferences using the same default fallback as the worker", async () => {
vi.mocked(getUserNotificationPreferences).mockResolvedValue([{ tenantId: "tenant_1", userId: "user_1", category: "default", channel: "EMAIL", enabled: false }] as never);
const response = (await loader(routeArgs())) as Response;
const body = await response.json();
expect(body).toEqual({
preferences: {
default: { IN_APP: true, EMAIL: false },
billing: { IN_APP: true, EMAIL: false },
team: { IN_APP: true, EMAIL: false },
},
});
});
it("returns bounded 400 JSON for an invalid category without calling upsert", async () => {
const form = preferenceForm({ category: "security" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid notification preference category." });
expect(upsertUserNotificationPreference).not.toHaveBeenCalled();
});
it("returns bounded 400 JSON for an invalid notification action without calling upsert", async () => {
const form = preferenceForm({ action: "delete-preference" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid notification preference action." });
expect(upsertUserNotificationPreference).not.toHaveBeenCalled();
});
it("returns bounded 400 JSON for an invalid channel without calling upsert", async () => {
const form = preferenceForm({ channel: "SMS" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid notification preference channel." });
expect(upsertUserNotificationPreference).not.toHaveBeenCalled();
});
it("writes a valid preference update with tenant, user, normalized category, channel, and enabled state", async () => {
const form = preferenceForm({ category: " Team ", channel: "in-app", enabled: "true" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(requireAuth).toHaveBeenCalledWith({ request: expect.any(Request), params });
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(getUserInfo).toHaveBeenCalledWith(expect.any(Request));
expect(upsertUserNotificationPreference).toHaveBeenCalledWith({
tenantId: "tenant_1",
userId: "user_1",
channel: "IN_APP",
category: "team",
enabled: true,
});
expect(body).toEqual({ ok: true });
});
it("renders compact controls for default, billing, and team notification preferences", () => {
render(
<MemoryRouter>
<WorkspaceNotificationSettingsRoute />
</MemoryRouter>,
);
expect(screen.getByRole("heading", { name: "Notification preferences" })).toBeInTheDocument();
expect(screen.getByText("Preferences are scoped to your current workspace and user account.", { exact: false })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Default" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Billing" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Team" })).toBeInTheDocument();
expect(screen.getAllByLabelText("In-app")).toHaveLength(3);
expect(screen.getAllByLabelText("Email")).toHaveLength(3);
expect(screen.getByLabelText("Email", { selector: "input#notification-billing-EMAIL" })).not.toBeChecked();
expect(screen.getByLabelText("In-app", { selector: "input#notification-team-IN_APP" })).not.toBeChecked();
});
});
@@ -0,0 +1,194 @@
import { ActionFunctionArgs, LoaderFunctionArgs, useActionData, useLoaderData } from "react-router";
import {
getUserNotificationPreferences,
upsertUserNotificationPreference,
type NotificationPreferenceChannel,
} from "@toolctrl/db/notifications.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { useRootData } from "~/utils/data/useRootData";
import { getTranslations } from "~/locale/i18next.server";
import { useTranslation } from "react-i18next";
const NOTIFICATION_SETTING_CATEGORIES = ["default", "billing", "team"] as const;
const NOTIFICATION_SETTING_CHANNELS = ["IN_APP", "EMAIL"] as const;
type NotificationSettingCategory = (typeof NOTIFICATION_SETTING_CATEGORIES)[number];
type NotificationSettingChannel = (typeof NOTIFICATION_SETTING_CHANNELS)[number];
type NotificationPreferenceRecord = {
channel: NotificationPreferenceChannel | string;
category: string;
enabled: boolean;
};
type LoaderData = {
preferences: Record<NotificationSettingCategory, Record<NotificationSettingChannel, boolean>>;
};
type ActionData = {
ok?: true;
error?: string;
};
function isAllowedCategory(value: string): value is NotificationSettingCategory {
return NOTIFICATION_SETTING_CATEGORIES.includes(value as NotificationSettingCategory);
}
function isAllowedChannel(value: string): value is NotificationSettingChannel {
return NOTIFICATION_SETTING_CHANNELS.includes(value as NotificationSettingChannel);
}
function getRequiredFormValue(formData: FormData, key: string): string | null {
const value = formData.get(key);
if (typeof value !== "string") {
return null;
}
const normalized = value.trim();
return normalized.length > 0 ? normalized : null;
}
function createDefaultPreferences(): LoaderData["preferences"] {
return {
default: { IN_APP: true, EMAIL: true },
billing: { IN_APP: true, EMAIL: true },
team: { IN_APP: true, EMAIL: true },
};
}
function toLoaderData(records: NotificationPreferenceRecord[]): LoaderData {
const preferences = createDefaultPreferences();
const explicitPreferences = new Set<string>();
for (const record of records) {
const category = record.category.trim().toLowerCase();
const channel = record.channel.trim().replace(/-/g, "_").toUpperCase();
if (isAllowedCategory(category) && isAllowedChannel(channel)) {
preferences[category][channel] = record.enabled;
explicitPreferences.add(`${category}:${channel}`);
}
}
for (const category of NOTIFICATION_SETTING_CATEGORIES) {
if (category === "default") {
continue;
}
for (const channel of NOTIFICATION_SETTING_CHANNELS) {
if (!explicitPreferences.has(`${category}:${channel}`)) {
preferences[category][channel] = preferences.default[channel];
}
}
}
return { preferences };
}
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const tenantId = await getTenantIdFromUrl(params);
const userInfo = await getUserInfo(request);
const records = (await getUserNotificationPreferences({ tenantId, userId: userInfo.userId })) as NotificationPreferenceRecord[];
return Response.json(toLoaderData(records));
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
await validateCSRFToken(request);
const tenantId = await getTenantIdFromUrl(params);
const userInfo = await getUserInfo(request);
const formData = await request.formData();
const actionName = getRequiredFormValue(formData, "action");
if (actionName !== "update-preference") {
return badRequest({ error: t("settings.notifications.errors.invalidPreferenceAction") });
}
const category = getRequiredFormValue(formData, "category")?.toLowerCase() ?? "";
const channel = getRequiredFormValue(formData, "channel")?.replace(/-/g, "_").toUpperCase() ?? "";
if (!isAllowedCategory(category)) {
return badRequest({ error: t("settings.notifications.errors.invalidPreferenceCategory") });
}
if (!isAllowedChannel(channel)) {
return badRequest({ error: t("settings.notifications.errors.invalidPreferenceChannel") });
}
await upsertUserNotificationPreference({
tenantId,
userId: userInfo.userId,
channel,
category,
enabled: formData.get("enabled") === "on" || formData.get("enabled") === "true",
});
return Response.json({ ok: true });
};
export default function WorkspaceNotificationSettingsRoute() {
const { t } = useTranslation();
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const rootData = useRootData();
return (
<main data-ui-id="ui.settings.notifications.page" className="mx-auto grid max-w-3xl gap-5 px-4 py-5 sm:px-8">
<div className="space-y-2">
<h1 className="text-2xl font-semibold text-foreground">{t("settings.notifications.heading")}</h1>
<p className="text-sm text-muted-foreground">{t("settings.notifications.description")}</p>
</div>
{actionData?.error ? <p className="rounded-md border border-destructive/40 bg-destructive/10 p-3 text-sm text-destructive">{actionData.error}</p> : null}
{actionData?.ok ? <p className="rounded-md border border-emerald-500/40 bg-emerald-500/10 p-3 text-sm text-emerald-700">{t("settings.notifications.saved")}</p> : null}
<div className="divide-y rounded-lg border bg-card">
{NOTIFICATION_SETTING_CATEGORIES.map((category) => (
<section
key={category}
data-ui-id={`ui.settings.notifications.category.${category}`}
className="grid gap-3 p-4 sm:grid-cols-[1fr_auto] sm:items-center"
>
<div>
<h2 className="text-sm font-medium text-foreground">{t(`settings.notifications.categories.${category}`)}</h2>
<p className="text-sm text-muted-foreground">{t("settings.notifications.categoryDescription", { category: t(`settings.notifications.categories.${category}`).toLowerCase() })}</p>
</div>
<div className="flex flex-wrap gap-3">
{NOTIFICATION_SETTING_CHANNELS.map((channel) => {
const inputId = `notification-${category}-${channel}`;
return (
<form
key={channel}
method="post"
data-ui-id={`ui.settings.notifications.preference.${category}.${channel.toLowerCase()}`}
className="flex items-center gap-2 rounded-md border px-3 py-2"
>
<input type="hidden" name="action" value="update-preference" />
{rootData.csrf && <input type="hidden" name="csrf" value={rootData.csrf} />}
<input type="hidden" name="category" value={category} />
<input type="hidden" name="channel" value={channel} />
<input id={inputId} name="enabled" type="checkbox" defaultChecked={data.preferences[category][channel]} />
<label htmlFor={inputId} className="text-sm font-medium">
{t(channel === "IN_APP" ? "settings.notifications.channels.inApp" : "settings.notifications.channels.email")}
</label>
<button type="submit" className="text-sm text-primary underline-offset-2 hover:underline">
{t("shared.save")}
</button>
</form>
);
})}
</div>
</section>
))}
</div>
</main>
);
}
@@ -0,0 +1,112 @@
import { beforeEach, describe, expect, test, vi } from "vitest";
const getTenantIdMock = vi.fn().mockResolvedValue("t-1");
const verifyPermissionMock = vi.fn().mockResolvedValue(undefined);
const getPluginForTenantMock = vi.fn();
const auditFindManyMock = vi.fn();
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: (...args: unknown[]) => getTenantIdMock(...args),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: (...args: unknown[]) => verifyPermissionMock(...args),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string, fallback?: string) => fallback ?? key,
})),
}));
vi.mock("~/modules/plugins/services/.server/PluginLifecycleService", () => ({
getPluginForTenant: (...args: unknown[]) => getPluginForTenantMock(...args),
}));
vi.mock("~/utils/db.server", () => ({
dbRead: {
pluginCapabilityUse: {
findMany: (...args: unknown[]) => auditFindManyMock(...args),
},
},
}));
beforeEach(() => {
getTenantIdMock.mockClear();
verifyPermissionMock.mockReset();
verifyPermissionMock.mockResolvedValue(undefined);
getPluginForTenantMock.mockReset();
auditFindManyMock.mockReset();
});
describe("plugin audit route", () => {
test("loader stops before plugin lookup and audit reads when audit permission is denied", async () => {
const denial = new Response("Forbidden", { status: 403 });
verifyPermissionMock.mockRejectedValueOnce(denial);
const { loader } = await import("./plugins.$id.audit.js");
await expect(
loader({
request: new Request("http://localhost/app/t-1/settings/plugins/pl-1/audit"),
params: { tenant: "t-1", id: "pl-1" },
context: {},
})
).rejects.toBe(denial);
expect(verifyPermissionMock).toHaveBeenCalledWith(expect.any(Request), "app.settings.auditTrails.view", "t-1");
expect(getPluginForTenantMock).not.toHaveBeenCalled();
expect(auditFindManyMock).not.toHaveBeenCalled();
});
test("loader caps and orders capability filter options deterministically", async () => {
getPluginForTenantMock.mockResolvedValue({
id: "pl-row-1",
pluginId: "com.acme.audit",
version: "1.0.0",
});
auditFindManyMock
.mockResolvedValueOnce([
{
id: "audit-1",
pluginInvocationId: "inv-1",
capability: "log",
outcome: "success",
errorCode: null,
durationMs: 12,
payloadHash: "hash-1",
timestamp: new Date("2026-05-27T10:00:00.000Z"),
},
])
.mockResolvedValueOnce([{ capability: "secret.read" }, { capability: "http.outbound" }, { capability: "log" }]);
const { loader } = await import("./plugins.$id.audit.js");
const response = await loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-row-1/audit"),
params: { tenant: "acme", id: "pl-row-1" },
context: {},
});
await expect(response.json()).resolves.toMatchObject({
capabilityOptions: ["http.outbound", "log", "secret.read"],
});
expect(auditFindManyMock).toHaveBeenNthCalledWith(
1,
expect.objectContaining({
select: {
id: true,
pluginInvocationId: true,
capability: true,
outcome: true,
errorCode: true,
durationMs: true,
payloadHash: true,
timestamp: true,
},
})
);
expect(auditFindManyMock).toHaveBeenNthCalledWith(
2,
expect.objectContaining({
distinct: ["capability"],
orderBy: [{ capability: "asc" }, { timestamp: "desc" }],
take: 32,
})
);
});
});
@@ -0,0 +1,340 @@
/**
* Phase 06 #23 — Plugin capability-use audit trail UI (tenant admin).
*
* Lists every PluginCapabilityUse row for a given Plugin row owned by
* the current tenant. Loader uses dbRead (read-replica when configured)
* since the page is read-only and the audit table is the chattiest in
* the plugin subsystem.
*
* Filters: capability name + date range (UTC day boundaries). Pagination
* is cursor-based (`timestamp` desc, `id` tiebreaker) — keyset rather
* than offset to stay cheap as the table grows. Cap at 100 rows / page.
*/
import type { LoaderFunctionArgs } from "react-router";
import { Form, Link, useLoaderData, useSearchParams } from "react-router";
import { useTranslation } from "react-i18next";
import { getTranslations } from "~/locale/i18next.server";
import { useLocaleFormatters } from "~/locale/format";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { dbRead } from "~/utils/db.server";
import { getPluginForTenant } from "~/modules/plugins/services/.server/PluginLifecycleService";
const PAGE_SIZE = 50;
const MAX_PAGE_SIZE = 100;
const CAPABILITY_FILTER_OPTION_LIMIT = 32;
type AuditRow = {
id: string;
pluginInvocationId: string;
capability: string;
outcome: string;
errorCode: string | null;
durationMs: number | null;
payloadHash: string | null;
timestamp: string;
};
type LoaderData = {
title: string;
tenantSlug: string;
plugin: {
id: string;
pluginId: string;
version: string;
};
filters: {
capability: string | null;
from: string | null;
to: string | null;
};
rows: ReadonlyArray<AuditRow>;
nextCursor: { ts: string; id: string } | null;
capabilityOptions: ReadonlyArray<string>;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.auditTrails.view", tenantId);
const { t } = await getTranslations(request);
const pluginRowId = params.id ?? "";
if (pluginRowId.length === 0) {
throw new Response(t("settings.plugins.errors.notFound"), { status: 404 });
}
const plugin = await getPluginForTenant({ tenantId, pluginRowId });
if (!plugin) {
throw new Response(t("settings.plugins.errors.pluginNotFound"), { status: 404 });
}
const url = new URL(request.url);
const capability = stringOrNull(url.searchParams.get("capability"));
const from = stringOrNull(url.searchParams.get("from"));
const to = stringOrNull(url.searchParams.get("to"));
const cursorTs = stringOrNull(url.searchParams.get("cursorTs"));
const cursorId = stringOrNull(url.searchParams.get("cursorId"));
const where: Record<string, unknown> = {
tenantId,
pluginId: plugin.pluginId,
};
if (capability) {
where.capability = capability;
}
if (from || to) {
const range: Record<string, Date> = {};
if (from) {
const d = parseDate(from);
if (d) range.gte = d;
}
if (to) {
const d = parseDate(to);
if (d) range.lt = addDays(d, 1); // exclusive upper bound
}
if (Object.keys(range).length > 0) {
where.timestamp = range;
}
}
if (cursorTs && cursorId) {
const cursorDate = parseDate(cursorTs) ?? new Date(cursorTs);
if (!Number.isNaN(cursorDate.getTime())) {
// Keyset pagination: (timestamp, id) tuple strictly before cursor.
where.OR = [
{ timestamp: { lt: cursorDate } },
{ timestamp: cursorDate, id: { lt: cursorId } },
];
}
}
// Capability options: distinct capability names seen in the last 30
// days for this plugin. Cheap because of the (tenantId, pluginId,
// timestamp DESC) index — bounded by row count, not table scan.
const since = addDays(new Date(), -30);
const [fetched, distinct] = await Promise.all([
dbRead.pluginCapabilityUse.findMany({
where: where as never,
select: {
id: true,
pluginInvocationId: true,
capability: true,
outcome: true,
errorCode: true,
durationMs: true,
payloadHash: true,
timestamp: true,
},
orderBy: [{ timestamp: "desc" }, { id: "desc" }],
take: Math.min(MAX_PAGE_SIZE, PAGE_SIZE) + 1,
}),
dbRead.pluginCapabilityUse.findMany({
where: { tenantId, pluginId: plugin.pluginId, timestamp: { gte: since } },
select: { capability: true },
distinct: ["capability"],
orderBy: [{ capability: "asc" }, { timestamp: "desc" }],
take: CAPABILITY_FILTER_OPTION_LIMIT,
}),
]);
const rowsPage = fetched.slice(0, PAGE_SIZE);
const nextCursor =
fetched.length > PAGE_SIZE && rowsPage.length > 0
? {
ts: rowsPage[rowsPage.length - 1]!.timestamp.toISOString(),
id: rowsPage[rowsPage.length - 1]!.id,
}
: null;
const data: LoaderData = {
title: `${t("settings.plugins.audit.title")} · ${plugin.pluginId}`,
tenantSlug: params.tenant ?? "",
plugin: { id: plugin.id, pluginId: plugin.pluginId, version: plugin.version },
filters: { capability, from, to },
rows: rowsPage.map((r) => ({
id: r.id,
pluginInvocationId: r.pluginInvocationId,
capability: r.capability,
outcome: r.outcome,
errorCode: r.errorCode ?? null,
durationMs: r.durationMs ?? null,
payloadHash: r.payloadHash ?? null,
timestamp: r.timestamp.toISOString(),
})),
nextCursor,
capabilityOptions: distinct.map((d) => d.capability).sort(),
};
return Response.json(data);
};
function stringOrNull(value: string | null): string | null {
if (!value) return null;
const trimmed = value.trim();
return trimmed.length === 0 ? null : trimmed;
}
function parseDate(input: string): Date | null {
// Accept YYYY-MM-DD and full ISO strings.
const tryYmd = /^\d{4}-\d{2}-\d{2}$/u.test(input) ? `${input}T00:00:00.000Z` : input;
const d = new Date(tryYmd);
if (Number.isNaN(d.getTime())) return null;
return d;
}
function addDays(date: Date, days: number): Date {
const d = new Date(date.getTime());
d.setUTCDate(d.getUTCDate() + days);
return d;
}
export default function PluginAuditTrailRoute() {
const data = useLoaderData<LoaderData>();
const [params] = useSearchParams();
const { t } = useTranslation();
const formatters = useLocaleFormatters();
const nextHref = data.nextCursor
? withParams(params, {
cursorTs: data.nextCursor.ts,
cursorId: data.nextCursor.id,
})
: null;
const outcomeLabel = (outcome: string) => {
if (outcome === "success" || outcome === "denied" || outcome === "error") {
return t(`settings.plugins.audit.outcomes.${outcome}`);
}
return outcome;
};
return (
<div className="space-y-6 p-6">
<header className="space-y-1">
<p className="text-xs text-gray-500">
<Link to={appPath({ tenantSlug: data.tenantSlug, path: "settings/plugins" })} className="text-blue-600 hover:underline">
{t("settings.plugins.audit.backToPlugins")}
</Link>
</p>
<h1 className="text-xl font-semibold">{t("settings.plugins.audit.heading")} · {data.plugin.pluginId}</h1>
<p className="text-sm text-gray-500">
{t("settings.plugins.audit.description")}
</p>
</header>
<Form method="get" className="flex flex-wrap items-end gap-3 rounded border border-gray-200 bg-white p-4">
<label className="flex flex-col text-xs text-gray-600">
<span className="mb-1">{t("settings.plugins.audit.filters.capability")}</span>
<select
name="capability"
defaultValue={data.filters.capability ?? ""}
className="rounded border border-gray-300 px-2 py-1 text-sm"
>
<option value="">{t("settings.plugins.audit.filters.all")}</option>
{data.capabilityOptions.map((cap) => (
<option key={cap} value={cap}>
{cap}
</option>
))}
</select>
</label>
<label className="flex flex-col text-xs text-gray-600">
<span className="mb-1">{t("settings.plugins.audit.filters.fromUtc")}</span>
<input
type="date"
name="from"
defaultValue={data.filters.from ?? ""}
className="rounded border border-gray-300 px-2 py-1 text-sm"
/>
</label>
<label className="flex flex-col text-xs text-gray-600">
<span className="mb-1">{t("settings.plugins.audit.filters.toUtc")}</span>
<input
type="date"
name="to"
defaultValue={data.filters.to ?? ""}
className="rounded border border-gray-300 px-2 py-1 text-sm"
/>
</label>
<button type="submit" className="rounded border border-gray-300 bg-white px-3 py-1 text-sm hover:bg-gray-50">
{t("settings.plugins.audit.filters.submit")}
</button>
<Link to="." className="text-xs text-gray-500 hover:underline">
{t("settings.plugins.audit.filters.reset")}
</Link>
</Form>
{data.rows.length === 0 ? (
<p className="rounded border border-dashed border-gray-300 p-6 text-sm text-gray-500">
{t("settings.plugins.audit.empty")}
</p>
) : (
<div className="overflow-x-auto rounded border border-gray-200">
<table className="w-full text-left text-sm">
<thead className="bg-gray-50 text-xs uppercase tracking-wide text-gray-500">
<tr>
<th className="px-3 py-2">{t("settings.plugins.audit.table.timestamp")}</th>
<th className="px-3 py-2">{t("settings.plugins.audit.table.capability")}</th>
<th className="px-3 py-2">{t("settings.plugins.audit.table.outcome")}</th>
<th className="px-3 py-2">{t("settings.plugins.audit.table.duration")}</th>
<th className="px-3 py-2">{t("settings.plugins.audit.table.invocation")}</th>
<th className="px-3 py-2">{t("settings.plugins.audit.table.payloadHash")}</th>
</tr>
</thead>
<tbody>
{data.rows.map((row) => (
<tr key={row.id} className="border-t border-gray-100">
<td className="px-3 py-2 font-mono text-xs text-gray-700">
{formatters.date(row.timestamp, { dateStyle: "medium", timeStyle: "medium" })}
</td>
<td className="px-3 py-2 font-mono text-xs">{row.capability}</td>
<td className="px-3 py-2 text-xs">
<span
className={
row.outcome === "success"
? "rounded bg-green-100 px-2 py-0.5 text-green-800"
: row.outcome === "denied"
? "rounded bg-amber-100 px-2 py-0.5 text-amber-800"
: "rounded bg-red-100 px-2 py-0.5 text-red-800"
}
>
{outcomeLabel(row.outcome)}
{row.errorCode ? ` · ${row.errorCode}` : ""}
</span>
</td>
<td className="px-3 py-2 text-xs text-gray-600">
{row.durationMs === null
? t("shared.notAvailable")
: t("settings.plugins.audit.durationMs", {
duration: formatters.number(row.durationMs),
})}
</td>
<td className="px-3 py-2 font-mono text-xs text-gray-500" title={row.pluginInvocationId}>
{row.pluginInvocationId.slice(0, 8)}…
</td>
<td className="px-3 py-2 font-mono text-xs text-gray-500" title={row.payloadHash ?? ""}>
{row.payloadHash ? `${row.payloadHash.slice(0, 12)}…` : t("shared.notSet")}
</td>
</tr>
))}
</tbody>
</table>
</div>
)}
{nextHref ? (
<div className="flex justify-end">
<Link to={`?${nextHref}`} className="rounded border border-gray-300 bg-white px-3 py-1 text-sm hover:bg-gray-50">
{t("settings.plugins.audit.nextPage")}
</Link>
</div>
) : null}
</div>
);
}
function withParams(current: URLSearchParams, next: Record<string, string>): string {
const merged = new URLSearchParams(current);
for (const [k, v] of Object.entries(next)) {
merged.set(k, v);
}
return merged.toString();
}
@@ -0,0 +1,669 @@
import { beforeEach, describe, expect, test, vi } from "vitest";
const getTenantIdMock = vi.fn().mockResolvedValue("tenant-1");
const verifyPermissionMock = vi.fn().mockResolvedValue(undefined);
const loadPluginSettingsPageDataMock = vi.fn();
const setPluginUserSettingMock = vi.fn();
const reportPluginSettingsFrameViolationMock = vi.fn();
const getUserInfoMock = vi.fn();
const validateCSRFTokenMock = vi.fn();
const getUserMock = vi.fn();
const consumeRateLimitMock = vi.fn();
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: (...args: unknown[]) => getTenantIdMock(...args),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: (...args: unknown[]) => verifyPermissionMock(...args),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: (...args: unknown[]) => getUserInfoMock(...args),
validateCSRFToken: (...args: unknown[]) => validateCSRFTokenMock(...args),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: (...args: unknown[]) => getUserMock(...args),
}));
vi.mock("~/shared-store.server", () => ({
getSharedStore: vi.fn(() => ({ kind: "test-store" })),
}));
vi.mock("@toolctrl/shared-store", () => ({
createSlidingWindowRateLimiter: vi.fn(() => ({
consume: (...args: unknown[]) => consumeRateLimitMock(...args),
})),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string, vars?: Record<string, unknown>) => (vars ? `${key}:${JSON.stringify(vars)}` : key),
})),
}));
vi.mock("~/modules/plugins/services/.server/PluginSettingsService", () => {
class PluginSettingsServiceError extends Error {
constructor(
public readonly code: string,
message: string
) {
super(message);
}
}
return {
PluginSettingsServiceError,
loadPluginSettingsPageData: (...args: unknown[]) => loadPluginSettingsPageDataMock(...args),
reportPluginSettingsFrameViolation: (...args: unknown[]) => reportPluginSettingsFrameViolationMock(...args),
setPluginUserSetting: (...args: unknown[]) => setPluginUserSettingMock(...args),
};
});
beforeEach(() => {
getTenantIdMock.mockClear();
verifyPermissionMock.mockReset();
verifyPermissionMock.mockResolvedValue(undefined);
loadPluginSettingsPageDataMock.mockReset();
setPluginUserSettingMock.mockReset();
reportPluginSettingsFrameViolationMock.mockReset();
reportPluginSettingsFrameViolationMock.mockResolvedValue(undefined);
getUserInfoMock.mockReset();
getUserInfoMock.mockResolvedValue({ userId: "user-1" });
validateCSRFTokenMock.mockReset();
validateCSRFTokenMock.mockResolvedValue(undefined);
getUserMock.mockReset();
getUserMock.mockResolvedValue({ email: "user@example.com" });
consumeRateLimitMock.mockReset();
consumeRateLimitMock.mockResolvedValue({ allowed: true });
});
describe("plugin settings route", () => {
test("headers add anti-framing policy while preserving server timing", async () => {
const { headers } = await import("./plugins.$id.js");
const responseHeaders = headers({
loaderHeaders: new Headers({ "Server-Timing": "plugin;dur=12" }),
parentHeaders: new Headers(),
actionHeaders: new Headers(),
errorHeaders: undefined,
});
expect(responseHeaders.get("Content-Security-Policy")).toBe(
"default-src 'self'; script-src 'self'; connect-src 'self'; img-src 'self' data: blob:; font-src 'self' data:; style-src 'self' 'unsafe-inline'; frame-src 'self'; child-src 'self'; worker-src 'none'; media-src 'none'; manifest-src 'none'; frame-ancestors 'self'; base-uri 'self'; object-src 'none'; form-action 'self'; navigate-to 'self'"
);
expect(responseHeaders.get("X-Frame-Options")).toBe("SAMEORIGIN");
expect(responseHeaders.get("Server-Timing")).toBe("plugin;dur=12");
});
test("headers deny powerful browser capabilities for embedded plugin settings", async () => {
const { headers } = await import("./plugins.$id.js");
const responseHeaders = headers({
loaderHeaders: new Headers(),
parentHeaders: new Headers(),
actionHeaders: new Headers(),
errorHeaders: undefined,
});
const policy = responseHeaders.get("Permissions-Policy") ?? "";
for (const directive of [
"camera=()",
"microphone=()",
"geolocation=()",
"clipboard-read=()",
"clipboard-write=()",
"display-capture=()",
"fullscreen=()",
"payment=()",
"storage-access=()",
"usb=()",
"web-share=()",
]) {
expect(policy).toContain(directive);
}
expect(policy).not.toContain("*");
expect(policy).not.toContain("self");
});
test("loader stops before settings lookup when use permission is denied", async () => {
const denial = new Response("Forbidden", { status: 403 });
verifyPermissionMock.mockRejectedValueOnce(denial);
const { loader } = await import("./plugins.$id.js");
await expect(
loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1"),
params: { tenant: "acme", id: "pl-1" },
context: {},
})
).rejects.toBe(denial);
expect(verifyPermissionMock).toHaveBeenCalledWith(expect.any(Request), "app.plugins.use", "tenant-1");
expect(loadPluginSettingsPageDataMock).not.toHaveBeenCalled();
});
test("loader returns plugin frame HTML and per-user settings for tenant-scoped plugins", async () => {
loadPluginSettingsPageDataMock.mockResolvedValue({
plugin: { id: "pl-1", pluginId: "com.acme.settings", version: "1.0.0" },
entry: "ui/settings.html",
trustedHtml: "<main>Settings</main>",
settings: { theme: "dark" },
});
const { loader } = await import("./plugins.$id.js");
const response = await loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1"),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
await expect(response.json()).resolves.toMatchObject({
plugin: { id: "pl-1", pluginId: "com.acme.settings", version: "1.0.0" },
trustedHtml: "<main>Settings</main>",
settings: { theme: "dark" },
});
expect(loadPluginSettingsPageDataMock).toHaveBeenCalledWith({ tenantId: "tenant-1", pluginRowId: "pl-1", userId: "user-1" });
});
test("loader stops before settings lookup when no authenticated user is available", async () => {
getUserInfoMock.mockResolvedValueOnce({ userId: null });
const { loader } = await import("./plugins.$id.js");
await expect(
loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1"),
params: { tenant: "acme", id: "pl-1" },
context: {},
})
).rejects.toMatchObject({ status: 401 });
expect(loadPluginSettingsPageDataMock).not.toHaveBeenCalled();
});
test("loader maps missing settings UI to 404", async () => {
const { PluginSettingsServiceError } = await import("~/modules/plugins/services/.server/PluginSettingsService");
loadPluginSettingsPageDataMock.mockRejectedValue(new PluginSettingsServiceError("settings_ui_unavailable", "no ui"));
const { loader } = await import("./plugins.$id.js");
await expect(
loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1"),
params: { tenant: "acme", id: "pl-1" },
context: {},
})
).rejects.toMatchObject({ status: 404 });
});
test("loader maps unsafe and oversized settings UI errors to hardened statuses", async () => {
const { PluginSettingsServiceError } = await import("~/modules/plugins/services/.server/PluginSettingsService");
const { loader } = await import("./plugins.$id.js");
loadPluginSettingsPageDataMock.mockRejectedValueOnce(new PluginSettingsServiceError("settings_ui_entry_unsafe", "unsafe"));
await expect(
loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1"),
params: { tenant: "acme", id: "pl-1" },
context: {},
})
).rejects.toMatchObject({ status: 400 });
loadPluginSettingsPageDataMock.mockRejectedValueOnce(new PluginSettingsServiceError("settings_ui_file_too_large", "too large"));
await expect(
loader({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1"),
params: { tenant: "acme", id: "pl-1" },
context: {},
})
).rejects.toMatchObject({ status: 413 });
});
test("action stores one setting through the per-user settings service", async () => {
setPluginUserSettingMock.mockResolvedValue({ key: "theme", value: "light", settings: { theme: "light" } });
const { action } = await import("./plugins.$id.js");
const request = new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json", "x-forwarded-for": "203.0.113.5" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
});
const response = await action({
request,
params: { tenant: "acme", id: "pl-1" },
context: {},
});
await expect(response.json()).resolves.toEqual({ ok: true, key: "theme", value: "light", settings: { theme: "light" } });
expect(verifyPermissionMock).toHaveBeenCalledWith(request, "app.plugins.use", "tenant-1");
expect(validateCSRFTokenMock).toHaveBeenCalledWith(request, { headerOnly: true });
expect(setPluginUserSettingMock).toHaveBeenCalledWith({
tenantId: "tenant-1",
pluginRowId: "pl-1",
userId: "user-1",
key: "theme",
value: "light",
actor: { userId: "user-1", email: "user@example.com", ip: "203.0.113.5" },
});
});
test("action accepts json content types with charset parameters", async () => {
setPluginUserSettingMock.mockResolvedValue({ key: "theme", value: "light", settings: { theme: "light" } });
const { action } = await import("./plugins.$id.js");
const request = new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json; charset=utf-8" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
});
const response = await action({
request,
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(200);
await expect(response.json()).resolves.toMatchObject({ ok: true, key: "theme" });
expect(consumeRateLimitMock).toHaveBeenCalledOnce();
expect(setPluginUserSettingMock).toHaveBeenCalledOnce();
});
test("action reports plugin settings frame violations without persisting settings", async () => {
const { action } = await import("./plugins.$id.js");
const request = new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json", "x-forwarded-for": "203.0.113.7" },
body: JSON.stringify({ op: "reportFrameViolation", reason: "wrong_origin", csrf: "csrf-token" }),
});
const response = await action({
request,
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(200);
await expect(response.json()).resolves.toEqual({ ok: true });
expect(verifyPermissionMock).toHaveBeenCalledWith(request, "app.plugins.use", "tenant-1");
expect(validateCSRFTokenMock).toHaveBeenCalledWith(request, { headerOnly: true });
expect(consumeRateLimitMock).toHaveBeenCalledWith("tenant:tenant-1:user:user-1:plugin:pl-1:reason:wrong_origin");
expect(reportPluginSettingsFrameViolationMock).toHaveBeenCalledWith({
tenantId: "tenant-1",
pluginRowId: "pl-1",
reason: "wrong_origin",
actor: { userId: "user-1", email: "user@example.com", ip: "203.0.113.7" },
});
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action rejects invalid plugin settings frame violation reasons before rate limiting", async () => {
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "reportFrameViolation", reason: "raw-payload", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: "invalid_frame_violation_reason",
message: "settings.plugins.settings.errors.invalid_frame_violation_reason",
});
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(reportPluginSettingsFrameViolationMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action rate limits plugin settings frame violation reports", async () => {
consumeRateLimitMock.mockResolvedValueOnce({ allowed: false });
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "reportFrameViolation", reason: "wrong_source", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(429);
expect(response.headers.get("Retry-After")).toBe("60");
await expect(response.json()).resolves.toEqual({
error: "rate_limited",
message: 'settings.plugins.settings.errors.rate_limited:{"perMin":120}',
});
expect(reportPluginSettingsFrameViolationMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action denies setting writes with use permission before CSRF and body parsing", async () => {
const denial = new Response("Forbidden", { status: 403 });
verifyPermissionMock.mockRejectedValueOnce(denial);
const { action } = await import("./plugins.$id.js");
await expect(
action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: "{",
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
})
).rejects.toBe(denial);
expect(verifyPermissionMock).toHaveBeenCalledWith(expect.any(Request), "app.plugins.use", "tenant-1");
expect(validateCSRFTokenMock).not.toHaveBeenCalled();
expect(getUserInfoMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action rejects non-json setting writes before parsing or rate limiting", async () => {
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "text/plain" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(415);
await expect(response.json()).resolves.toEqual({
error: "unsupported_media_type",
message: "settings.plugins.settings.errors.unsupported_media_type",
});
expect(validateCSRFTokenMock).not.toHaveBeenCalled();
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action validates op and key before user lookup or setting writes", async () => {
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "getSetting", key: "theme", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: "missing_fields",
message: "settings.plugins.settings.errors.missing_fields",
});
expect(validateCSRFTokenMock).toHaveBeenCalled();
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action validates setting key and value schema before rate limiting or persistence", async () => {
const { action } = await import("./plugins.$id.js");
const cases = [
{ key: "../theme", value: "dark", error: "settings_key_invalid" },
{ key: "__proto__", value: "polluted", error: "settings_key_invalid" },
{ key: "apiKey", value: "abc", error: "settings_key_secret_like" },
{ key: "authorization", value: "Bearer abc", error: "settings_key_secret_like" },
{ key: "clientSecret", value: "abc", error: "settings_key_secret_like" },
{ key: "theme", value: undefined, error: "settings_value_invalid" },
{ key: "appearance", value: { theme: { accessToken: "must-not-persist" } }, error: "settings_value_invalid" },
{ key: "appearance", value: { headers: { authorization: "Bearer must-not-persist" } }, error: "settings_value_invalid" },
{ key: "blob", value: "x".repeat(33 * 1024), error: "settings_value_too_large" },
];
for (const item of cases) {
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: item.key, value: item.value, csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status, item.error).toBe(400);
await expect(response.json()).resolves.toEqual({
error: item.error,
message: `settings.plugins.settings.errors.${item.error}`,
});
}
expect(validateCSRFTokenMock).toHaveBeenCalledTimes(cases.length);
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action returns 400 for malformed settings JSON", async () => {
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: "{",
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: "invalid_json",
message: "settings.plugins.settings.errors.invalid_json",
});
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action rejects oversized settings JSON before parsing and rate limiting", async () => {
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json", "content-length": String(81 * 1024) },
body: JSON.stringify({ op: "setSetting", key: "blob", value: "x" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: "invalid_json",
message: "settings.plugins.settings.errors.invalid_json",
});
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action rejects oversized settings JSON even when content-length is absent", async () => {
const { action } = await import("./plugins.$id.js");
const oversizedValue = "x".repeat(81 * 1024);
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: "blob", value: oversizedValue }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: "invalid_json",
message: "settings.plugins.settings.errors.invalid_json",
});
expect(consumeRateLimitMock).not.toHaveBeenCalled();
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action rate limits per-user plugin setting writes before persistence", async () => {
consumeRateLimitMock.mockResolvedValueOnce({ allowed: false });
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(429);
expect(response.headers.get("Retry-After")).toBe("60");
await expect(response.json()).resolves.toEqual({
error: "rate_limited",
message: 'settings.plugins.settings.errors.rate_limited:{"perMin":60}',
});
expect(getUserMock).not.toHaveBeenCalled();
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
});
test("action fails open when plugin settings rate limit storage is unavailable", async () => {
consumeRateLimitMock.mockRejectedValueOnce(new Error("redis unavailable"));
setPluginUserSettingMock.mockResolvedValue({ key: "theme", value: "light", settings: { theme: "light" } });
const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(200);
await expect(response.json()).resolves.toMatchObject({ ok: true, key: "theme" });
expect(setPluginUserSettingMock).toHaveBeenCalledOnce();
expect(warn).toHaveBeenCalledWith("[plugin-settings] rate-limit infra failure; allowing settings write:", "redis unavailable");
warn.mockRestore();
});
test("action fails closed in production when plugin settings rate limit storage is unavailable", async () => {
const originalNodeEnv = process.env.NODE_ENV;
const originalFailOpen = process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN;
process.env.NODE_ENV = "production";
delete process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN;
consumeRateLimitMock.mockRejectedValueOnce(new Error("redis unavailable"));
const { action } = await import("./plugins.$id.js");
try {
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(503);
expect(response.headers.get("Retry-After")).toBe("60");
await expect(response.json()).resolves.toEqual({
error: "rate_limit_unavailable",
message: "settings.plugins.settings.errors.rate_limit_unavailable",
});
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
} finally {
if (originalNodeEnv === undefined) delete process.env.NODE_ENV;
else process.env.NODE_ENV = originalNodeEnv;
if (originalFailOpen === undefined) delete process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN;
else process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN = originalFailOpen;
}
});
test("action ignores the fail-open escape hatch in production when plugin settings rate limit storage is unavailable", async () => {
const originalNodeEnv = process.env.NODE_ENV;
const originalFailOpen = process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN;
process.env.NODE_ENV = "production";
process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN = "true";
consumeRateLimitMock.mockRejectedValueOnce(new Error("redis unavailable"));
const { action } = await import("./plugins.$id.js");
try {
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(503);
await expect(response.json()).resolves.toEqual({
error: "rate_limit_unavailable",
message: "settings.plugins.settings.errors.rate_limit_unavailable",
});
expect(setPluginUserSettingMock).not.toHaveBeenCalled();
} finally {
if (originalNodeEnv === undefined) delete process.env.NODE_ENV;
else process.env.NODE_ENV = originalNodeEnv;
if (originalFailOpen === undefined) delete process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN;
else process.env.PLUGIN_RATE_LIMIT_FAIL_OPEN = originalFailOpen;
}
});
test("action uses x-real-ip when x-forwarded-for is absent", async () => {
setPluginUserSettingMock.mockResolvedValue({ key: "theme", value: "light", settings: { theme: "light" } });
const { action } = await import("./plugins.$id.js");
await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json", "x-real-ip": "198.51.100.9" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(setPluginUserSettingMock).toHaveBeenCalledWith(expect.objectContaining({ actor: expect.objectContaining({ ip: "198.51.100.9" }) }));
});
test("action maps service validation errors to localized JSON responses", async () => {
const { PluginSettingsServiceError } = await import("~/modules/plugins/services/.server/PluginSettingsService");
setPluginUserSettingMock.mockRejectedValue(new PluginSettingsServiceError("settings_value_invalid", "invalid value"));
const { action } = await import("./plugins.$id.js");
const response = await action({
request: new Request("http://localhost/app/acme/settings/plugins/pl-1", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ op: "setSetting", key: "appearance", value: { theme: "dark" }, csrf: "csrf-token" }),
}),
params: { tenant: "acme", id: "pl-1" },
context: {},
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: "settings_value_invalid",
message: "settings.plugins.settings.errors.settings_value_invalid",
});
});
});
@@ -0,0 +1,481 @@
import { useCallback, useMemo, useRef, useState } from "react";
import type { ActionFunctionArgs, HeadersFunction, LoaderFunctionArgs } from "react-router";
import { Link, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { createSlidingWindowRateLimiter } from "@toolctrl/shared-store";
import { getTranslations } from "~/locale/i18next.server";
import { PluginSettingsFrame } from "~/modules/plugins/components/PluginSettingsFrame";
import {
loadPluginSettingsPageData,
PluginSettingsServiceError,
reportPluginSettingsFrameViolation,
setPluginUserSetting,
type PluginSettingsFrameViolationReason,
type PluginSettingValue,
type PluginUserSettings,
} from "~/modules/plugins/services/.server/PluginSettingsService";
import {
isPluginSettingKeyFormatSafe,
isPluginSettingKeyReserved,
isPluginSettingKeySecretLike,
isPluginSettingValueShapeSafe,
isPluginSettingValueWithinSize,
} from "~/modules/plugins/utils/pluginSettingsValidation";
import { getSharedStore } from "~/shared-store.server";
import { serverTimingHeaders } from "~/modules/metrics/utils/defaultHeaders";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { useRootData } from "~/utils/data/useRootData";
import { getUser } from "~/utils/db/users.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
title: string;
tenantSlug: string;
plugin: {
id: string;
pluginId: string;
version: string;
};
trustedHtml: string;
settings: PluginUserSettings;
};
const SETTINGS_WRITE_RATE_LIMIT_PREFIX = "plugin-settings-write-route:rl";
const SETTINGS_FRAME_VIOLATION_RATE_LIMIT_PREFIX = "plugin-settings-frame-violation-route:rl";
const PLUGIN_SETTINGS_ROUTE_MAX_BODY_BYTES = 80 * 1024;
const PLUGIN_SETTINGS_FRAME_VIOLATION_REPORT_INTERVAL_MS = 60_000;
const PLUGIN_SETTINGS_FRAME_VIOLATION_REASONS = new Set<PluginSettingsFrameViolationReason>([
"wrong_origin",
"wrong_source",
"invalid_payload",
"unexpected_navigation",
]);
const PLUGIN_SETTINGS_ROUTE_CSP = [
"default-src 'self'",
"script-src 'self'",
"connect-src 'self'",
"img-src 'self' data: blob:",
"font-src 'self' data:",
"style-src 'self' 'unsafe-inline'",
"frame-src 'self'",
"child-src 'self'",
"worker-src 'none'",
"media-src 'none'",
"manifest-src 'none'",
"frame-ancestors 'self'",
"base-uri 'self'",
"object-src 'none'",
"form-action 'self'",
"navigate-to 'self'",
].join("; ");
const PLUGIN_SETTINGS_ROUTE_PERMISSION_POLICY = [
"accelerometer=()",
"ambient-light-sensor=()",
"autoplay=()",
"bluetooth=()",
"camera=()",
"clipboard-read=()",
"clipboard-write=()",
"display-capture=()",
"encrypted-media=()",
"fullscreen=()",
"gamepad=()",
"geolocation=()",
"gyroscope=()",
"hid=()",
"identity-credentials-get=()",
"idle-detection=()",
"local-fonts=()",
"magnetometer=()",
"microphone=()",
"midi=()",
"otp-credentials=()",
"payment=()",
"picture-in-picture=()",
"publickey-credentials-get=()",
"screen-wake-lock=()",
"serial=()",
"speaker-selection=()",
"storage-access=()",
"usb=()",
"web-share=()",
"xr-spatial-tracking=()",
].join(", ");
export const headers: HeadersFunction = (args) => {
const responseHeaders = new Headers(serverTimingHeaders(args));
responseHeaders.set("Content-Security-Policy", PLUGIN_SETTINGS_ROUTE_CSP);
responseHeaders.set("Permissions-Policy", PLUGIN_SETTINGS_ROUTE_PERMISSION_POLICY);
responseHeaders.set("X-Frame-Options", "SAMEORIGIN");
return responseHeaders;
};
function shouldFailClosedOnRateLimitInfraFailure(): boolean {
return process.env.NODE_ENV === "production";
}
type JsonObjectResult = { ok: true; value: Record<string, unknown> } | { ok: false };
type SettingsWritePayloadError = "settings_key_invalid" | "settings_key_secret_like" | "settings_value_invalid" | "settings_value_too_large";
function hasJsonContentType(request: Request): boolean {
const contentType = request.headers.get("content-type")?.toLowerCase() ?? "";
return contentType.split(";", 1)[0]?.trim() === "application/json";
}
async function readJsonObject(request: Request): Promise<JsonObjectResult> {
const contentLength = Number(request.headers.get("content-length") ?? "0");
if (Number.isFinite(contentLength) && contentLength > PLUGIN_SETTINGS_ROUTE_MAX_BODY_BYTES) {
return { ok: false };
}
try {
const text = await readLimitedRequestText(request, PLUGIN_SETTINGS_ROUTE_MAX_BODY_BYTES);
if (text === null) return { ok: false };
const value = JSON.parse(text) as unknown;
if (!value || typeof value !== "object" || Array.isArray(value)) {
return { ok: false };
}
return { ok: true, value: value as Record<string, unknown> };
} catch {
return { ok: false };
}
}
async function readLimitedRequestText(request: Request, maxBytes: number): Promise<string | null> {
if (!request.body) return null;
const reader = request.body.getReader();
const decoder = new TextDecoder();
let bytes = 0;
let text = "";
try {
while (true) {
const { done, value } = await reader.read();
if (done) break;
bytes += value.byteLength;
if (bytes > maxBytes) {
await reader.cancel();
return null;
}
text += decoder.decode(value, { stream: true });
}
text += decoder.decode();
return text;
} finally {
reader.releaseLock();
}
}
function resolveSettingsWriteRateLimitPerMin(): number {
const raw = process.env.PLUGIN_SETTINGS_WRITE_RATE_LIMIT_PER_MIN;
if (typeof raw !== "string" || raw.length === 0) return 60;
const parsed = Number.parseInt(raw, 10);
if (!Number.isFinite(parsed) || parsed <= 0) return 60;
return parsed;
}
function resolveFrameViolationRateLimitPerMin(): number {
const raw = process.env.PLUGIN_SETTINGS_FRAME_VIOLATION_RATE_LIMIT_PER_MIN;
if (typeof raw !== "string" || raw.length === 0) return 120;
const parsed = Number.parseInt(raw, 10);
if (!Number.isFinite(parsed) || parsed <= 0) return 120;
return parsed;
}
function getPluginSettingsLoaderErrorStatus(code: PluginSettingsServiceError["code"]): number {
if (code === "settings_ui_file_too_large") return 413;
if (code === "settings_ui_entry_unsafe") return 400;
return 404;
}
function getSettingsWritePayloadError(key: string, value: unknown): SettingsWritePayloadError | null {
if (!isPluginSettingKeyFormatSafe(key) || isPluginSettingKeyReserved(key)) {
return "settings_key_invalid";
}
if (isPluginSettingKeySecretLike(key)) {
return "settings_key_secret_like";
}
if (!isPluginSettingValueShapeSafe(value)) {
return "settings_value_invalid";
}
return isPluginSettingValueWithinSize(value) ? null : "settings_value_too_large";
}
function isPluginSettingsFrameViolationReason(reason: unknown): reason is PluginSettingsFrameViolationReason {
return typeof reason === "string" && PLUGIN_SETTINGS_FRAME_VIOLATION_REASONS.has(reason as PluginSettingsFrameViolationReason);
}
// The settings iframe writes hit this UI route's action through React Router's
// single-fetch endpoint (`<path>.data`), so the action's `Response.json(...)`
// comes back turbo-stream encoded (`text/x-script`) rather than as raw JSON.
// Decode that envelope (`{ data: <actionResult> }`) here; keep the plain-JSON
// branch for any caller that still receives a raw JSON response.
function pluginSettingsActionUrl(): string {
// The component is rendered at the plugin-settings DETAIL route, so the current
// pathname IS that route. A bare `fetch(".")` would resolve to the parent
// plugins-list route (its action does not handle setSetting), so target the
// detail route's single-fetch endpoint explicitly.
return `${window.location.pathname.replace(/\/$/u, "")}.data`;
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.plugins.use", tenantId);
const [{ t }, userInfo] = await Promise.all([getTranslations(request), getUserInfo(request)]);
if (!userInfo.userId) {
throw new Response(t("settings.plugins.settings.errors.unauthorized"), { status: 401 });
}
const pluginRowId = params.id ?? "";
if (pluginRowId.length === 0) {
throw new Response(t("settings.plugins.errors.notFound"), { status: 404 });
}
try {
const settingsPage = await loadPluginSettingsPageData({ tenantId, pluginRowId, userId: userInfo.userId });
const data: LoaderData = {
title: `${t("settings.plugins.settings.title")} · ${settingsPage.plugin.pluginId}`,
tenantSlug: params.tenant ?? "",
plugin: {
id: settingsPage.plugin.id,
pluginId: settingsPage.plugin.pluginId,
version: settingsPage.plugin.version,
},
trustedHtml: settingsPage.trustedHtml,
settings: settingsPage.settings,
};
return Response.json(data);
} catch (error) {
if (error instanceof PluginSettingsServiceError) {
throw new Response(t(`settings.plugins.settings.errors.${error.code}`), { status: getPluginSettingsLoaderErrorStatus(error.code) });
}
throw error;
}
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.plugins.use", tenantId);
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
if (!userInfo.userId) {
return Response.json({ error: "unauthorized", message: t("settings.plugins.settings.errors.unauthorized") }, { status: 401 });
}
const pluginRowId = params.id ?? "";
if (pluginRowId.length === 0) {
return Response.json({ error: "plugin_not_found", message: t("settings.plugins.errors.notFound") }, { status: 404 });
}
if (!hasJsonContentType(request)) {
return Response.json({ error: "unsupported_media_type", message: t("settings.plugins.settings.errors.unsupported_media_type") }, { status: 415 });
}
await validateCSRFToken(request, { headerOnly: true });
const parsed = await readJsonObject(request);
if (!parsed.ok) {
return Response.json({ error: "invalid_json", message: t("settings.plugins.settings.errors.invalid_json") }, { status: 400 });
}
const body = parsed.value as { op?: unknown; key?: unknown; value?: unknown; reason?: unknown };
if (body.op === "reportFrameViolation") {
if (!isPluginSettingsFrameViolationReason(body.reason)) {
return Response.json({ error: "invalid_frame_violation_reason", message: t("settings.plugins.settings.errors.invalid_frame_violation_reason") }, { status: 400 });
}
try {
const perMin = resolveFrameViolationRateLimitPerMin();
const limiter = createSlidingWindowRateLimiter({
store: getSharedStore(),
max: perMin,
windowSeconds: 60,
prefix: SETTINGS_FRAME_VIOLATION_RATE_LIMIT_PREFIX,
});
const decision = await limiter.consume(`tenant:${tenantId}:user:${userInfo.userId}:plugin:${pluginRowId}:reason:${body.reason}`);
if (!decision.allowed) {
return Response.json(
{ error: "rate_limited", message: t("settings.plugins.settings.errors.rate_limited", { perMin }) },
{ status: 429, headers: { "Retry-After": "60" } }
);
}
} catch (error) {
if (shouldFailClosedOnRateLimitInfraFailure()) {
return Response.json(
{ error: "rate_limit_unavailable", message: t("settings.plugins.settings.errors.rate_limit_unavailable") },
{ status: 503, headers: { "Retry-After": "60" } }
);
}
// eslint-disable-next-line no-console
console.warn("[plugin-settings] frame-violation rate-limit infra failure; allowing audit report:", error instanceof Error ? error.message : String(error));
}
try {
const user = await getUser(userInfo.userId);
await reportPluginSettingsFrameViolation({
tenantId,
pluginRowId,
reason: body.reason,
actor: {
userId: userInfo.userId,
email: user?.email ?? null,
ip: request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? null,
},
});
return Response.json({ ok: true });
} catch (error) {
if (error instanceof PluginSettingsServiceError) {
const status = error.code === "plugin_not_found" ? 404 : 400;
return Response.json({ error: error.code, message: t(`settings.plugins.settings.errors.${error.code}`) }, { status });
}
throw error;
}
}
if (body.op !== "setSetting" || typeof body.key !== "string") {
return Response.json({ error: "missing_fields", message: t("settings.plugins.settings.errors.missing_fields") }, { status: 400 });
}
const payloadError = getSettingsWritePayloadError(body.key, body.value);
if (payloadError) {
return Response.json({ error: payloadError, message: t(`settings.plugins.settings.errors.${payloadError}`) }, { status: 400 });
}
try {
const perMin = resolveSettingsWriteRateLimitPerMin();
const limiter = createSlidingWindowRateLimiter({
store: getSharedStore(),
max: perMin,
windowSeconds: 60,
prefix: SETTINGS_WRITE_RATE_LIMIT_PREFIX,
});
const decision = await limiter.consume(`tenant:${tenantId}:user:${userInfo.userId}:plugin:${pluginRowId}`);
if (!decision.allowed) {
return Response.json(
{ error: "rate_limited", message: t("settings.plugins.settings.errors.rate_limited", { perMin }) },
{ status: 429, headers: { "Retry-After": "60" } }
);
}
} catch (error) {
if (shouldFailClosedOnRateLimitInfraFailure()) {
return Response.json(
{ error: "rate_limit_unavailable", message: t("settings.plugins.settings.errors.rate_limit_unavailable") },
{ status: 503, headers: { "Retry-After": "60" } }
);
}
// Failing open keeps legitimate plugin settings usable outside
// production during a transient shared-store outage; the service still
// enforces key and value safety before any write reaches the database.
// eslint-disable-next-line no-console
console.warn("[plugin-settings] rate-limit infra failure; allowing settings write:", error instanceof Error ? error.message : String(error));
}
try {
const user = await getUser(userInfo.userId);
const result = await setPluginUserSetting({
tenantId,
pluginRowId,
userId: userInfo.userId,
key: body.key,
value: body.value as PluginSettingValue,
actor: {
userId: userInfo.userId,
email: user?.email ?? null,
ip: request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? null,
},
});
return Response.json({ ok: true, key: result.key, value: result.value, settings: result.settings });
} catch (error) {
if (error instanceof PluginSettingsServiceError) {
const status = error.code === "plugin_not_found" ? 404 : 400;
return Response.json({ error: error.code, message: t(`settings.plugins.settings.errors.${error.code}`) }, { status });
}
throw error;
}
};
export default function TenantPluginSettingsRoute() {
const data = useLoaderData<LoaderData>();
const { csrf } = useRootData();
const { t } = useTranslation();
const [settings, setSettings] = useState<PluginUserSettings>(data.settings);
const frameViolationReportedAtRef = useRef(new Map<PluginSettingsFrameViolationReason, number>());
const frameErrorMessages = useMemo(
() => ({
invalid_payload: t("settings.plugins.settings.frameErrors.invalid_payload"),
settings_unavailable: t("settings.plugins.settings.frameErrors.settings_unavailable"),
settings_update_failed: t("settings.plugins.settings.frameErrors.settings_update_failed"),
}),
[t]
);
const getSetting = useCallback((key: string) => settings[key], [settings]);
const setSetting = useCallback(
async (key: string, value: PluginSettingValue) => {
const fallbackMessage = t("settings.plugins.settings.frameErrors.settings_update_failed");
const response = await fetch(pluginSettingsActionUrl(), {
method: "POST",
headers: {
"content-type": "application/json",
...(csrf ? { "x-csrf-token": csrf } : {}),
},
body: JSON.stringify({ op: "setSetting", key, value, csrf }),
});
// The write reaches this UI route's action through React Router's
// single-fetch endpoint, so the response body is turbo-stream encoded
// rather than the action's raw JSON. The HTTP status is authoritative
// (2xx = persisted, 4xx = rejected with a localized reason), so gate on it
// instead of parsing the body, and reflect the written value locally to
// keep the settings frame state in sync without a reload.
if (!response.ok) {
throw new Error(fallbackMessage);
}
setSettings((current) => ({ ...current, [key]: value ?? null }));
},
[csrf]
);
const reportFrameViolation = useCallback(
(reason: PluginSettingsFrameViolationReason) => {
const now = Date.now();
const lastReportedAt = frameViolationReportedAtRef.current.get(reason) ?? 0;
if (now - lastReportedAt < PLUGIN_SETTINGS_FRAME_VIOLATION_REPORT_INTERVAL_MS) {
return;
}
frameViolationReportedAtRef.current.set(reason, now);
void Promise.resolve(
fetch(pluginSettingsActionUrl(), {
method: "POST",
headers: {
"content-type": "application/json",
...(csrf ? { "x-csrf-token": csrf } : {}),
},
body: JSON.stringify({ op: "reportFrameViolation", reason, csrf }),
})
).catch(() => undefined);
},
[csrf]
);
return (
<div className="space-y-6 p-6" data-ui-id="ui.plugins.settings.page">
<header className="space-y-1">
<p className="text-xs text-gray-500">
<Link to={appPath({ tenantSlug: data.tenantSlug, path: "settings/plugins" })} className="text-blue-600 hover:underline">
{t("settings.plugins.audit.backToPlugins")}
</Link>
</p>
<h1 className="text-xl font-semibold">{t("settings.plugins.settings.heading", { pluginId: data.plugin.pluginId })}</h1>
<p className="text-sm text-gray-500">{t("settings.plugins.settings.description")}</p>
</header>
<PluginSettingsFrame
pluginId={data.plugin.pluginId}
title={t("settings.plugins.settings.frameTitle", { pluginId: data.plugin.pluginId })}
trustedHtml={data.trustedHtml}
settings={settings}
errorMessages={frameErrorMessages}
onGetSetting={getSetting}
onSetSetting={setSetting}
onInvalidMessage={reportFrameViolation}
className="min-h-[520px] w-full rounded border border-gray-200 bg-white"
dataUiId="ui.plugins.settings.frame"
/>
</div>
);
}
@@ -0,0 +1,450 @@
import "@testing-library/jest-dom";
import { act, render, screen, waitFor } from "@testing-library/react";
import { MemoryRouter, useLoaderData } from "react-router";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
PLUGIN_SETTINGS_FRAME_CHANNEL_META_NAME,
PLUGIN_SETTINGS_FRAME_PROTOCOL_VERSION,
PLUGIN_SETTINGS_FRAME_SANDBOX,
} from "~/modules/plugins/components/PluginSettingsFrame";
import TenantPluginSettingsRoute from "./plugins.$id";
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
useLoaderData: vi.fn(),
};
});
vi.mock("react-i18next", () => ({
useTranslation: () => ({
t: (key: string, options?: Record<string, unknown>) => {
if (key === "settings.plugins.audit.backToPlugins") return "Back to plugins";
if (key === "settings.plugins.settings.heading") return `Settings for ${String(options?.pluginId ?? "")}`;
if (key === "settings.plugins.settings.description") return "Manage this plugin's embedded settings.";
if (key === "settings.plugins.settings.frameTitle") return `Settings frame for ${String(options?.pluginId ?? "")}`;
if (key === "settings.plugins.settings.frameErrors.invalid_payload") return "The plugin settings request is invalid.";
if (key === "settings.plugins.settings.frameErrors.settings_unavailable") return "This setting is unavailable.";
if (key === "settings.plugins.settings.frameErrors.settings_update_failed") return "Plugin settings could not be saved.";
return key;
},
}),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/data/useRootData", () => ({
useRootData: () => ({ csrf: "csrf-token" }),
}));
vi.mock("~/modules/plugins/services/.server/PluginSettingsService", () => ({
PluginSettingsServiceError: class PluginSettingsServiceError extends Error {
constructor(
public readonly code: string,
message: string
) {
super(message);
}
},
loadPluginSettingsHtml: vi.fn(),
loadPluginSettingsPageData: vi.fn(),
}));
vi.mock("~/utils/app/CanonicalUrlUtils", () => ({
appPath: ({ tenantSlug, path }: { tenantSlug: string; path: string }) => `/app/${tenantSlug}/${path}`,
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
function renderSettingsRoute() {
return render(
<MemoryRouter>
<TenantPluginSettingsRoute />
</MemoryRouter>
);
}
function getFrameChannelId(frame: Element) {
const srcDoc = frame.getAttribute("srcdoc") ?? "";
const match = srcDoc.match(new RegExp(`name="${PLUGIN_SETTINGS_FRAME_CHANNEL_META_NAME}" content="([^"]+)"`, "u"));
if (!match?.[1]) throw new Error("plugin settings frame channel missing");
return match[1];
}
describe("tenant plugin settings route UI", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(useLoaderData).mockReturnValue({
title: "Plugin settings",
tenantSlug: "acme",
plugin: {
id: "pl-1",
pluginId: "com.acme.settings",
version: "1.0.0",
},
trustedHtml: "<main><h1>Settings</h1></main>",
settings: { theme: "dark" },
});
});
it("renders the sandboxed settings iframe with route-level navigation", () => {
renderSettingsRoute();
expect(screen.getByRole("link", { name: "Back to plugins" })).toHaveAttribute("href", "/app/acme/settings/plugins");
expect(screen.getByRole("heading", { name: "Settings for com.acme.settings" })).toBeInTheDocument();
expect(document.querySelector('[data-ui-id="ui.plugins.settings.page"]')).toBeInTheDocument();
const frame = screen.getByTitle("Settings frame for com.acme.settings");
expect(frame).toHaveAttribute("data-ui-id", "ui.plugins.settings.frame");
expect(frame).toHaveAttribute("data-plugin-id", "com.acme.settings");
expect(frame).toHaveAttribute("sandbox", PLUGIN_SETTINGS_FRAME_SANDBOX);
expect(frame).not.toHaveAttribute("src");
expect(frame).toHaveAttribute("srcdoc", expect.stringContaining('http-equiv="Content-Security-Policy"'));
expect(frame).toHaveAttribute("srcdoc", expect.stringContaining("script-src 'nonce-"));
expect(frame).not.toHaveAttribute("srcdoc", expect.stringContaining("script-src 'unsafe-inline'"));
expect(frame).toHaveAttribute("srcdoc", expect.stringContaining(`name="plugin-settings-protocol" content="${PLUGIN_SETTINGS_FRAME_PROTOCOL_VERSION}"`));
expect(frame).toHaveAttribute("srcdoc", expect.stringContaining('name="plugin-id" content="com.acme.settings"'));
expect(frame).toHaveAttribute("srcdoc", expect.stringContaining(`name="${PLUGIN_SETTINGS_FRAME_CHANNEL_META_NAME}"`));
});
it("serves loaded settings to the iframe and persists updates through the route action", async () => {
const fetchMock = vi.fn(
async () =>
new Response(JSON.stringify({ ok: true, key: "theme", value: "light", settings: { theme: "light" } }), {
status: 200,
headers: { "content-type": "application/json" },
})
);
vi.stubGlobal("fetch", fetchMock);
renderSettingsRoute();
const frame = screen.getByTitle("Settings frame for com.acme.settings") as HTMLIFrameElement;
const channelId = getFrameChannelId(frame);
const source = frame.contentWindow;
if (!source) throw new Error("iframe contentWindow missing");
const postMessage = vi.spyOn(source, "postMessage").mockImplementation(() => undefined);
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.get", version: 1, pluginId: "com.acme.settings", channelId, requestId: "get-1", key: "theme" },
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{ type: "plugin.settings.result", version: 1, pluginId: "com.acme.settings", channelId, requestId: "get-1", ok: true, key: "theme", value: "dark" },
"*"
)
);
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.acme.settings", channelId, requestId: "set-1", key: "theme", value: "light" },
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(fetchMock).toHaveBeenCalledWith(".data", {
method: "POST",
headers: { "content-type": "application/json", "x-csrf-token": "csrf-token" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
})
);
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{ type: "plugin.settings.result", version: 1, pluginId: "com.acme.settings", channelId, requestId: "set-1", ok: true, key: "theme", value: "light" },
"*"
)
);
});
it("keeps iframe settings unchanged when route-level persistence fails", async () => {
const fetchMock = vi.fn(
async () =>
new Response(JSON.stringify({ error: "rate_limited", message: "Too many plugin setting updates. Try again in a minute." }), {
status: 429,
headers: { "content-type": "application/json" },
})
);
vi.stubGlobal("fetch", fetchMock);
renderSettingsRoute();
const frame = screen.getByTitle("Settings frame for com.acme.settings") as HTMLIFrameElement;
const channelId = getFrameChannelId(frame);
const source = frame.contentWindow;
if (!source) throw new Error("iframe contentWindow missing");
const postMessage = vi.spyOn(source, "postMessage").mockImplementation(() => undefined);
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.acme.settings", channelId, requestId: "set-fail", key: "theme", value: "light" },
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(fetchMock).toHaveBeenCalledWith(".data", {
method: "POST",
headers: { "content-type": "application/json", "x-csrf-token": "csrf-token" },
body: JSON.stringify({ op: "setSetting", key: "theme", value: "light", csrf: "csrf-token" }),
})
);
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{
type: "plugin.settings.result",
version: 1,
pluginId: "com.acme.settings",
channelId,
requestId: "set-fail",
ok: false,
error: "settings_update_failed",
message: "Plugin settings could not be saved.",
},
"*"
)
);
postMessage.mockClear();
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.get", version: 1, pluginId: "com.acme.settings", channelId, requestId: "get-after-fail", key: "theme" },
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{
type: "plugin.settings.result",
version: 1,
pluginId: "com.acme.settings",
channelId,
requestId: "get-after-fail",
ok: true,
key: "theme",
value: "dark",
},
"*"
)
);
});
it("returns bounded iframe error copy when route-level persistence returns non-json", async () => {
const fetchMock = vi.fn(
async () =>
new Response("<!doctype html><title>Bad Gateway</title>", {
status: 502,
headers: { "content-type": "text/html" },
})
);
vi.stubGlobal("fetch", fetchMock);
renderSettingsRoute();
const frame = screen.getByTitle("Settings frame for com.acme.settings") as HTMLIFrameElement;
const channelId = getFrameChannelId(frame);
const source = frame.contentWindow;
if (!source) throw new Error("iframe contentWindow missing");
const postMessage = vi.spyOn(source, "postMessage").mockImplementation(() => undefined);
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.acme.settings", channelId, requestId: "set-bad-gateway", key: "theme", value: "light" },
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{
type: "plugin.settings.result",
version: 1,
pluginId: "com.acme.settings",
channelId,
requestId: "set-bad-gateway",
ok: false,
error: "settings_update_failed",
message: "Plugin settings could not be saved.",
},
"*"
)
);
expect(fetchMock).toHaveBeenCalledOnce();
});
it("rejects forged iframe settings messages and reports frame violations without setting persistence", async () => {
const fetchMock = vi.fn();
vi.stubGlobal("fetch", fetchMock);
renderSettingsRoute();
const frame = screen.getByTitle("Settings frame for com.acme.settings") as HTMLIFrameElement;
const channelId = getFrameChannelId(frame);
const source = frame.contentWindow;
if (!source) throw new Error("iframe contentWindow missing");
const postMessage = vi.spyOn(source, "postMessage").mockImplementation(() => undefined);
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.acme.settings", channelId, requestId: "wrong-origin", key: "theme", value: "light" },
origin: "https://evil.example",
source,
})
);
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.acme.settings", channelId, requestId: "wrong-source", key: "theme", value: "light" },
origin: "null",
source: window,
})
);
window.dispatchEvent(
new MessageEvent("message", {
data: {
type: "plugin.settings.set",
version: 1,
pluginId: "com.acme.settings",
channelId: "stale-channel",
requestId: "wrong-channel",
key: "theme",
value: "light",
},
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{
type: "plugin.settings.result",
version: 1,
pluginId: "com.acme.settings",
channelId,
requestId: "wrong-channel",
ok: false,
error: "invalid_payload",
message: "The plugin settings request is invalid.",
},
"*"
)
);
await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(3));
expect(fetchMock.mock.calls.map(([, init]) => JSON.parse(String((init as RequestInit).body)).op)).toEqual([
"reportFrameViolation",
"reportFrameViolation",
"reportFrameViolation",
]);
expect(fetchMock.mock.calls.map(([, init]) => JSON.parse(String((init as RequestInit).body)).reason)).toEqual([
"wrong_origin",
"wrong_source",
"invalid_payload",
]);
expect(postMessage).toHaveBeenCalledTimes(1);
});
it("deduplicates repeated iframe violation reports before they reach the route action", async () => {
const fetchMock = vi.fn();
vi.stubGlobal("fetch", fetchMock);
renderSettingsRoute();
const frame = screen.getByTitle("Settings frame for com.acme.settings") as HTMLIFrameElement;
const channelId = getFrameChannelId(frame);
const source = frame.contentWindow;
if (!source) throw new Error("iframe contentWindow missing");
act(() => {
for (let index = 0; index < 3; index += 1) {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.acme.settings", channelId, requestId: `wrong-origin-${index}`, key: "theme", value: "light" },
origin: "https://evil.example",
source,
})
);
}
});
await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
expect(JSON.parse(String((fetchMock.mock.calls[0]?.[1] as RequestInit).body))).toEqual({
op: "reportFrameViolation",
reason: "wrong_origin",
csrf: "csrf-token",
});
});
it("rejects iframe settings messages for another plugin and reports the invalid payload without setting persistence", async () => {
const fetchMock = vi.fn();
vi.stubGlobal("fetch", fetchMock);
renderSettingsRoute();
const frame = screen.getByTitle("Settings frame for com.acme.settings") as HTMLIFrameElement;
const channelId = getFrameChannelId(frame);
const source = frame.contentWindow;
if (!source) throw new Error("iframe contentWindow missing");
const postMessage = vi.spyOn(source, "postMessage").mockImplementation(() => undefined);
act(() => {
window.dispatchEvent(
new MessageEvent("message", {
data: { type: "plugin.settings.set", version: 1, pluginId: "com.evil.settings", channelId, requestId: "wrong-plugin", key: "theme", value: "light" },
origin: "null",
source,
})
);
});
await waitFor(() =>
expect(postMessage).toHaveBeenCalledWith(
{
type: "plugin.settings.result",
version: 1,
pluginId: "com.acme.settings",
channelId,
requestId: "wrong-plugin",
ok: false,
error: "invalid_payload",
message: "The plugin settings request is invalid.",
},
"*"
)
);
await waitFor(() =>
expect(fetchMock).toHaveBeenCalledWith(".data", {
method: "POST",
headers: { "content-type": "application/json", "x-csrf-token": "csrf-token" },
body: JSON.stringify({ op: "reportFrameViolation", reason: "invalid_payload", csrf: "csrf-token" }),
})
);
});
});
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,672 @@
/**
* Phase 06 #22 — Tenant-Admin plugins UI.
*
* Lists installed plugins for the current tenant with capability consent,
* enable / disable toggles and a manifest preview. The route is deliberately
* scoped (no install dialog, no per-user toggles) — the foundation surfaces
* what plugins exist, links manifest-declared settings UIs, and lets tenant
* admins approve manifest-declared capabilities before flipping the kill-switch.
*
* Permission: `app.plugins.use` can view installed plugins and
* `app.plugins.manage` can grant or revoke capabilities and enable/disable them.
*/
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import {
getPluginCapabilityMetadata,
isPluginCapabilityName,
type PluginCapabilityMetadata,
type PluginCapabilityRisk,
} from "@toolctrl/plugin-runtime/capabilities";
import { isPluginHookProductionAvailable } from "@toolctrl/plugin-runtime/hooks/registry";
import type { PluginCapability } from "@toolctrl/plugin-runtime/manifest";
import { Form, Link, useActionData, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { useState } from "react";
import { getTranslations } from "~/locale/i18next.server";
import { useLocaleFormatters } from "~/locale/format";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { useRootData } from "~/utils/data/useRootData";
import { getUserPermission, verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getUser } from "~/utils/db/users.db.server";
import {
PluginLifecycleError,
disablePlugin,
enablePlugin,
grantPluginCapabilities,
isCapabilityGrantScopeSatisfied,
listPluginCapabilityGrants,
listPluginCapabilityGrantsForPlugins,
listPlugins,
revokePluginCapabilities,
type PluginLifecycleActor,
type PluginListItem,
} from "~/modules/plugins/services/.server/PluginLifecycleService";
import { getPluginConsentRequirements, isPluginHookConsentName } from "~/modules/plugins/utils/pluginConsentRequirements";
import { parsePluginCapabilityNameArray, readPluginConsentUrlEncodedFormData } from "~/modules/plugins/utils/capabilityConsentPayload.server";
async function createCapabilityReviewDigest(item: Pick<PluginListItem, "pluginId" | "version" | "manifest">, capabilityNames: ReadonlyArray<string>) {
const { createCapabilityReviewDigest: createDigest } = await import("~/modules/plugins/utils/capabilityReviewDigest");
return createDigest(item, capabilityNames);
}
type SerializedPluginCapability = {
name: string;
scope: PluginCapability["scope"] | null;
granted: boolean;
grantedAt: string | null;
grantedScopeJson: unknown;
metadata: SerializedPluginCapabilityMetadata | null;
};
type SerializedPluginCapabilityMetadata = Pick<PluginCapabilityMetadata, "risk" | "productionAvailable">;
type SerializedPluginItem = {
id: string;
pluginId: string;
version: string;
enabled: boolean;
capabilities: ReadonlyArray<SerializedPluginCapability>;
missingCapabilities: ReadonlyArray<string>;
capabilityReviewDigest: string;
hasSettingsUi: boolean;
manifestJson: string;
installedAt: string;
};
type LoaderData = {
title: string;
tenantSlug: string;
canManage: boolean;
canAudit: boolean;
items: ReadonlyArray<SerializedPluginItem>;
};
type ActionData = { ok: boolean; message?: string };
const USE_PERMISSION = "app.plugins.use";
const MANAGE_PERMISSION = "app.plugins.manage";
const AUDIT_PERMISSION = "app.settings.auditTrails.view";
export function formatPluginCapabilityLabel(capability: string, t: (key: string, options?: Record<string, unknown>) => string) {
if (isPluginHookConsentName(capability)) {
return t("settings.plugins.consent.hookLabel", { hook: capability.slice("hook:".length) });
}
if (isPluginCapabilityName(capability)) {
return t(`settings.plugins.capabilityNames.${capability.replaceAll(".", "_")}`);
}
return t(`settings.plugins.capabilityNames.${capability.replaceAll(".", "_")}`, {
defaultValue: t("settings.plugins.capabilityNames.unknown", { capability }),
});
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, USE_PERMISSION, tenantId);
const [{ t }, info, items] = await Promise.all([getTranslations(request), getUserInfo(request), listPlugins({ tenantId })]);
const [managePermission, auditPermission, serializedItems] = await Promise.all([
info.userId
? getUserPermission({
userId: info.userId,
permissionName: MANAGE_PERMISSION,
tenantId,
})
: Promise.resolve(null),
info.userId
? getUserPermission({
userId: info.userId,
permissionName: AUDIT_PERMISSION,
tenantId,
})
: Promise.resolve(null),
serializePluginItems({ tenantId, items }),
]);
const data: LoaderData = {
title: `${t("settings.plugins.title")} | ${process.env.APP_NAME}`,
tenantSlug: params.tenant ?? "",
canManage: Boolean(managePermission?.userPermission),
canAudit: Boolean(auditPermission?.userPermission),
items: serializedItems,
};
return Response.json(data);
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, MANAGE_PERMISSION, tenantId);
const { t } = await getTranslations(request);
const parsedForm = await readPluginConsentUrlEncodedFormData(request);
if (!parsedForm.ok) {
return Response.json({ ok: false, message: t("settings.plugins.errors.invalidFormPayload") } satisfies ActionData, { status: 400 });
}
const form = parsedForm.formData;
await validateCSRFToken(request, { formData: form });
const op = form.get("op");
const pluginRowId = form.get("id");
if (typeof pluginRowId !== "string" || pluginRowId.length === 0) {
return Response.json({ ok: false, message: t("settings.plugins.errors.missingPluginId") } satisfies ActionData, { status: 400 });
}
const actor = await resolveActor(request);
try {
if (op === "enable") {
await enablePlugin({ tenantId, pluginRowId, actor });
return Response.json({ ok: true } satisfies ActionData);
}
if (op === "disable") {
await disablePlugin({ tenantId, pluginRowId, actor });
return Response.json({ ok: true } satisfies ActionData);
}
if (op === "revoke") {
const submittedPluginId = form.get("pluginId");
const parsedNames = parsePluginCapabilityNameArray(form.getAll("capabilityNames[]"));
if (typeof submittedPluginId !== "string" || submittedPluginId.length === 0 || !parsedNames.ok) {
return Response.json({ ok: false, message: t("settings.plugins.errors.missingCapabilityRevokeSelection") } satisfies ActionData, { status: 400 });
}
const item = (await listPlugins({ tenantId })).find((row) => row.id === pluginRowId);
if (!item) {
return Response.json({ ok: false, message: t("settings.plugins.errors.pluginNotFound") } satisfies ActionData, { status: 404 });
}
if (item.pluginId !== submittedPluginId) {
return Response.json({ ok: false, message: t("settings.plugins.errors.staleCapabilityReview") } satisfies ActionData, { status: 409 });
}
await revokePluginCapabilities({ tenantId, pluginId: item.pluginId, capabilityNames: parsedNames.capabilityNames, actor });
return Response.json({ ok: true } satisfies ActionData);
}
if (op === "grant" || op === "grantAndEnable") {
const parsedNames = parsePluginCapabilityNameArray(form.getAll("capabilities[]"));
if (!parsedNames.ok) {
return Response.json({ ok: false, message: t("settings.plugins.errors.missingCapabilitySelection") } satisfies ActionData, { status: 400 });
}
const item = (await listPlugins({ tenantId })).find((row) => row.id === pluginRowId);
if (!item) {
return Response.json({ ok: false, message: t("settings.plugins.errors.pluginNotFound") } satisfies ActionData, { status: 404 });
}
if (form.get("capabilitiesReviewed") !== "yes") {
return Response.json({ ok: false, message: t("settings.plugins.errors.missingCapabilityReview") } satisfies ActionData, { status: 400 });
}
const declaredCapabilities = new Map(getPluginConsentRequirements(item.manifest).map((requirement) => [requirement.name, requirement]));
if (parsedNames.capabilityNames.length === 0) {
return Response.json({ ok: false, message: t("settings.plugins.errors.missingCapabilitySelection") } satisfies ActionData, { status: 400 });
}
const existingGrants = await listPluginCapabilityGrants({ tenantId, pluginId: item.pluginId });
const grantByCapability = new Map(existingGrants.map((grant) => [grant.capabilityName, grant]));
const missingCapabilities = getPluginConsentRequirements(item.manifest)
.filter((requirement) => {
const grant = grantByCapability.get(requirement.name);
return !grant || !isCapabilityGrantScopeSatisfied({ declaredScope: requirement.scope ?? null, grantedScopeJson: grant.scopeJson });
})
.map((requirement) => requirement.name);
if (!areCapabilityNameSetsEqual(parsedNames.capabilityNames, missingCapabilities)) {
return Response.json({ ok: false, message: t("settings.plugins.errors.staleCapabilityReview") } satisfies ActionData, { status: 409 });
}
const requestedCapabilities = missingCapabilities;
const submittedDigest = form.get("capabilityReviewDigest");
const expectedDigest = await createCapabilityReviewDigest(item, missingCapabilities);
if (typeof submittedDigest !== "string" || submittedDigest !== expectedDigest) {
return Response.json({ ok: false, message: t("settings.plugins.errors.staleCapabilityReview") } satisfies ActionData, { status: 409 });
}
await grantPluginCapabilities({
tenantId,
pluginId: item.pluginId,
grants: requestedCapabilities.map((name) => ({
capabilityName: name,
scopeJson: declaredCapabilities.get(name)?.scope ?? null,
})),
actor,
capabilityReviewDigest: submittedDigest,
});
if (op === "grantAndEnable") {
await enablePlugin({ tenantId, pluginRowId, actor });
}
return Response.json({ ok: true } satisfies ActionData);
}
return Response.json({ ok: false, message: t("settings.plugins.errors.unknownOperation") } satisfies ActionData, { status: 400 });
} catch (err) {
if (err instanceof PluginLifecycleError) {
return Response.json(
{
ok: false,
message: t(`settings.plugins.errors.lifecycle.${err.code}`),
} satisfies ActionData,
{ status: getPluginLifecycleErrorStatus(err.code) }
);
}
throw err;
}
};
function getPluginLifecycleErrorStatus(code: PluginLifecycleError["code"]): number {
if (
code === "signature_key_not_trusted" ||
code === "signature_key_mismatch" ||
code === "binary_verification_failed" ||
code === "capability_unavailable" ||
code === "production_guard_violation"
) {
return 403;
}
if (code === "not_found" || code === "binary_not_found") {
return 404;
}
if (code === "already_installed" || code === "capability_consent_missing") {
return 409;
}
if (code === "tenant_install_limit_exceeded") {
return 429;
}
return 400;
}
function areCapabilityNameSetsEqual(left: ReadonlyArray<string>, right: ReadonlyArray<string>): boolean {
if (left.length !== right.length) return false;
const rightNames = new Set(right);
return left.every((name) => rightNames.has(name));
}
async function serializePluginItems(args: { tenantId: string; items: ReadonlyArray<PluginListItem> }): Promise<SerializedPluginItem[]> {
const { createCapabilityReviewDigest: createDigest } = await import("~/modules/plugins/utils/capabilityReviewDigest");
const grants = await listPluginCapabilityGrantsForPlugins({
tenantId: args.tenantId,
pluginIds: args.items.map((row) => row.pluginId),
});
const grantsByPluginId = new Map<string, typeof grants>();
for (const grant of grants) {
const pluginGrants = grantsByPluginId.get(grant.pluginId) ?? [];
pluginGrants.push(grant);
grantsByPluginId.set(grant.pluginId, pluginGrants);
}
return Promise.all(
args.items.map(async (row) => {
const pluginGrants = grantsByPluginId.get(row.pluginId) ?? [];
const grantByCapability = new Map(pluginGrants.map((grant) => [grant.capabilityName, grant]));
const capabilities = getPluginConsentRequirements(row.manifest).map((capability) => {
const grant = grantByCapability.get(capability.name);
const granted = Boolean(grant) && isCapabilityGrantScopeSatisfied({ declaredScope: capability.scope ?? null, grantedScopeJson: grant?.scopeJson });
return {
name: capability.name,
scope: capability.scope ?? null,
granted,
grantedAt: grant?.grantedAt.toISOString() ?? null,
grantedScopeJson: grant?.scopeJson ?? null,
metadata: serializePluginConsentMetadata(capability.name),
};
});
const missingCapabilities = capabilities.filter((capability) => !capability.granted).map((capability) => capability.name);
return {
id: row.id,
pluginId: row.pluginId,
version: row.version,
enabled: row.enabled,
capabilities,
missingCapabilities,
capabilityReviewDigest: createDigest(row, missingCapabilities),
hasSettingsUi: Boolean(row.manifest.ui?.settings?.entry),
manifestJson: JSON.stringify(row.manifest, null, 2),
installedAt: row.installedAt.toISOString(),
};
})
);
}
function serializePluginConsentMetadata(name: string): SerializedPluginCapabilityMetadata | null {
if (isPluginHookConsentName(name)) {
const hookName = name.slice("hook:".length);
return { risk: "medium", productionAvailable: isPluginHookProductionAvailable(hookName) };
}
const metadata = getPluginCapabilityMetadata(name);
return metadata ? { risk: metadata.risk, productionAvailable: metadata.productionAvailable } : null;
}
async function resolveActor(request: Request): Promise<PluginLifecycleActor> {
const info = await getUserInfo(request);
const user = info.userId ? await getUser(info.userId) : null;
const ip = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? null;
return { userId: info.userId ?? null, email: user?.email ?? null, ip };
}
export default function TenantPluginsRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const { t } = useTranslation();
const rootData = useRootData();
const formatters = useLocaleFormatters();
const [expanded, setExpanded] = useState<string | null>(null);
const [reviewingCapabilities, setReviewingCapabilities] = useState<string | null>(null);
const [reviewedCapabilities, setReviewedCapabilities] = useState<ReadonlySet<string>>(() => new Set());
const getCapabilityReviewKey = (item: SerializedPluginItem, capabilityName: string) => `${item.id}:${item.capabilityReviewDigest}:${capabilityName}`;
const denyCapabilityReview = (item: SerializedPluginItem) => {
setReviewedCapabilities((current) => {
const next = new Set(current);
for (const capabilityName of item.missingCapabilities) {
next.delete(getCapabilityReviewKey(item, capabilityName));
}
return next;
});
setReviewingCapabilities(null);
};
return (
<div className="space-y-6 p-6" data-ui-id="ui.plugins.page">
<header>
<h1 className="text-xl font-semibold">{t("settings.plugins.title")}</h1>
<p className="text-sm text-gray-500">{t("settings.plugins.description", { tenantSlug: data.tenantSlug })}</p>
</header>
{actionData?.message ? (
<div
role="alert"
className={`rounded border px-3 py-2 text-sm ${actionData.ok ? "border-green-300 bg-green-50 text-green-800" : "border-red-300 bg-red-50 text-red-800"}`}
>
{actionData.message}
</div>
) : null}
{data.items.length === 0 ? (
<p className="rounded border border-dashed border-gray-300 p-6 text-sm text-gray-500">{t("settings.plugins.empty")}</p>
) : (
<ul className="space-y-3" data-ui-id="ui.plugins.list">
{data.items.map((item) => {
const missingCapabilityNames = new Set(item.missingCapabilities);
const capabilitiesToReview = item.capabilities.filter((capability) => missingCapabilityNames.has(capability.name));
const unavailableCapabilitiesToReview = capabilitiesToReview.filter((capability) => capability.metadata?.productionAvailable === false);
const reviewComplete =
unavailableCapabilitiesToReview.length === 0 &&
item.missingCapabilities.every((capabilityName) => reviewedCapabilities.has(getCapabilityReviewKey(item, capabilityName)));
return (
<li
key={item.id}
className="rounded border border-gray-200 bg-white p-4 shadow-sm"
data-ui-id="ui.plugins.item"
data-plugin-row-id={item.id}
data-plugin-id={item.pluginId}
>
<div className="flex flex-wrap items-center justify-between gap-3">
<div>
<h2 className="text-base font-medium">{item.pluginId}</h2>
<p className="text-xs text-gray-500">
{t("settings.plugins.versionInstalled", {
version: item.version,
date: formatters.date(item.installedAt, { dateStyle: "medium", timeStyle: "short" }),
})}
</p>
</div>
<div className="flex items-center gap-3">
<span
className={`rounded-full px-2 py-0.5 text-xs font-medium ${item.enabled ? "bg-green-100 text-green-800" : "bg-gray-100 text-gray-700"}`}
>
{item.enabled ? t("shared.enabled") : t("shared.disabled")}
</span>
{data.canManage ? (
item.enabled ? (
<Form method="post" className="inline" data-ui-id="ui.plugins.lifecycle.form">
{rootData.csrf ? <input type="hidden" name="csrf" value={rootData.csrf} /> : null}
<input type="hidden" name="id" value={item.id} />
<input type="hidden" name="op" value="disable" />
<button
type="submit"
className="rounded border border-gray-300 bg-white px-3 py-1 text-sm hover:bg-gray-50"
data-ui-id="ui.plugins.lifecycle.button"
>
{t("shared.disable")}
</button>
</Form>
) : item.missingCapabilities.length > 0 ? null : (
<Form method="post" className="inline" data-ui-id="ui.plugins.lifecycle.form">
{rootData.csrf ? <input type="hidden" name="csrf" value={rootData.csrf} /> : null}
<input type="hidden" name="id" value={item.id} />
<input type="hidden" name="op" value="enable" />
<button
type="submit"
className="rounded border border-gray-300 bg-white px-3 py-1 text-sm hover:bg-gray-50"
data-ui-id="ui.plugins.lifecycle.button"
>
{t("shared.enable")}
</button>
</Form>
)
) : null}
</div>
</div>
<div className="mt-3 space-y-2">
<p className="text-xs font-medium text-gray-500 uppercase">{t("settings.plugins.capabilities")}</p>
{item.capabilities.length === 0 ? (
<p className="text-xs text-gray-500">{t("settings.plugins.consent.none")}</p>
) : (
<ul className="space-y-2">
{item.capabilities.map((capability) => (
<li key={capability.name} className="rounded border border-gray-100 bg-gray-50 px-3 py-2">
<div className="flex flex-wrap items-center justify-between gap-2">
<span className="text-sm font-medium text-gray-900">{formatPluginCapabilityLabel(capability.name, t)}</span>
<span
className={`rounded-full px-2 py-0.5 text-xs font-medium ${capability.granted ? "bg-green-100 text-green-800" : "bg-amber-100 text-amber-800"}`}
>
{capability.granted ? t("settings.plugins.consent.granted") : t("settings.plugins.consent.missing")}
</span>
</div>
<p className="mt-1 text-xs text-gray-500">{formatPluginCapabilityScope(capability.scope, t)}</p>
{capability.granted && capability.grantedAt ? (
<p className="mt-1 text-xs text-gray-500" data-ui-id="ui.plugins.capability.grantMeta">
{t("settings.plugins.consent.grantedAt", {
date: formatters.date(capability.grantedAt, { dateStyle: "medium", timeStyle: "short" }),
})}
</p>
) : null}
{data.canManage && capability.granted ? (
<Form method="post" className="mt-2" data-ui-id="ui.plugins.capability.revoke.form">
{rootData.csrf ? <input type="hidden" name="csrf" value={rootData.csrf} /> : null}
<input type="hidden" name="id" value={item.id} />
<input type="hidden" name="pluginId" value={item.pluginId} />
<input type="hidden" name="op" value="revoke" />
<input type="hidden" name="capabilityNames[]" value={capability.name} />
<button
type="submit"
className="text-xs font-medium text-red-700 hover:underline"
data-ui-id="ui.plugins.capability.revoke.button"
>
{t("settings.plugins.consent.revoke")}
</button>
<span className="ml-2 text-xs text-gray-500">{t("settings.plugins.consent.revokeDisables")}</span>
</Form>
) : null}
</li>
))}
</ul>
)}
{data.canManage && item.missingCapabilities.length > 0 ? (
<div className="rounded border border-amber-200 bg-amber-50 p-3">
<button
type="button"
aria-expanded={reviewingCapabilities === item.id}
aria-controls={`plugin-capability-review-${item.id}`}
onClick={() => setReviewingCapabilities(reviewingCapabilities === item.id ? null : item.id)}
className="rounded border border-amber-300 bg-white px-3 py-1 text-sm font-medium text-amber-900 hover:bg-amber-100"
data-ui-id="ui.plugins.capabilityReview.toggle"
>
{t("settings.plugins.consent.reviewCapabilities")}
</button>
<span className="ml-3 text-xs text-gray-500">{t("settings.plugins.consent.description")}</span>
{reviewingCapabilities === item.id ? (
<Form
method="post"
id={`plugin-capability-review-${item.id}`}
className="mt-3 space-y-3"
aria-label={t("settings.plugins.consent.reviewFormLabel", { pluginId: item.pluginId })}
data-ui-id="ui.plugins.capabilityReview.form"
>
{rootData.csrf ? <input type="hidden" name="csrf" value={rootData.csrf} /> : null}
<input type="hidden" name="id" value={item.id} />
<input type="hidden" name="op" value={item.enabled ? "grant" : "grantAndEnable"} />
<input type="hidden" name="capabilityReviewDigest" value={item.capabilityReviewDigest} />
<div>
<p className="text-sm font-medium text-amber-950">{t("settings.plugins.consent.reviewTitle", { pluginId: item.pluginId })}</p>
<p className="mt-1 text-xs text-amber-900">{t("settings.plugins.consent.reviewDescription", { version: item.version })}</p>
</div>
<ul className="space-y-2">
{capabilitiesToReview.map((capability) => {
const reviewKey = getCapabilityReviewKey(item, capability.name);
const label = formatPluginCapabilityLabel(capability.name, t);
const unavailable = capability.metadata?.productionAvailable === false;
return (
<li key={capability.name} className="rounded border border-amber-200 bg-white px-3 py-2">
<label className="flex items-start gap-2">
<input
type="checkbox"
name="capabilities[]"
value={capability.name}
disabled={unavailable}
checked={reviewedCapabilities.has(reviewKey)}
onChange={(event) => {
const isChecked = event.currentTarget.checked;
setReviewedCapabilities((current) => {
const next = new Set(current);
if (isChecked) {
next.add(reviewKey);
} else {
next.delete(reviewKey);
}
return next;
});
}}
className="mt-0.5 h-3.5 w-3.5 rounded border-gray-300 disabled:cursor-not-allowed disabled:opacity-50"
data-ui-id="ui.plugins.capabilityReview.checkbox"
/>
<span className="text-sm font-medium text-gray-900">
{t("settings.plugins.consent.reviewCapability", { capability: label })}
</span>
</label>
{capability.metadata ? (
<div className="mt-2 flex flex-wrap gap-2">
<span
className={`rounded-full px-2 py-0.5 text-xs font-medium ${getPluginCapabilityRiskClassName(capability.metadata.risk)}`}
data-ui-id="ui.plugins.capabilityReview.risk"
>
{t(`settings.plugins.consent.risk.${capability.metadata.risk}`)}
</span>
<span
className={`rounded-full px-2 py-0.5 text-xs font-medium ${
capability.metadata.productionAvailable ? "bg-green-100 text-green-800" : "bg-red-100 text-red-800"
}`}
data-ui-id="ui.plugins.capabilityReview.availability"
>
{capability.metadata.productionAvailable
? t("settings.plugins.consent.available")
: t("settings.plugins.consent.unavailable")}
</span>
</div>
) : null}
{unavailable ? (
<p className="mt-2 text-xs text-red-700" data-ui-id="ui.plugins.capabilityReview.unavailableReason">
{t("settings.plugins.consent.unavailableDescription")}
</p>
) : null}
<p className="mt-1 text-xs text-gray-500">{formatPluginCapabilityScope(capability.scope, t)}</p>
<code
className="mt-2 inline-flex rounded border border-gray-200 bg-gray-50 px-1.5 py-0.5 text-xs text-gray-700"
data-ui-id="ui.plugins.capabilityReview.grantName"
>
{capability.name}
</code>
</li>
);
})}
</ul>
<input type="hidden" name="capabilitiesReviewed" value={reviewComplete ? "yes" : "no"} />
<div className="flex flex-wrap items-center gap-2">
<button
type="submit"
disabled={!reviewComplete}
className="rounded border border-amber-300 bg-amber-100 px-3 py-1 text-sm font-medium text-amber-950 hover:bg-amber-200 disabled:cursor-not-allowed disabled:opacity-50"
data-ui-id="ui.plugins.capabilityReview.button"
>
{item.enabled ? t("settings.plugins.consent.approve") : t("settings.plugins.consent.approveAndEnable")}
</button>
<button
type="button"
onClick={() => denyCapabilityReview(item)}
className="rounded border border-gray-300 bg-white px-3 py-1 text-sm font-medium text-gray-700 hover:bg-gray-50"
data-ui-id="ui.plugins.capabilityReview.deny"
>
{t("shared.deny")}
</button>
</div>
</Form>
) : null}
</div>
) : null}
</div>
<button
type="button"
aria-expanded={expanded === item.id}
aria-controls={`plugin-manifest-${item.id}`}
onClick={() => setExpanded(expanded === item.id ? null : item.id)}
className="mt-2 text-xs text-blue-600 hover:underline"
data-ui-id="ui.plugins.manifest.toggle"
>
{expanded === item.id ? t("settings.plugins.hideManifest") : t("settings.plugins.viewManifest")}
</button>
{item.enabled && item.hasSettingsUi ? (
<Link
to={appPath({ tenantSlug: data.tenantSlug, path: `settings/plugins/${item.id}` })}
className="ml-4 text-xs font-medium text-blue-600 hover:underline"
data-ui-id="ui.plugins.settings.open"
>
{t("settings.plugins.openSettings")}
</Link>
) : null}
{data.canAudit ? (
<Link
to={appPath({ tenantSlug: data.tenantSlug, path: `settings/plugins/${item.id}/audit` })}
className="ml-4 text-xs font-medium text-blue-600 hover:underline"
data-ui-id="ui.plugins.audit.open"
>
{t("settings.plugins.viewAudit")}
</Link>
) : null}
{expanded === item.id ? (
<pre
id={`plugin-manifest-${item.id}`}
// Scrollable regions must be keyboard-focusable (axe
// scrollable-region-focusable) so keyboard users can scroll the
// manifest content.
tabIndex={0}
className="mt-2 overflow-auto rounded bg-gray-50 p-3 text-xs text-gray-800"
data-ui-id="ui.plugins.manifest.panel"
>
{item.manifestJson}
</pre>
) : null}
</li>
);
})}
</ul>
)}
</div>
);
}
function getPluginCapabilityRiskClassName(risk: PluginCapabilityRisk): string {
switch (risk) {
case "low":
return "bg-green-100 text-green-800";
case "medium":
return "bg-blue-100 text-blue-800";
case "high":
return "bg-amber-100 text-amber-800";
case "critical":
return "bg-red-100 text-red-800";
}
}
function formatPluginCapabilityScope(scope: PluginCapability["scope"] | null, t: (key: string, options?: Record<string, unknown>) => string) {
if (!scope) {
return t("settings.plugins.consent.noScope");
}
const parts = [
scope.allowedHosts?.length ? t("settings.plugins.consent.allowedHosts", { hosts: scope.allowedHosts.join(", ") }) : null,
scope.keyPattern ? t("settings.plugins.consent.keyPattern", { pattern: scope.keyPattern }) : null,
scope.tablePrefix ? t("settings.plugins.consent.tablePrefix", { prefix: scope.tablePrefix }) : null,
].filter(Boolean);
return parts.length > 0 ? parts.join(" / ") : t("settings.plugins.consent.noScope");
}
@@ -0,0 +1,517 @@
import "@testing-library/jest-dom";
import { fireEvent, render, screen } from "@testing-library/react";
import type { FormHTMLAttributes, ReactNode } from "react";
import { MemoryRouter, useActionData, useLoaderData } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { expectNoAxeViolations, runAxe } from "@toolctrl/ui-app/test-setup/axe";
import TenantPluginsRoute from "./plugins";
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
Form: ({ children, ...props }: { children: ReactNode } & FormHTMLAttributes<HTMLFormElement>) => <form {...props}>{children}</form>,
useActionData: vi.fn(),
useLoaderData: vi.fn(),
};
});
function interpolateTranslation(template: string, options?: Record<string, unknown>) {
return template.replace(/\{\{(\w+)\}\}/g, (_, key: string) => String(options?.[key] ?? `{{${key}}}`));
}
vi.mock("react-i18next", () => ({
useTranslation: () => ({
t: (key: string, options?: Record<string, unknown>) => interpolateTranslation(translations[key] ?? String(options?.defaultValue ?? key), options),
}),
}));
vi.mock("~/locale/format", () => ({
useLocaleFormatters: () => ({
date: (value: string) => `formatted:${value}`,
}),
}));
vi.mock("~/utils/app/CanonicalUrlUtils", () => ({
appPath: ({ tenantSlug, path }: { tenantSlug: string; path: string }) => `/app/${tenantSlug}/${path}`,
}));
vi.mock("~/utils/data/useRootData", () => ({
useRootData: () => ({ csrf: "csrf-token" }),
}));
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
getUserPermission: vi.fn(),
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: vi.fn(),
}));
vi.mock("~/modules/plugins/services/.server/PluginLifecycleService", () => ({
PluginLifecycleError: class PluginLifecycleError extends Error {
code: string;
constructor(code: string, message: string) {
super(message);
this.code = code;
}
},
disablePlugin: vi.fn(),
enablePlugin: vi.fn(),
grantPluginCapabilities: vi.fn(),
listPluginCapabilityGrants: vi.fn(),
listPluginCapabilityGrantsForPlugins: vi.fn(),
listPlugins: vi.fn(),
revokePluginCapabilities: vi.fn(),
}));
const translations: Record<string, string> = {
"settings.plugins.title": "Plugins",
"settings.plugins.description": "Installed plugins for acme",
"settings.plugins.versionInstalled": "v{{version}} installed {{date}}",
"settings.plugins.capabilities": "Capabilities",
"settings.plugins.capabilityNames.http_outbound": "Outbound HTTP",
"settings.plugins.capabilityNames.log": "Logging",
"settings.plugins.capabilityNames.audit": "Audit logging",
"settings.plugins.capabilityNames.secret_read": "Secret read",
"settings.plugins.consent.allowedHosts": "Allowed hosts: {{hosts}}",
"settings.plugins.consent.approve": "Approve capabilities",
"settings.plugins.consent.approveAndEnable": "Approve and enable",
"settings.plugins.consent.description": "Review and approve missing capability grants before enabling this plugin.",
"settings.plugins.consent.granted": "Approved",
"settings.plugins.consent.grantedAt": "Approved {{date}} for the scope shown above.",
"settings.plugins.consent.hookLabel": "Hook: {{hook}}",
"settings.plugins.consent.keyPattern": "Key pattern: {{pattern}}",
"settings.plugins.consent.missing": "Approval required",
"settings.plugins.consent.noScope": "No additional scope.",
"settings.plugins.consent.none": "This plugin declares no capabilities.",
"settings.plugins.consent.reviewCapabilities": "Review capabilities",
"settings.plugins.consent.reviewDescription": "Version {{version}} is requesting these additional host capabilities.",
"settings.plugins.consent.reviewFormLabel": "Capability review for {{pluginId}}",
"settings.plugins.consent.reviewTitle": "Review {{pluginId}} capabilities",
"settings.plugins.consent.reviewCapability": "I reviewed {{capability}}.",
"settings.plugins.consent.reviewedCapabilities": "I reviewed the requested plugin capabilities.",
"settings.plugins.consent.risk.low": "Low risk",
"settings.plugins.consent.risk.medium": "Medium risk",
"settings.plugins.consent.risk.high": "High risk",
"settings.plugins.consent.risk.critical": "Critical risk",
"settings.plugins.consent.available": "Available in this runtime",
"settings.plugins.consent.unavailable": "Not available in this runtime",
"settings.plugins.consent.unavailableDescription": "This host binding is not production-available yet. It cannot be approved until the operator enables a reviewed implementation.",
"settings.plugins.consent.revoke": "Revoke approval",
"settings.plugins.consent.revokeDisables": "Revoking approval disables this plugin.",
"settings.plugins.consent.tablePrefix": "Table prefix: {{prefix}}",
"shared.deny": "Deny",
"settings.plugins.viewManifest": "View manifest",
"settings.plugins.hideManifest": "Hide manifest",
"settings.plugins.openSettings": "Open settings",
"settings.plugins.viewAudit": "View audit",
"shared.disable": "Disable",
"shared.disabled": "Disabled",
"shared.enable": "Enable",
"shared.enabled": "Enabled",
};
const pluginItem = {
id: "pl-1",
pluginId: "com.acme.outbound",
version: "1.2.3",
enabled: true,
capabilities: [
{
name: "http.outbound",
scope: { allowedHosts: ["api.example.com"] },
granted: true,
grantedAt: "2026-05-01T12:10:00.000Z",
grantedScopeJson: { allowedHosts: ["api.example.com"] },
metadata: { risk: "high", productionAvailable: false },
},
],
missingCapabilities: [],
capabilityReviewDigest: "review-digest",
hasSettingsUi: true,
manifestJson: JSON.stringify({ id: "com.acme.outbound", capabilities: [{ name: "http.outbound" }] }, null, 2),
installedAt: "2026-05-01T12:00:00.000Z",
};
function setLoaderData(canManage: boolean, item = pluginItem, canAudit = false) {
vi.mocked(useLoaderData).mockReturnValue({
title: "Plugins",
tenantSlug: "acme",
canManage,
canAudit,
items: [item],
});
vi.mocked(useActionData).mockReturnValue(undefined);
}
function renderPluginsRoute() {
return render(
<MemoryRouter>
<TenantPluginsRoute />
</MemoryRouter>
);
}
describe("tenant plugin settings UI", () => {
beforeEach(() => {
vi.clearAllMocks();
setLoaderData(false);
});
it("hides mutation controls from read-only plugin users and exposes manifest state", async () => {
renderPluginsRoute();
expect(screen.getByRole("heading", { name: "Plugins" })).toBeInTheDocument();
expect(screen.getByText("com.acme.outbound")).toBeInTheDocument();
expect(screen.getByText(/Outbound HTTP/u)).toBeInTheDocument();
expect(screen.getByText("Approved")).toBeInTheDocument();
expect(screen.getByText("Approved formatted:2026-05-01T12:10:00.000Z for the scope shown above.")).toBeInTheDocument();
expect(document.querySelector('[data-ui-id="ui.plugins.capability.grantMeta"]')).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Disable" })).not.toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Enable" })).not.toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Approve capabilities" })).not.toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Revoke approval" })).not.toBeInTheDocument();
expect(document.querySelector('[data-ui-id="ui.plugins.list"]')).toBeInTheDocument();
expect(document.querySelector('[data-ui-id="ui.plugins.item"][data-plugin-row-id="pl-1"][data-plugin-id="com.acme.outbound"]')).toBeInTheDocument();
const settingsLink = screen.getByRole("link", { name: "Open settings" });
expect(settingsLink).toHaveAttribute("href", "/app/acme/settings/plugins/pl-1");
expect(settingsLink).toHaveAttribute("data-ui-id", "ui.plugins.settings.open");
expect(screen.queryByRole("link", { name: "View audit" })).not.toBeInTheDocument();
const manifestToggle = screen.getByRole("button", { name: "View manifest" });
expect(manifestToggle).toHaveAttribute("aria-expanded", "false");
expect(manifestToggle).toHaveAttribute("data-ui-id", "ui.plugins.manifest.toggle");
fireEvent.click(manifestToggle);
expect(screen.getByRole("button", { name: "Hide manifest" })).toHaveAttribute("aria-expanded", "true");
expect(screen.getByText(/http\.outbound/u)).toBeInTheDocument();
expect(document.querySelector('[data-ui-id="ui.plugins.manifest.panel"]')).toBeInTheDocument();
});
it("shows the disable mutation control to plugin managers", () => {
setLoaderData(true);
renderPluginsRoute();
expect(screen.getByRole("button", { name: "Disable" })).toHaveAttribute("data-ui-id", "ui.plugins.lifecycle.button");
expect(document.querySelector('[data-ui-id="ui.plugins.lifecycle.form"]')).toBeInTheDocument();
expect(document.querySelector('input[name="id"]')).toHaveAttribute("value", "pl-1");
expect(document.querySelector('input[name="op"]')).toHaveAttribute("value", "disable");
expect(document.querySelector('input[name="csrf"]')).toHaveAttribute("value", "csrf-token");
});
it("shows plugin audit links only when the user has audit permission", () => {
setLoaderData(false, pluginItem, true);
renderPluginsRoute();
const auditLink = screen.getByRole("link", { name: "View audit" });
expect(auditLink).toHaveAttribute("href", "/app/acme/settings/plugins/pl-1/audit");
expect(auditLink).toHaveAttribute("data-ui-id", "ui.plugins.audit.open");
expect(screen.queryByRole("button", { name: "Disable" })).not.toBeInTheDocument();
});
it("shows revoke controls for granted capabilities to plugin managers", () => {
setLoaderData(true);
renderPluginsRoute();
expect(screen.getByRole("button", { name: "Revoke approval" })).toHaveAttribute("data-ui-id", "ui.plugins.capability.revoke.button");
expect(document.querySelector('[data-ui-id="ui.plugins.capability.revoke.form"]')).toBeInTheDocument();
expect(screen.getByText("Revoking approval disables this plugin.")).toBeInTheDocument();
expect(document.querySelector('input[name="pluginId"]')).toHaveAttribute("value", "com.acme.outbound");
expect(document.querySelector('input[name="capabilityNames[]"]')).toHaveAttribute("value", "http.outbound");
});
it("guides managers through capability review before enabling", () => {
setLoaderData(true, {
...pluginItem,
enabled: false,
capabilities: [
{
name: "log",
scope: null,
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "low", productionAvailable: true },
},
],
missingCapabilities: ["log"],
});
renderPluginsRoute();
expect(screen.getByText("Approval required")).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Enable" })).not.toBeInTheDocument();
const reviewToggle = screen.getByRole("button", { name: "Review capabilities" });
expect(reviewToggle).toHaveAttribute("aria-expanded", "false");
expect(reviewToggle).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.toggle");
expect(screen.queryByRole("button", { name: "Approve and enable" })).not.toBeInTheDocument();
fireEvent.click(reviewToggle);
expect(reviewToggle).toHaveAttribute("aria-expanded", "true");
expect(screen.getByRole("form", { name: "Capability review for com.acme.outbound" })).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.form");
expect(screen.getByText("Review com.acme.outbound capabilities")).toBeInTheDocument();
expect(screen.getAllByText("No additional scope.")).toHaveLength(2);
expect(screen.getByText("log")).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.grantName");
expect(screen.getByText("Low risk")).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.risk");
expect(screen.getByText("Available in this runtime")).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.availability");
const approveButton = screen.getByRole("button", { name: "Approve and enable" });
expect(approveButton).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.button");
expect(approveButton).toBeDisabled();
const reviewCheckbox = screen.getByLabelText("I reviewed Logging.");
expect(reviewCheckbox).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.checkbox");
fireEvent.click(reviewCheckbox);
expect(approveButton).toBeEnabled();
expect(document.querySelector('input[name="op"]')).toHaveAttribute("value", "grantAndEnable");
expect(document.querySelector('input[name="capabilities[]"]')).toHaveAttribute("value", "log");
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "yes");
expect(document.querySelector('input[name="capabilityReviewDigest"]')).toHaveAttribute("value", "review-digest");
const denyButton = screen.getByRole("button", { name: "Deny" });
expect(denyButton).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.deny");
fireEvent.click(denyButton);
expect(screen.queryByRole("form", { name: "Capability review for com.acme.outbound" })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Review capabilities" }));
expect(screen.getByLabelText("I reviewed Logging.")).not.toBeChecked();
expect(screen.getByRole("button", { name: "Approve and enable" })).toBeDisabled();
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "no");
});
it("keeps approval disabled until every missing capability is reviewed", () => {
setLoaderData(true, {
...pluginItem,
enabled: false,
capabilities: [
{
name: "log",
scope: null,
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "low", productionAvailable: true },
},
{
name: "audit",
scope: null,
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "medium", productionAvailable: true },
},
],
missingCapabilities: ["log", "audit"],
});
renderPluginsRoute();
fireEvent.click(screen.getByRole("button", { name: "Review capabilities" }));
const approveButton = screen.getByRole("button", { name: "Approve and enable" });
expect(approveButton).toBeDisabled();
fireEvent.click(screen.getByLabelText("I reviewed Logging."));
expect(approveButton).toBeDisabled();
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "no");
fireEvent.click(screen.getByLabelText("I reviewed Audit logging."));
expect(approveButton).toBeEnabled();
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "yes");
});
it("requires explicit review before enabling hook-only plugins", () => {
setLoaderData(true, {
...pluginItem,
pluginId: "com.acme.workflow-hook",
enabled: false,
capabilities: [
{
name: "hook:workflow.executed",
scope: null,
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "medium", productionAvailable: true },
},
],
missingCapabilities: ["hook:workflow.executed"],
manifestJson: JSON.stringify({ id: "com.acme.workflow-hook", hooks: [{ name: "workflow.executed", export: "onWorkflowExecuted" }] }, null, 2),
hasSettingsUi: false,
});
renderPluginsRoute();
expect(screen.getByText("Hook: workflow.executed")).toBeInTheDocument();
expect(screen.getByText("Approval required")).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Enable" })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Review capabilities" }));
const approveButton = screen.getByRole("button", { name: "Approve and enable" });
expect(approveButton).toBeDisabled();
const reviewCheckbox = screen.getByLabelText("I reviewed Hook: workflow.executed.");
expect(reviewCheckbox).toHaveAttribute("value", "hook:workflow.executed");
expect(screen.getByText("Medium risk")).toBeInTheDocument();
expect(screen.getByText("Available in this runtime")).toBeInTheDocument();
expect(screen.getAllByText("No additional scope.")).toHaveLength(2);
fireEvent.click(reviewCheckbox);
expect(approveButton).toBeEnabled();
expect(document.querySelector('input[name="op"]')).toHaveAttribute("value", "grantAndEnable");
expect(document.querySelector('input[name="capabilities[]"]')).toHaveAttribute("value", "hook:workflow.executed");
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "yes");
});
it("resets reviewed capability state when the review digest changes", () => {
const itemWithMissingCapability = {
...pluginItem,
enabled: false,
capabilities: [
{
name: "log",
scope: null,
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "low", productionAvailable: true },
},
],
missingCapabilities: ["log"],
};
setLoaderData(true, itemWithMissingCapability);
const view = renderPluginsRoute();
fireEvent.click(screen.getByRole("button", { name: "Review capabilities" }));
fireEvent.click(screen.getByLabelText("I reviewed Logging."));
expect(screen.getByRole("button", { name: "Approve and enable" })).toBeEnabled();
setLoaderData(true, {
...itemWithMissingCapability,
capabilityReviewDigest: "changed-review-digest",
capabilities: [
{
name: "log",
scope: null,
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "low", productionAvailable: true },
},
],
});
view.rerender(
<MemoryRouter>
<TenantPluginsRoute />
</MemoryRouter>
);
expect(screen.getByLabelText("I reviewed Logging.")).not.toBeChecked();
expect(screen.getByRole("button", { name: "Approve and enable" })).toBeDisabled();
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "no");
expect(document.querySelector('input[name="capabilityReviewDigest"]')).toHaveAttribute("value", "changed-review-digest");
expect(screen.getAllByText("No additional scope.")).toHaveLength(2);
});
it("blocks approval for unavailable host bindings before submit", () => {
setLoaderData(true, {
...pluginItem,
enabled: false,
capabilities: [
{
name: "http.outbound",
scope: { allowedHosts: ["api.example.com"] },
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "high", productionAvailable: false },
},
],
missingCapabilities: ["http.outbound"],
});
renderPluginsRoute();
fireEvent.click(screen.getByRole("button", { name: "Review capabilities" }));
expect(screen.getByText("High risk")).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.risk");
expect(screen.getByText("Not available in this runtime")).toHaveAttribute("data-ui-id", "ui.plugins.capabilityReview.availability");
expect(screen.getByText("This host binding is not production-available yet. It cannot be approved until the operator enables a reviewed implementation.")).toHaveAttribute(
"data-ui-id",
"ui.plugins.capabilityReview.unavailableReason"
);
expect(screen.getByLabelText("I reviewed Outbound HTTP.")).toBeDisabled();
expect(screen.getByRole("button", { name: "Approve and enable" })).toBeDisabled();
expect(document.querySelector('input[name="capabilitiesReviewed"]')).toHaveAttribute("value", "no");
});
it("keeps capability-free plugins enable-able without consent controls", () => {
setLoaderData(true, {
...pluginItem,
enabled: false,
capabilities: [],
missingCapabilities: [],
});
renderPluginsRoute();
expect(screen.getByText("This plugin declares no capabilities.")).toBeInTheDocument();
expect(screen.getByRole("button", { name: "Enable" })).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Approve and enable" })).not.toBeInTheDocument();
expect(screen.queryByRole("link", { name: "Open settings" })).not.toBeInTheDocument();
});
it("has no axe violations for the read-only plugin list", async () => {
await expectNoAxeViolations(
<MemoryRouter>
<TenantPluginsRoute />
</MemoryRouter>
);
});
it("has no axe violations for plugin manager revoke controls", async () => {
setLoaderData(true);
await expectNoAxeViolations(
<MemoryRouter>
<TenantPluginsRoute />
</MemoryRouter>
);
});
it("has no axe violations for expanded capability review controls", async () => {
setLoaderData(true, {
...pluginItem,
enabled: false,
capabilities: [
{
name: "http.outbound",
scope: { allowedHosts: ["api.example.com"] },
granted: false,
grantedAt: null,
grantedScopeJson: null,
metadata: { risk: "high", productionAvailable: false },
},
],
missingCapabilities: ["http.outbound"],
});
const { container } = renderPluginsRoute();
fireEvent.click(screen.getByRole("button", { name: "Review capabilities" }));
expect(screen.getByRole("form", { name: "Capability review for com.acme.outbound" })).toBeInTheDocument();
expect((await runAxe(container)).violations).toEqual([]);
});
});
@@ -0,0 +1,127 @@
import "@testing-library/jest-dom";
import { render, screen } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { MemoryRouter } from "react-router";
import type { LoaderFunctionArgs } from "react-router";
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({ t: (key: string) => key })),
}));
const translations: Record<string, string> = {
"settings.policies.eyebrow": "Workspace policy status",
"settings.policies.heading": "Workspace policies",
"settings.policies.description": "These read-only boundaries describe how settings changes stay scoped to the current workspace.",
"settings.policies.resolvedWorkspace": "Resolved workspace:",
"settings.policies.sections.membership.heading": "Membership policy",
"settings.policies.sections.roles.heading": "Role policy",
"settings.policies.sections.billing.heading": "Billing policy",
"settings.policies.sections.notifications.heading": "Notification policy",
"settings.policies.sections.audit.heading": "Data and audit policy",
"settings.policies.sections.api.heading": "API policy",
"settings.policies.sections.membership.links.members": "Review members",
"settings.policies.sections.roles.links.roles": "Review roles",
"settings.policies.sections.billing.links.billing": "Review billing",
"settings.policies.sections.notifications.links.notifications": "Review notifications",
"settings.policies.sections.audit.links.audit": "Review audit logs",
"settings.policies.sections.api.links.api": "Review API settings",
};
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string) => translations[key] ?? key }),
}));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({
verifyUserHasPermission: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/app/UrlUtils", () => ({
default: {
currentTenantUrl: vi.fn((params: { tenant?: string }, path: string) => `/${params.tenant}/${path}`),
},
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
useLoaderData: () => routeLoaderData,
useParams: () => ({ tenant: "acme" }),
};
});
import UrlUtils from "~/utils/app/UrlUtils";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import WorkspacePoliciesRoute, { loader } from "./policies";
let routeLoaderData: unknown;
const request = new Request("https://app.example.test/acme/settings/policies");
const params = { tenant: "acme" };
function routeArgs(): LoaderFunctionArgs {
return { request, params, context: {}, unstable_pattern: "app.$tenant/settings/policies" };
}
describe("workspace policies settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "ToolCTRL";
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant_1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
routeLoaderData = { title: "settings.policies.title | ToolCTRL", workspaceSlug: "acme" };
});
it("requires account settings permission for the resolved tenant before rendering policy data", async () => {
const data = await loader(routeArgs());
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(request, "app.settings.account.view", "tenant_1");
expect(vi.mocked(getTenantIdFromUrl).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(verifyUserHasPermission).mock.invocationCallOrder[0]);
expect(data).toEqual({ title: "settings.policies.title | ToolCTRL", workspaceSlug: "acme" });
});
it("propagates permission rejection after tenant resolution", async () => {
const rejection = new Response("Forbidden", { status: 403 });
vi.mocked(verifyUserHasPermission).mockRejectedValueOnce(rejection as never);
await expect(loader(routeArgs())).rejects.toBe(rejection);
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(verifyUserHasPermission).toHaveBeenCalledWith(request, "app.settings.account.view", "tenant_1");
});
it("renders all workspace policy section headings and tenant-scoped settings links", () => {
render(
<MemoryRouter>
<WorkspacePoliciesRoute />
</MemoryRouter>,
);
expect(screen.getByRole("heading", { name: "Workspace policies" })).toBeInTheDocument();
expect(screen.getByText("Resolved workspace:")).toBeInTheDocument();
expect(screen.getByText("acme")).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Membership policy" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Role policy" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Billing policy" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Notification policy" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Data and audit policy" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "API policy" })).toBeInTheDocument();
expect(screen.getByRole("link", { name: "Review members" })).toHaveAttribute("href", "/acme/settings/members");
expect(screen.getByRole("link", { name: "Review roles" })).toHaveAttribute("href", "/acme/settings/roles-and-permissions");
expect(screen.getByRole("link", { name: "Review billing" })).toHaveAttribute("href", "/acme/settings/subscription");
expect(screen.getByRole("link", { name: "Review notifications" })).toHaveAttribute("href", "/acme/settings/notifications");
expect(screen.getByRole("link", { name: "Review audit logs" })).toHaveAttribute("href", "/acme/settings/logs");
expect(screen.getByRole("link", { name: "Review API settings" })).toHaveAttribute("href", "/acme/settings/api");
expect(UrlUtils.currentTenantUrl).toHaveBeenCalledWith({ tenant: "acme" }, "settings/api");
});
it("keeps rendered policy copy free of secret-like placeholders", () => {
const { container } = render(
<MemoryRouter>
<WorkspacePoliciesRoute />
</MemoryRouter>,
);
expect(container.textContent).not.toMatch(/token|secret|password|apiKey=/i);
});
});
@@ -0,0 +1,100 @@
import { LoaderFunctionArgs, MetaFunction, useLoaderData, useParams } from "react-router";
import { useTranslation } from "react-i18next";
import UrlUtils from "~/utils/app/UrlUtils";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
type PolicyLink = {
labelKey: string;
path: string;
};
type PolicySection = {
id: string;
links: PolicyLink[];
};
type LoaderData = {
title: string;
workspaceSlug: string;
};
const POLICY_SECTIONS: PolicySection[] = [
{
id: "membership",
links: [{ labelKey: "settings.policies.sections.membership.links.members", path: "settings/members" }],
},
{
id: "roles",
links: [{ labelKey: "settings.policies.sections.roles.links.roles", path: "settings/roles-and-permissions" }],
},
{
id: "billing",
links: [{ labelKey: "settings.policies.sections.billing.links.billing", path: "settings/subscription" }],
},
{
id: "notifications",
links: [{ labelKey: "settings.policies.sections.notifications.links.notifications", path: "settings/notifications" }],
},
{
id: "audit",
links: [{ labelKey: "settings.policies.sections.audit.links.audit", path: "settings/logs" }],
},
{
id: "api",
links: [{ labelKey: "settings.policies.sections.api.links.api", path: "settings/api" }],
},
];
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.account.view", tenantId);
const { t } = await getTranslations(request);
const data: LoaderData = {
title: `${t("settings.policies.title")} | ${process.env.APP_NAME}`,
workspaceSlug: params.tenant ?? "",
};
return data;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function WorkspacePoliciesRoute() {
const data = useLoaderData<LoaderData>();
const params = useParams();
const { t } = useTranslation();
return (
<main data-ui-id="ui.settings.policies.page" className="mx-auto grid max-w-4xl gap-6 px-4 py-5 sm:px-8">
<div className="space-y-2">
<p className="text-sm font-medium text-primary">{t("settings.policies.eyebrow")}</p>
<h1 className="text-2xl font-semibold text-foreground">{t("settings.policies.heading")}</h1>
<p className="max-w-3xl text-sm text-muted-foreground">{t("settings.policies.description")}</p>
</div>
<div className="rounded-lg border bg-card p-4 text-sm text-muted-foreground">
<span className="font-medium text-foreground">{t("settings.policies.resolvedWorkspace")}</span> {data.workspaceSlug}
</div>
<div className="grid gap-4 md:grid-cols-2">
{POLICY_SECTIONS.map((section) => (
<section key={section.id} data-ui-id={`ui.settings.policies.section.${section.id}`} className="rounded-lg border bg-card p-5 shadow-sm">
<div className="space-y-2">
<h2 className="text-base font-semibold text-foreground">{t(`settings.policies.sections.${section.id}.heading`)}</h2>
<p className="text-sm leading-6 text-muted-foreground">{t(`settings.policies.sections.${section.id}.body`)}</p>
</div>
<div className="mt-4 flex flex-wrap gap-2">
{section.links.map((link) => (
<a key={link.path} href={UrlUtils.currentTenantUrl(params, link.path)} className="text-sm font-medium text-primary underline-offset-2 hover:underline">
{t(link.labelKey)}
</a>
))}
</div>
</section>
))}
</div>
</main>
);
}
@@ -0,0 +1,117 @@
// @vitest-environment node
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } from "react-router";
const mocks = vi.hoisted(() => ({
createAuditEvent: vi.fn(),
db: {
user: {
findUnique: vi.fn(),
update: vi.fn(),
},
},
getTenantIdFromUrl: vi.fn(),
getTranslations: vi.fn(),
getUserInfo: vi.fn(),
requireAuth: vi.fn(),
sendEmailMailjet: vi.fn(),
signDeletionToken: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("@toolctrl/db/audit-events.server", () => ({ createAuditEvent: (...args: unknown[]) => mocks.createAuditEvent(...args) }));
vi.mock("@toolctrl/db/client.server", () => ({ getDbClient: () => mocks.db }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: (...args: unknown[]) => mocks.getTranslations(...args) }));
vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: (...args: unknown[]) => mocks.requireAuth(...args) }));
vi.mock("~/utils/session.server", () => ({
getUserInfo: (...args: unknown[]) => mocks.getUserInfo(...args),
validateCSRFToken: (...args: unknown[]) => mocks.validateCSRFToken(...args),
}));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: (...args: unknown[]) => mocks.getTenantIdFromUrl(...args) }));
vi.mock("~/utils/dsgvo/deletionToken.server", () => ({
DeletionTokenSecretMissingError: class DeletionTokenSecretMissingError extends Error {},
signDeletionToken: (...args: unknown[]) => mocks.signDeletionToken(...args),
}));
vi.mock("~/modules/emails/services/MailjetEmailService", () => ({
sendEmailMailjet: (...args: unknown[]) => mocks.sendEmailMailjet(...args),
}));
import { action } from "./privacy";
const originalAppName = process.env.APP_NAME;
const translations: Record<string, string> = {
"settings.privacy.mail.deleteConfirm.defaultAppName": "this application",
"settings.privacy.mail.deleteConfirm.subject": "Confirm account deletion for {{appName}}",
"settings.privacy.mail.deleteConfirm.intro": "We received a request to delete your account for {{appName}}.",
"settings.privacy.mail.deleteConfirm.instructions": "To confirm, please click the link below within {{hours}} hours:",
"settings.privacy.mail.deleteConfirm.gracePeriod": "After confirmation a {{days}}-day grace period begins.",
"settings.privacy.mail.deleteConfirm.ignore": "If you did not request this, ignore this email. (Request id: {{requestId}})",
"settings.privacy.messages.deleteConfirmationSent": "Sent to {{email}} for {{hours}} hours and {{days}} days.",
};
function t(key: string, values: Record<string, unknown> = {}) {
return Object.entries(values).reduce(
(message, [name, value]) => message.replaceAll(`{{${name}}}`, String(value)),
translations[key] ?? key
);
}
function createDeleteRequest() {
return new Request("https://app.example.test/app/acme/settings/privacy", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams([
["intent", "delete"],
["confirmation", "DELETE"],
["csrf", "csrf-token"],
]),
});
}
async function callDeleteAction() {
return action({
request: createDeleteRequest(),
params: { tenant: "acme" },
context: {},
unstable_pattern: "app.$tenant/settings/privacy",
} as ActionFunctionArgs) as Promise<Response>;
}
describe("privacy deletion confirmation email", () => {
beforeEach(() => {
vi.clearAllMocks();
delete process.env.APP_NAME;
mocks.createAuditEvent.mockResolvedValue(undefined);
mocks.getTenantIdFromUrl.mockResolvedValue("tenant-1");
mocks.getTranslations.mockResolvedValue({ t });
mocks.getUserInfo.mockResolvedValue({ userId: "user-1" });
mocks.requireAuth.mockResolvedValue(undefined);
mocks.validateCSRFToken.mockResolvedValue(undefined);
mocks.signDeletionToken.mockReturnValue("signed-delete-token");
mocks.db.user.findUnique.mockResolvedValue({ email: "ada@example.test" });
mocks.sendEmailMailjet.mockResolvedValue({ provider: "queue", status: "queued", messageId: "job-1" });
});
afterEach(() => {
if (originalAppName === undefined) {
delete process.env.APP_NAME;
} else {
process.env.APP_NAME = originalAppName;
}
});
it("uses a grammatical neutral app-name fallback in queued deletion emails", async () => {
const response = await callDeleteAction();
const data = await response.json();
expect(response.status).toBe(200);
expect(data).toMatchObject({ intent: "delete", ok: true, emailSent: true });
expect(mocks.sendEmailMailjet).toHaveBeenCalledTimes(1);
const queued = mocks.sendEmailMailjet.mock.calls[0]?.[0] as { data?: { subject?: string; body?: string } };
expect(queued.data?.subject).toBe("Confirm account deletion for this application");
expect(queued.data?.body).toContain("delete your account for this application");
expect(`${queued.data?.subject}\n${queued.data?.body}`).not.toMatch(/your your|undefined/);
});
});
@@ -0,0 +1,217 @@
/**
* Phase 10 Task #68 — DSGVO deletion-confirmation route.
*
* Handles the link emailed by the self-service privacy page after a user
* requests account deletion. The HMAC-signed token in the URL identifies
* the user and bounds the validity window (default 24h). Only when the
* user opens this link AND submits the confirmation button (POST) does
* the system actually flip `User.pendingDeletion=true` and schedule the
* 30-day grace-period deletion.
*
* GET /app/:tenant/settings/privacy/delete/confirm/:token
* → verify token; show "Confirm Deletion" button or expired-page.
*
* POST same path
* → re-verify (defense-in-depth), flip User.pendingDeletion +
* scheduledDeletionAt = now + GRACE_DAYS, audit, show the
* reactivate-link page.
*
* The audit row uses regulatoryScope=[gdpr], dataSensitivity=pii,
* actorType=user (the user themself triggered) and metadata.requestId
* for cross-correlation with the earlier email-send audit.
*/
import { randomUUID } from "node:crypto";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { Form, useActionData, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { createAuditEvent } from "@toolctrl/db/audit-events.server";
import { getDbClient } from "@toolctrl/db/client.server";
import { useLocaleFormatters } from "~/locale/format";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { requireAuth } from "~/utils/loaders.middleware";
import { verifyDeletionToken } from "~/utils/dsgvo/deletionToken.server";
const DSGVO_GRACE_PERIOD_DAYS = Number(process.env.DSGVO_GRACE_PERIOD_DAYS ?? "30") || 30;
type LoaderData =
| { stage: "ready"; tenantSlug: string; userEmail: string; expiresAtIso: string }
| { stage: "expired"; tenantSlug: string };
type ActionData =
| { stage: "confirmed"; scheduledDeletionAtIso: string; tenantSlug: string }
| { stage: "expired"; tenantSlug: string }
| { stage: "mismatch"; tenantSlug: string }
| { ok: false; error: string };
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
// The user MUST be authenticated as the deletion target before we even
// show the confirm button — owning the email link alone is not enough,
// they must also have an active session for that same user id.
await requireAuth({ request, params });
const userInfo = await getUserInfo(request);
const tenantSlug = params.tenant ?? "";
const token = params.token ?? "";
const payload = verifyDeletionToken(token);
if (!payload) {
const data: LoaderData = { stage: "expired", tenantSlug };
return Response.json(data);
}
if (payload.userId !== userInfo.userId) {
// Same as expired from the end-user perspective — never disclose
// that the token is valid for a different user.
const data: LoaderData = { stage: "expired", tenantSlug };
return Response.json(data);
}
const db = getDbClient();
const user = await db.user.findUnique({ where: { id: userInfo.userId }, select: { email: true } });
if (!user) {
const data: LoaderData = { stage: "expired", tenantSlug };
return Response.json(data);
}
const data: LoaderData = {
stage: "ready",
tenantSlug,
userEmail: user.email,
expiresAtIso: new Date(payload.exp * 1000).toISOString(),
};
return Response.json(data);
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await requireAuth({ request, params });
await validateCSRFToken(request);
const userInfo = await getUserInfo(request);
const tenantId = await getTenantIdFromUrl(params);
const tenantSlug = params.tenant ?? "";
const token = params.token ?? "";
const payload = verifyDeletionToken(token);
if (!payload) {
const data: ActionData = { stage: "expired", tenantSlug };
return Response.json(data, { status: 410 });
}
if (payload.userId !== userInfo.userId) {
const data: ActionData = { stage: "mismatch", tenantSlug };
return Response.json(data, { status: 403 });
}
const db = getDbClient();
const requestId = randomUUID();
const now = new Date();
const scheduledDeletionAt = new Date(now.getTime() + DSGVO_GRACE_PERIOD_DAYS * 24 * 60 * 60 * 1000);
await db.user.update({
where: { id: userInfo.userId },
data: {
pendingDeletion: true,
deletionRequestedAt: now,
scheduledDeletionAt,
deletionRequestId: requestId,
},
});
await createAuditEvent({
tenantId,
actorId: userInfo.userId,
actorType: "user",
action: "REQUEST_USER_DELETION",
targetType: "User",
targetId: userInfo.userId,
regulatoryScope: ["gdpr"],
dataSensitivity: "pii",
outcome: "success",
metadata: {
requestId,
intent: "delete",
source: "self-service",
phase: "confirmed-via-email-link",
scheduledDeletionAt: scheduledDeletionAt.toISOString(),
tokenRequestedAt: payload.requestedAt,
},
});
const data: ActionData = { stage: "confirmed", scheduledDeletionAtIso: scheduledDeletionAt.toISOString(), tenantSlug };
return Response.json(data);
};
export default function PrivacyDeleteConfirmRoute() {
const data = useLoaderData<LoaderData>();
const action = useActionData<ActionData>();
const { t } = useTranslation();
const formatters = useLocaleFormatters();
const reactivateHref = `/app/${encodeURIComponent("tenantSlug" in data ? data.tenantSlug : "")}/settings/privacy`;
if (action && "stage" in action && action.stage === "confirmed") {
const reactivate = `/app/${encodeURIComponent(action.tenantSlug)}/settings/privacy`;
return (
<div className="mx-auto max-w-xl space-y-4 p-8">
<h1 className="text-xl font-semibold">{t("settings.privacy.deleteConfirm.confirmed.title")}</h1>
<p className="text-sm text-gray-700">
{t("settings.privacy.deleteConfirm.confirmed.bodyPrefix")}{" "}
<strong>{formatters.date(action.scheduledDeletionAtIso, { dateStyle: "medium", timeStyle: "short" })}</strong>.
{" "}
{t("settings.privacy.deleteConfirm.confirmed.bodySuffix")}
</p>
<p className="text-sm">
<a className="text-blue-600 underline" href={reactivate}>
{t("settings.privacy.deleteConfirm.confirmed.reactivate")}
</a>
</p>
</div>
);
}
if (action && "stage" in action && action.stage === "mismatch") {
return (
<div className="mx-auto max-w-xl space-y-4 p-8">
<h1 className="text-xl font-semibold">{t("settings.privacy.deleteConfirm.mismatch.title")}</h1>
<p className="text-sm text-gray-700">
{t("settings.privacy.deleteConfirm.mismatch.description")}
</p>
</div>
);
}
if (data.stage === "expired" || (action && "stage" in action && action.stage === "expired")) {
return (
<div className="mx-auto max-w-xl space-y-4 p-8">
<h1 className="text-xl font-semibold">{t("settings.privacy.deleteConfirm.expired.title")}</h1>
<p className="text-sm text-gray-700">
{t("settings.privacy.deleteConfirm.expired.description")}
</p>
<p className="text-sm">
<a className="text-blue-600 underline" href={reactivateHref}>
{t("settings.privacy.deleteConfirm.expired.returnToPrivacy")}
</a>
</p>
</div>
);
}
return (
<div className="mx-auto max-w-xl space-y-4 p-8">
<h1 className="text-xl font-semibold">{t("settings.privacy.deleteConfirm.ready.title")}</h1>
<p className="text-sm text-gray-700">
{t("settings.privacy.deleteConfirm.ready.bodyPrefix")}{" "}
<strong>{data.userEmail}</strong>.
{" "}
{t(
"settings.privacy.deleteConfirm.ready.bodySuffix",
{ days: formatters.number(DSGVO_GRACE_PERIOD_DAYS) },
)}
</p>
<p className="text-xs text-gray-500">
{t("settings.privacy.deleteConfirm.ready.expiresAt", {
date: formatters.date(data.expiresAtIso, { dateStyle: "medium", timeStyle: "short" }),
})}
</p>
<Form method="post">
<button
type="submit"
className="rounded bg-red-600 px-4 py-2 text-sm font-medium text-white hover:bg-red-500"
>
{t("settings.privacy.deleteConfirm.ready.submit")}
</button>
</Form>
</div>
);
}
@@ -0,0 +1,377 @@
/**
* Phase 10 Task #68 — DSGVO self-service privacy hub.
*
* Top-level settings page that lets a logged-in user manage their
* Art. 15/17/20 rights:
*
* • POST { intent: "export" } — enqueues a personal-data export
* (rate-limited to 1 per 7 days; the worker streams the bundle to
* S3 and emails a signed download URL).
*
* • POST { intent: "delete" } — emails a short-lived confirmation
* link. The confirmation route flips User.pendingDeletion +
* scheduledDeletionAt so a hijacked session cannot schedule deletion
* without inbox access.
*
* • POST { intent: "reactivate" } — cancels a pending deletion.
*
* Every action is audited with regulatoryScope=[gdpr],
* dataSensitivity=pii, actorType=user, and a stable requestId so the
* worker job can be correlated with the UI action.
*/
import { randomUUID } from "node:crypto";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { Form, redirect, useActionData, useLoaderData } from "react-router";
import { useTranslation } from "react-i18next";
import { createAuditEvent } from "@toolctrl/db/audit-events.server";
import { getDbClient } from "@toolctrl/db/client.server";
import { getTranslations } from "~/locale/i18next.server";
import { useLocaleFormatters } from "~/locale/format";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { requireAuth } from "~/utils/loaders.middleware";
import { DeletionTokenSecretMissingError, signDeletionToken } from "~/utils/dsgvo/deletionToken.server";
import { sendEmailMailjet } from "~/modules/emails/services/MailjetEmailService";
const DSGVO_GRACE_PERIOD_DAYS = Number(process.env.DSGVO_GRACE_PERIOD_DAYS ?? "30") || 30;
type LoaderData = {
title: string;
tenantSlug: string;
graceDays: number;
user: {
id: string;
email: string;
pendingDeletion: boolean;
scheduledDeletionAt: string | null;
pseudonymized: boolean;
};
};
type ActionData =
| { intent: "export"; ok: true; message: string }
| { intent: "delete"; ok: true; emailSent: true; message: string }
| { intent: "reactivate"; ok: true }
| { ok: false; error: string };
const DELETION_CONFIRM_TOKEN_TTL_HOURS = Number(process.env.DSGVO_CONFIRM_TOKEN_TTL_HOURS ?? "24") || 24;
function buildConfirmationUrl(request: Request, tenantSlug: string, token: string): string {
const origin = new URL(request.url).origin;
// Encode tenantSlug for safety; token is base64url which is already URL-safe.
return `${origin}/app/${encodeURIComponent(tenantSlug)}/settings/privacy/delete/confirm/${token}`;
}
function getDeletionMailAppName(t: (key: string) => string): string {
return process.env.APP_NAME?.trim() || t("settings.privacy.mail.deleteConfirm.defaultAppName");
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const userInfo = await getUserInfo(request);
const { t } = await getTranslations(request);
const db = getDbClient();
const user = await db.user.findUnique({
where: { id: userInfo.userId },
select: {
id: true,
email: true,
pendingDeletion: true,
scheduledDeletionAt: true,
pseudonymized: true,
},
});
if (!user) throw new Response(t("settings.privacy.errors.userNotFound"), { status: 404 });
const data: LoaderData = {
title: `${t("settings.privacy.title")} | ${process.env.APP_NAME ?? t("app.navbar.settings")}`,
tenantSlug: params.tenant ?? "",
graceDays: DSGVO_GRACE_PERIOD_DAYS,
user: {
id: user.id,
email: user.email,
pendingDeletion: user.pendingDeletion,
scheduledDeletionAt: user.scheduledDeletionAt ? user.scheduledDeletionAt.toISOString() : null,
pseudonymized: user.pseudonymized,
},
};
return Response.json(data);
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await requireAuth({ request, params });
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
const tenantId = await getTenantIdFromUrl(params);
const form = await request.formData();
const intent = String(form.get("intent") ?? "");
const db = getDbClient();
const requestId = randomUUID();
if (intent === "export") {
// Record the request as an AuditEvent — the worker job picks it up
// out-of-band (queue glue lives in apps/worker/src/index.ts).
await createAuditEvent({
tenantId,
actorId: userInfo.userId,
actorType: "user",
action: "REQUEST_PERSONAL_DATA_EXPORT",
targetType: "User",
targetId: userInfo.userId,
regulatoryScope: ["gdpr"],
dataSensitivity: "pii",
outcome: "success",
metadata: { requestId, intent: "export", source: "self-service" },
});
const data: ActionData = {
intent: "export",
ok: true,
message: t("settings.privacy.messages.exportRequested"),
};
return Response.json(data);
}
if (intent === "delete") {
const confirmation = String(form.get("confirmation") ?? "");
if (confirmation !== "LÖSCHEN" && confirmation.toUpperCase() !== "DELETE") {
const data: ActionData = {
ok: false,
error: t("settings.privacy.errors.confirmationMismatch"),
};
return Response.json(data, { status: 400 });
}
const user = await db.user.findUnique({ where: { id: userInfo.userId }, select: { email: true } });
if (!user) {
const data: ActionData = { ok: false, error: t("settings.privacy.errors.userNotFound") };
return Response.json(data, { status: 404 });
}
// Mint a short-lived signed token; do NOT mutate User.pendingDeletion yet.
// The pendingDeletion flag is only flipped after the user clicks the
// confirmation link emailed below — that protects against an attacker
// who has hijacked a session but cannot read the user's inbox.
let token: string;
try {
token = signDeletionToken({ userId: userInfo.userId, expiresInHours: DELETION_CONFIRM_TOKEN_TTL_HOURS });
} catch (err) {
if (err instanceof DeletionTokenSecretMissingError) {
const data: ActionData = {
ok: false,
error: t("settings.privacy.errors.deletionTokenSecretMissing"),
};
return Response.json(data, { status: 500 });
}
throw err;
}
const tenantSlug = params.tenant ?? "";
const confirmUrl = buildConfirmationUrl(request, tenantSlug, token);
const ttlHours = Math.min(Math.max(Math.floor(DELETION_CONFIRM_TOKEN_TTL_HOURS), 1), 72);
const appName = getDeletionMailAppName(t);
const mailSubject = t("settings.privacy.mail.deleteConfirm.subject", { appName });
const mailBody = [
t("settings.privacy.mail.deleteConfirm.intro", { appName }),
"",
t("settings.privacy.mail.deleteConfirm.instructions", { hours: ttlHours }),
"",
confirmUrl,
"",
t("settings.privacy.mail.deleteConfirm.gracePeriod", { days: DSGVO_GRACE_PERIOD_DAYS }),
"",
t("settings.privacy.mail.deleteConfirm.ignore", {
requestId,
}),
].join("\n");
try {
await sendEmailMailjet({
data: {
to: user.email,
subject: mailSubject,
body: mailBody,
tenantId: tenantId ?? undefined,
alias: "dsgvo-deletion-confirm",
data: { requestId, ttlHours },
priorityOverride: "high",
},
});
} catch (err) {
// Audit the failure so the operator sees the problem but do NOT leak
// detail to the end-user; deletion can always be re-requested.
await createAuditEvent({
tenantId,
actorId: userInfo.userId,
actorType: "user",
action: "REQUEST_USER_DELETION",
targetType: "User",
targetId: userInfo.userId,
regulatoryScope: ["gdpr"],
dataSensitivity: "pii",
outcome: "failure",
metadata: { requestId, intent: "delete", source: "self-service", phase: "send-confirmation-email", error: String(err) },
});
const data: ActionData = {
ok: false,
error: t("settings.privacy.errors.confirmationEmailFailed"),
};
return Response.json(data, { status: 502 });
}
await createAuditEvent({
tenantId,
actorId: userInfo.userId,
actorType: "user",
action: "REQUEST_USER_DELETION",
targetType: "User",
targetId: userInfo.userId,
regulatoryScope: ["gdpr"],
dataSensitivity: "pii",
outcome: "success",
metadata: { requestId, intent: "delete", source: "self-service", phase: "confirmation-email-sent" },
});
const successMessage = t(
"settings.privacy.messages.deleteConfirmationSent",
{ email: user.email, hours: ttlHours, days: DSGVO_GRACE_PERIOD_DAYS }
);
const ok: ActionData = {
intent: "delete",
ok: true,
emailSent: true,
message: successMessage,
};
return Response.json(ok);
}
if (intent === "reactivate") {
await db.user.update({
where: { id: userInfo.userId },
data: {
pendingDeletion: false,
deletionRequestedAt: null,
scheduledDeletionAt: null,
deletionRequestId: null,
},
});
await createAuditEvent({
tenantId,
actorId: userInfo.userId,
actorType: "user",
action: "CANCEL_USER_DELETION",
targetType: "User",
targetId: userInfo.userId,
regulatoryScope: ["gdpr"],
dataSensitivity: "pii",
outcome: "success",
metadata: { requestId, intent: "reactivate", source: "self-service" },
});
return redirect("./privacy");
}
const data: ActionData = { ok: false, error: t("settings.privacy.errors.unknownIntent", { intent }) };
return Response.json(data, { status: 400 });
};
export default function PrivacySettingsRoute() {
const data = useLoaderData<LoaderData>();
const action = useActionData<ActionData>();
const { t } = useTranslation();
const formatters = useLocaleFormatters();
return (
<div className="space-y-8 p-6" data-ui-id="ui.settings.privacy.page">
<header>
<h1 className="text-xl font-semibold">{t("settings.privacy.title")}</h1>
<p className="text-sm text-gray-500">
{t("settings.privacy.description")}
</p>
</header>
{action && "ok" in action && action.ok && "intent" in action && action.intent === "export" ? (
<div role="status" aria-live="polite" data-ui-id="ui.settings.privacy.status.export" className="rounded border border-green-300 bg-green-50 p-3 text-sm">
{action.message}
</div>
) : null}
{action && "ok" in action && action.ok && "intent" in action && action.intent === "delete" ? (
<div role="status" aria-live="polite" data-ui-id="ui.settings.privacy.status.delete" className="rounded border border-blue-300 bg-blue-50 p-3 text-sm">
{action.message}
</div>
) : null}
{action && "ok" in action && !action.ok ? (
<div role="alert" data-ui-id="ui.settings.privacy.alert" className="rounded border border-red-300 bg-red-50 p-3 text-sm">
{action.error}
</div>
) : null}
{/* Export */}
<section className="rounded border p-4">
<h2 className="text-lg font-medium">{t("settings.privacy.export.title")}</h2>
<p className="mt-1 text-sm text-gray-600">
{t("settings.privacy.export.description")}
</p>
<Form method="post" className="mt-3" data-ui-id="ui.settings.privacy.export.form">
<input type="hidden" name="intent" value="export" />
<button type="submit" className="rounded bg-blue-600 px-4 py-2 text-sm font-medium text-white hover:bg-blue-500">
{t("settings.privacy.export.submit")}
</button>
</Form>
</section>
{/* Delete or Reactivate */}
<section className="rounded border p-4">
<h2 className="text-lg font-medium">{t("settings.privacy.delete.title")}</h2>
{data.user.pendingDeletion ? (
<div className="mt-2 space-y-3">
<p className="text-sm">
{t("settings.privacy.delete.scheduledPrefix")}{" "}
<strong>
{data.user.scheduledDeletionAt
? formatters.date(data.user.scheduledDeletionAt, { dateStyle: "medium", timeStyle: "short" })
: t("settings.privacy.delete.unknownDate")}
</strong>
. {t("settings.privacy.delete.scheduledSuffix")}
</p>
<Form method="post" data-ui-id="ui.settings.privacy.reactivate.form">
<input type="hidden" name="intent" value="reactivate" />
<button type="submit" className="rounded bg-green-600 px-4 py-2 text-sm font-medium text-white hover:bg-green-500">
{t("settings.privacy.delete.reactivate")}
</button>
</Form>
</div>
) : (
<div className="mt-2 space-y-3">
<p className="text-sm text-gray-600">
{t(
"settings.privacy.delete.description",
{ days: formatters.number(data.graceDays) }
)}
</p>
<Form method="post" className="space-y-3" data-ui-id="ui.settings.privacy.delete.form">
<input type="hidden" name="intent" value="delete" />
<label className="block text-sm">
<span>{t("settings.privacy.delete.confirmationLabel")}</span>
<input name="confirmation" type="text" className="mt-1 w-full rounded border px-2 py-1" autoComplete="off" />
</label>
<button type="submit" className="rounded bg-red-600 px-4 py-2 text-sm font-medium text-white hover:bg-red-500">
{t("settings.privacy.delete.submit")}
</button>
</Form>
</div>
)}
</section>
<section className="rounded border p-4 text-sm">
<h2 className="text-lg font-medium">{t("settings.privacy.inventory.title")}</h2>
<p className="mt-1 text-gray-600">
{t("settings.privacy.inventory.descriptionPrefix")}{" "}
<a className="underline" href="/docs/features/dsgvo-bulk-ops">
{t("settings.privacy.inventory.documentationLink")}
</a>{" "}
{t("settings.privacy.inventory.descriptionSuffix")}
</p>
</section>
</div>
);
}
@@ -0,0 +1,33 @@
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import path from "node:path";
import { describe, expect, test } from "vitest";
// Guard test (#72 i18n-foundation): the tenant profile route MUST keep its
// locale picker. The picker itself lives in
// `apps/web/app/modules/users/components/UserProfileSettings.tsx`. The route
// composes the component and passes `currentSession.locale` so the UI can
// show the active language. If somebody refactors the picker out we want CI
// to scream — switching language is a privacy/UX requirement we already
// shipped, not an optional feature.
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const profilePath = path.join(__dirname, "profile.tsx");
const settingsPath = path.resolve(__dirname, "../../../modules/users/components/UserProfileSettings.tsx");
describe("tenant profile locale picker", () => {
test("profile route loader includes the active locale in currentSession", () => {
const source = readFileSync(profilePath, "utf8");
expect(source).toContain("currentSession: getCurrentSessionSettings");
expect(source).toContain("locale: userInfo.lng");
});
test("UserProfileSettings exposes a locale-picker InputSelect", () => {
const source = readFileSync(settingsPath, "utf8");
// The picker uses `i18nConfig.supportedLngs` to render the options and
// submits the change to the root /preferences action via setLocale.
expect(source).toContain("i18nConfig.supportedLngs");
expect(source).toMatch(/changedLocale\(/);
expect(source).toContain('"setLocale"');
expect(source).toContain('"/preferences"');
});
});
@@ -0,0 +1,544 @@
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) =>
({
"shared.invalidForm": "Form not submitted correctly.",
"shared.unexpectedError": "Unexpected error",
"settings.profile.errors.firstNameRequired": "First name required",
"settings.profile.errors.invalidPassword": "Invalid password.",
"settings.profile.errors.passwordMinLength": "Passwords must have least 6 characters.",
"settings.profile.errors.currentPasswordRequired": "Current password is required.",
"settings.profile.errors.cannotDeleteAdmin": "Cannot delete an admin",
"settings.profile.passwordUpdated": "Password updated",
"settings.profile.mfa.enrollmentStarted": "Authenticator enrollment started",
"settings.profile.mfa.enabled": "Authenticator enabled",
"settings.profile.mfa.disabled": "Authenticator disabled",
"settings.profile.mfa.enterCode": "Enter the 6-digit authenticator code.",
"settings.profile.mfa.noPendingEnrollment": "No pending authenticator enrollment found.",
"settings.profile.mfa.invalidCode": "Invalid authenticator code.",
})[key] ?? key,
})),
}));
vi.mock("~/utils/loaders.middleware", () => ({
requireAuth: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
getUserSession: vi.fn(),
storage: { destroySession: vi.fn() },
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenant: vi.fn(),
}));
vi.mock("~/utils/db.server", () => ({
db: {
user: {
findUnique: vi.fn(),
},
},
}));
vi.mock("~/utils/db/users.db.server", async (importOriginal) => {
const actual = await importOriginal<typeof import("~/utils/db/users.db.server")>();
return {
...actual,
activateUserTotpPendingSecret: vi.fn(),
disableUserTotp: vi.fn(),
getUserTotpPendingEnrollment: vi.fn(),
getUserTotpStatus: vi.fn(),
setUserMfaRecoveryCodes: vi.fn(),
setUserTotpPendingSecret: vi.fn(),
updateUserPassword: vi.fn(),
updateUserProfile: vi.fn(),
};
});
vi.mock("~/services/auth/totp.server", () => ({
startTotpEnrollment: vi.fn(),
verifyTotpCode: vi.fn(),
}));
vi.mock("~/utils/auth/mfa/recovery-codes.server", () => ({
generateRecoveryCodes: vi.fn(),
}));
vi.mock("~/modules/events/services/.server/EventsService", () => ({
default: { create: vi.fn() },
}));
vi.mock("bcryptjs", () => ({
default: { compare: vi.fn(), hash: vi.fn() },
}));
vi.mock("~/utils/auth/passwordHasher.server", () => ({
hashPassword: vi.fn(async () => "new-hash"),
verifyPassword: vi.fn(async () => ({ valid: true })),
}));
vi.mock("~/services/auth/password-policy.server", () => ({
validatePassword: vi.fn(async () => ({ valid: true, errors: [] })),
loadPasswordPolicy: vi.fn(() => ({
minLength: 1,
requireUpper: false,
requireLower: false,
requireDigit: false,
requireSpecial: false,
hibpCheck: false,
hibpMaxOccurrences: 0,
})),
MIN_PASSWORD_LENGTH: 12,
}));
vi.mock("~/utils/integrations/storageService", () => ({ storeFile: vi.fn() }));
vi.mock("~/utils/services/userService", () => ({ deleteUserWithItsTenants: vi.fn() }));
import { hashPassword, verifyPassword } from "~/utils/auth/passwordHasher.server";
import { validatePassword as validatePolicyPassword } from "~/services/auth/password-policy.server";
import EventsService from "~/modules/events/services/.server/EventsService";
import { generateRecoveryCodes } from "~/utils/auth/mfa/recovery-codes.server";
import { startTotpEnrollment, verifyTotpCode } from "~/services/auth/totp.server";
import { db } from "~/utils/db.server";
import {
activateUserTotpPendingSecret,
disableUserTotp,
getUserTotpPendingEnrollment,
getUserTotpStatus,
setUserMfaRecoveryCodes,
setUserTotpPendingSecret,
updateUserPassword,
updateUserProfile,
} from "~/utils/db/users.db.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { getUserInfo, getUserSession, storage } from "~/utils/session.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { storeFile } from "~/utils/integrations/storageService";
import { deleteUserWithItsTenants } from "~/utils/services/userService";
import { action, loader } from "./profile";
import { appendCSRFToken } from "~/utils/csrf";
const params = { tenant: "acme" };
const user = {
id: "user_1",
email: "ada@example.com",
passwordHash: "hashed-password",
firstName: "Ada",
lastName: "Lovelace",
admin: null,
};
const tenant = { id: "tenant_1", slug: "acme" };
const disabledStatus = { enabled: false, pending: false, enabledAt: null, pendingCreatedAt: null };
const pendingStatus = { enabled: false, pending: true, enabledAt: null, pendingCreatedAt: new Date("2026-05-08T12:00:00.000Z") };
const enabledStatus = { enabled: true, pending: false, enabledAt: new Date("2026-05-08T12:05:00.000Z"), pendingCreatedAt: null };
const recoveryGeneratedAt = new Date("2026-05-08T12:05:01.000Z");
const recoveryCodes = ["ABCD-EFGH-JKLM", "NPQR-STUV-WXYZ"];
const recoveryEntries = recoveryCodes.map((code, index) => ({ hash: `hash-${index + 1}`, usedAt: null, createdAt: recoveryGeneratedAt }));
function postRequest(form: FormData) {
return new Request("https://app.example.test/acme/settings/profile", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
});
}
function formWithAction(actionName: string, values: Record<string, string> = {}) {
const form = new FormData();
appendCSRFToken(form);
form.set("action", actionName);
Object.entries(values).forEach(([key, value]) => form.set(key, value));
return form;
}
async function callAction(form: FormData) {
return action({
request: postRequest(form),
params,
context: {},
unstable_pattern: "app.$tenant/settings/profile",
} as ActionFunctionArgs) as Promise<Response>;
}
async function json(response: Response) {
return response.json() as Promise<Record<string, unknown>>;
}
function expectNoSecretLeak(payload: unknown) {
const serialized = JSON.stringify(payload);
expect(serialized).not.toContain("RAWSECRET");
expect(serialized).not.toContain("encrypted-secret");
expect(serialized).not.toContain("encrypted-pending");
expect(serialized).not.toContain("123456");
expect(serialized).not.toContain("password-123");
expect(serialized).not.toContain("totpSecretEncrypted");
expect(serialized).not.toContain("secret");
expect(serialized).not.toContain("ABCD-EFGH-JKLM");
expect(serialized).not.toContain("NPQR-STUV-WXYZ");
expect(serialized).not.toContain("hash-1");
expect(serialized).not.toContain("hash-2");
}
describe("profile MFA route actions", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(requireAuth).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue({ userId: user.id } as never);
vi.mocked(getUserSession).mockResolvedValue({ id: "session_1", get: vi.fn(), set: vi.fn(), unset: vi.fn() } as never);
vi.mocked(storage.destroySession).mockResolvedValue("RJ_session=; Max-Age=0; Path=/; HttpOnly" as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue(tenant.id);
vi.mocked(getTenant).mockResolvedValue(tenant as never);
vi.mocked(db.user.findUnique).mockResolvedValue(user as never);
vi.mocked(updateUserProfile).mockResolvedValue({ ...user, avatar: "stored-avatar" } as never);
vi.mocked(updateUserPassword).mockResolvedValue({ ...user, passwordHash: "new-hash" } as never);
vi.mocked(storeFile).mockResolvedValue("stored-avatar" as never);
vi.mocked(deleteUserWithItsTenants).mockResolvedValue({ deletedTenants: [{ id: tenant.id, name: "Acme" }] } as never);
vi.mocked(getUserTotpStatus).mockResolvedValue(disabledStatus);
vi.mocked(verifyPassword).mockResolvedValue({ valid: true });
vi.mocked(startTotpEnrollment).mockReturnValue({
secret: "RAWSECRET",
encryptedSecret: "encrypted-secret",
otpauthUri: "otpauth://totp/ToolCTRL:ada@example.com?secret=RAWSECRET&issuer=ToolCTRL",
qrValue: "otpauth://totp/ToolCTRL:ada@example.com?secret=RAWSECRET&issuer=ToolCTRL",
});
vi.mocked(verifyTotpCode).mockReturnValue(true);
vi.mocked(getUserTotpPendingEnrollment).mockResolvedValue({
totpPendingSecretEncrypted: "encrypted-pending",
totpPendingCreatedAt: pendingStatus.pendingCreatedAt,
});
vi.mocked(generateRecoveryCodes).mockReturnValue({
codes: recoveryCodes,
entries: recoveryEntries,
generatedAt: recoveryGeneratedAt,
});
});
it("loader exposes only non-secret MFA status for the current user", async () => {
const response = await loader({
request: new Request("https://app.example.test/acme/settings/profile"),
params,
context: {},
unstable_pattern: "app.$tenant/settings/profile",
} as LoaderFunctionArgs);
expect(requireAuth).toHaveBeenCalled();
expect(getUserTotpStatus).toHaveBeenCalledWith(user.id);
expect(response).toMatchObject({ mfaStatus: disabledStatus });
expect(response).not.toHaveProperty("recoveryCodes");
expectNoSecretLeak(response);
});
it("starts TOTP enrollment after validating the current password", async () => {
vi.mocked(getUserTotpStatus).mockResolvedValueOnce(disabledStatus).mockResolvedValueOnce(pendingStatus);
const response = await callAction(formWithAction("startTotpEnrollment", { passwordCurrent: "password-123" }));
const body = await json(response);
expect(response.status).toBe(200);
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
expect(setUserTotpPendingSecret).toHaveBeenCalledWith(user.id, "encrypted-secret");
expect(body).toEqual({
success: "Authenticator enrollment started",
mfaStatus: { ...pendingStatus, pendingCreatedAt: pendingStatus.pendingCreatedAt?.toISOString() },
otpauthUri: expect.stringContaining("otpauth://"),
});
expect(JSON.stringify(body)).not.toContain("encrypted-secret");
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
});
it("rejects start enrollment with a bad password without persisting pending state", async () => {
vi.mocked(verifyPassword).mockResolvedValue({ valid: false });
const response = await callAction(formWithAction("startTotpEnrollment", { passwordCurrent: "password-123" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Invalid password." });
expect(setUserTotpPendingSecret).not.toHaveBeenCalled();
expectNoSecretLeak(body);
});
it("confirms pending TOTP enrollment and returns one-time recovery codes", async () => {
vi.mocked(getUserTotpStatus).mockResolvedValueOnce(pendingStatus).mockResolvedValueOnce(enabledStatus);
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "123456", userId: "attacker" }));
const body = await json(response);
expect(response.status).toBe(200);
expect(verifyTotpCode).toHaveBeenCalledWith("encrypted-pending", "123456");
expect(activateUserTotpPendingSecret).toHaveBeenCalledWith(user.id, "encrypted-pending");
expect(generateRecoveryCodes).toHaveBeenCalledTimes(1);
expect(setUserMfaRecoveryCodes).toHaveBeenCalledWith(user.id, recoveryEntries, recoveryGeneratedAt);
expect(JSON.stringify(vi.mocked(activateUserTotpPendingSecret).mock.calls)).not.toContain("attacker");
expect(body).toEqual({
success: "Authenticator enabled",
mfaStatus: { ...enabledStatus, enabledAt: enabledStatus.enabledAt?.toISOString() },
recoveryCodes,
});
expect(JSON.stringify(body)).not.toContain("hash-1");
expect(JSON.stringify(body)).not.toContain("hash-2");
const enabledEvent = vi.mocked(EventsService.create).mock.calls.at(-1)?.[0];
expect(enabledEvent?.data).toMatchObject({
recoveryCodes: { generatedCount: 2, remainingCount: 2, generatedAt: recoveryGeneratedAt },
});
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
});
it("rejects invalid or missing TOTP codes before verification", async () => {
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "12ab56" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Enter the 6-digit authenticator code." });
expect(verifyTotpCode).not.toHaveBeenCalled();
expect(generateRecoveryCodes).not.toHaveBeenCalled();
expect(setUserMfaRecoveryCodes).not.toHaveBeenCalled();
expectNoSecretLeak(body);
});
it("rejects confirmation without a pending secret", async () => {
vi.mocked(getUserTotpPendingEnrollment).mockResolvedValue({ totpPendingSecretEncrypted: null, totpPendingCreatedAt: null });
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "123456" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "No pending authenticator enrollment found." });
expect(activateUserTotpPendingSecret).not.toHaveBeenCalled();
expectNoSecretLeak(body);
});
it("rejects invalid confirmation codes without activating pending state", async () => {
vi.mocked(verifyTotpCode).mockReturnValue(false);
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "123456" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Invalid authenticator code." });
expect(activateUserTotpPendingSecret).not.toHaveBeenCalled();
expect(generateRecoveryCodes).not.toHaveBeenCalled();
expect(setUserMfaRecoveryCodes).not.toHaveBeenCalled();
expectNoSecretLeak(body);
});
it("disables TOTP only after validating the current password", async () => {
vi.mocked(getUserTotpStatus).mockResolvedValueOnce(enabledStatus).mockResolvedValueOnce(disabledStatus);
const response = await callAction(formWithAction("disableTotpEnrollment", { passwordCurrent: "password-123" }));
const body = await json(response);
expect(response.status).toBe(200);
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
expect(disableUserTotp).toHaveBeenCalledWith(user.id);
expect(body).toEqual({ success: "Authenticator disabled", mfaStatus: disabledStatus });
expectNoSecretLeak(body);
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
});
it("rejects disabling without a password", async () => {
const response = await callAction(formWithAction("disableTotpEnrollment"));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Current password is required." });
expect(disableUserTotp).not.toHaveBeenCalled();
});
it("propagates unauthenticated rejection before reading or mutating MFA state", async () => {
const rejection = new Response(null, { status: 302, headers: { Location: "/login" } });
vi.mocked(requireAuth).mockRejectedValueOnce(rejection as never);
await expect(callAction(formWithAction("startTotpEnrollment", { passwordCurrent: "password-123" }))).rejects.toBe(rejection);
expect(getUserInfo).not.toHaveBeenCalled();
expect(setUserTotpPendingSecret).not.toHaveBeenCalled();
});
it("updates profile fields for the authenticated user and ignores tampered form user IDs", async () => {
const response = await callAction(
formWithAction("profile", {
userId: "attacker",
firstName: "Grace",
lastName: "Hopper",
avatar: "data:image/png;base64,avatar",
passwordCurrent: "password-123",
})
);
const body = await json(response);
expect(response.status).toBe(200);
expect(storeFile).toHaveBeenCalledWith(
expect.objectContaining({
bucket: "users-icons",
content: "data:image/png;base64,avatar",
id: user.id,
scan: expect.objectContaining({ context: "avatar", filename: `${user.id}.avatar` }),
})
);
expect(updateUserProfile).toHaveBeenCalledWith({ firstName: "Grace", lastName: "Hopper", avatar: "stored-avatar" }, user.id);
expect(JSON.stringify(vi.mocked(updateUserProfile).mock.calls)).not.toContain("attacker");
expect(body).toEqual({ success: "shared.updated" });
expect(vi.mocked(EventsService.create).mock.calls.at(-1)?.[0]).toMatchObject({
event: "user.profile.updated",
userId: user.id,
data: {
email: user.email,
new: { firstName: "Grace", lastName: "Hopper" },
old: { firstName: user.firstName, lastName: user.lastName },
userId: user.id,
},
});
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
});
it("rejects invalid profile payloads before updating the authenticated user", async () => {
const response = await callAction(formWithAction("profile", { firstName: "A", lastName: "Hopper", userId: "attacker" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Form not submitted correctly.", fields: { firstName: "First name required" } });
expect(updateUserProfile).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("changes password only after comparing the current password and hashes the submitted new password", async () => {
// hashPassword mock is already set to return "new-hash" globally.
const response = await callAction(
formWithAction("password", {
userId: "attacker",
passwordCurrent: "password-123",
passwordNew: "new-password",
passwordNewConfirm: "new-password",
})
);
const body = await json(response);
expect(response.status).toBe(200);
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
expect(hashPassword).toHaveBeenCalledWith("new-password");
expect(updateUserPassword).toHaveBeenCalledWith({ passwordHash: "new-hash" }, user.id);
expect(JSON.stringify(vi.mocked(updateUserPassword).mock.calls)).not.toContain("attacker");
expect(body).toEqual({ passwordSuccess: "Password updated" });
expect(vi.mocked(EventsService.create).mock.calls.at(-1)?.[0]).toMatchObject({
event: "user.password.updated",
userId: user.id,
data: { user: { id: user.id, email: user.email } },
});
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
});
it("rejects bad current passwords before hashing or updating the password", async () => {
vi.mocked(verifyPassword).mockResolvedValue({ valid: false });
const response = await callAction(
formWithAction("password", { passwordCurrent: "password-123", passwordNew: "new-password", passwordNewConfirm: "new-password" })
);
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid password." });
expect(hashPassword).not.toHaveBeenCalled();
expect(updateUserPassword).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("rejects invalid password fields before comparing passwords", async () => {
vi.mocked(validatePolicyPassword).mockResolvedValueOnce({
valid: false,
errors: [{ code: "auth.password.errors.tooShort", args: { minLength: 12 } }],
});
const response = await callAction(formWithAction("password", { passwordCurrent: "password-123", passwordNew: "short", passwordNewConfirm: "short" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "auth.password.errors.tooShort" });
expect(verifyPassword).not.toHaveBeenCalled();
expect(updateUserPassword).not.toHaveBeenCalled();
});
it("deletes only the authenticated non-admin user and keeps deletion events redacted", async () => {
const response = await callAction(formWithAction("deleteAccount", { userId: "attacker", passwordCurrent: "password-123" }));
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("/login");
expect(getUserSession).toHaveBeenCalled();
expect(storage.destroySession).toHaveBeenCalledWith(expect.objectContaining({ id: "session_1" }));
expect(response.headers.get("Set-Cookie")).toContain("Max-Age=0");
expect(deleteUserWithItsTenants).toHaveBeenCalledWith(user.id);
expect(JSON.stringify(vi.mocked(deleteUserWithItsTenants).mock.calls)).not.toContain("attacker");
expect(vi.mocked(EventsService.create).mock.calls).toHaveLength(2);
expect(vi.mocked(EventsService.create).mock.calls[0][0]).toMatchObject({
event: "account.deleted",
userId: null,
data: { tenant: { id: tenant.id, name: "Acme" }, user: { id: user.id, email: user.email } },
});
expect(vi.mocked(EventsService.create).mock.calls[1][0]).toMatchObject({
event: "user.profile.deleted",
userId: null,
data: { id: user.id, email: user.email, firstName: user.firstName, lastName: user.lastName },
});
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
});
it("rejects account deletion without the current password", async () => {
const response = await callAction(formWithAction("deleteAccount"));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Current password is required." });
expect(verifyPassword).not.toHaveBeenCalled();
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("rejects account deletion with an invalid current password", async () => {
vi.mocked(verifyPassword).mockResolvedValue({ valid: false });
const response = await callAction(formWithAction("deleteAccount", { passwordCurrent: "password-123" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid password." });
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("returns an error when the deletion service fails after password validation", async () => {
vi.mocked(deleteUserWithItsTenants).mockRejectedValueOnce(new Error("delete failed") as never);
const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
const response = await callAction(formWithAction("deleteAccount", { passwordCurrent: "password-123" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Unexpected error" });
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
expect(EventsService.create).not.toHaveBeenCalled();
expect(storage.destroySession).not.toHaveBeenCalled();
expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
consoleError.mockRestore();
});
it("rejects admin account deletion before deleting user data", async () => {
vi.mocked(db.user.findUnique).mockResolvedValueOnce({ ...user, admin: { id: "admin_1" } } as never);
const response = await callAction(formWithAction("deleteAccount", { userId: "attacker", passwordCurrent: "password-123" }));
const body = await json(response);
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Cannot delete an admin" });
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
expect(EventsService.create).not.toHaveBeenCalled();
});
it("propagates unauthenticated rejection before profile, password, or delete mutations", async () => {
const rejection = new Response(null, { status: 302, headers: { Location: "/login" } });
vi.mocked(requireAuth).mockRejectedValueOnce(rejection as never);
await expect(callAction(formWithAction("profile", { firstName: "Grace", lastName: "Hopper" }))).rejects.toBe(rejection);
expect(getUserInfo).not.toHaveBeenCalled();
expect(updateUserProfile).not.toHaveBeenCalled();
expect(updateUserPassword).not.toHaveBeenCalled();
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,222 @@
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) =>
({
"settings.profile.mfa.sessionCleared": "Session MFA verification cleared",
})[key] ?? key,
})),
}));
vi.mock("~/utils/loaders.middleware", () => ({
requireAuth: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
commitSession: vi.fn(),
getUserInfo: vi.fn(),
getUserSession: vi.fn(),
storage: { destroySession: vi.fn() },
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/auth/mfa/step-up.server", () => ({
checkMfaStepUpState: vi.fn(),
clearMfaStepUpState: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenant: vi.fn(),
}));
vi.mock("~/utils/db.server", () => ({
db: { user: { findUnique: vi.fn() } },
}));
vi.mock("~/utils/db/users.db.server", async (importOriginal) => {
const actual = await importOriginal<typeof import("~/utils/db/users.db.server")>();
return {
...actual,
activateUserTotpPendingSecret: vi.fn(),
disableUserTotp: vi.fn(),
getUserTotpPendingEnrollment: vi.fn(),
getUserTotpStatus: vi.fn(),
setUserMfaRecoveryCodes: vi.fn(),
setUserTotpPendingSecret: vi.fn(),
updateUserPassword: vi.fn(),
updateUserProfile: vi.fn(),
};
});
vi.mock("~/services/auth/totp.server", () => ({
startTotpEnrollment: vi.fn(),
verifyTotpCode: vi.fn(),
}));
vi.mock("~/utils/auth/mfa/recovery-codes.server", () => ({
generateRecoveryCodes: vi.fn(),
}));
vi.mock("~/modules/events/services/.server/EventsService", () => ({
default: { create: vi.fn() },
}));
vi.mock("bcryptjs", () => ({
default: { compare: vi.fn(), hash: vi.fn() },
}));
vi.mock("~/utils/integrations/storageService", () => ({ storeFile: vi.fn() }));
vi.mock("~/utils/services/userService", () => ({ deleteUserWithItsTenants: vi.fn() }));
import { checkMfaStepUpState, clearMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
import { db } from "~/utils/db.server";
import { getUserTotpStatus } from "~/utils/db/users.db.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { commitSession, getUserInfo, getUserSession, validateCSRFToken } from "~/utils/session.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { action, loader } from "./profile";
const params = { tenant: "acme" };
const user = {
id: "user_1",
email: "ada@example.com",
passwordHash: "hashed-password",
firstName: "Ada",
lastName: "Lovelace",
admin: null,
};
const tenant = { id: "tenant_1", slug: "acme" };
const disabledStatus = { enabled: false, pending: false, enabledAt: null, pendingCreatedAt: null };
type SessionMock = {
get: ReturnType<typeof vi.fn>;
set: ReturnType<typeof vi.fn>;
unset: ReturnType<typeof vi.fn>;
};
function sessionMock(): SessionMock {
return { get: vi.fn(), set: vi.fn(), unset: vi.fn() };
}
function postRequest(actionName: string) {
return new Request("https://app.example.test/acme/settings/profile", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ action: actionName, csrf: "csrf-secret" }) });
}
async function callLoader() {
return loader({ request: new Request("https://app.example.test/acme/settings/profile"), params, context: {}, unstable_pattern: "app.$tenant/settings/profile" } as LoaderFunctionArgs);
}
async function callAction(actionName: string) {
return action({ request: postRequest(actionName), params, context: {}, unstable_pattern: "app.$tenant/settings/profile" } as ActionFunctionArgs) as Promise<Response>;
}
function expectNoSessionLeak(payload: unknown) {
const serialized = JSON.stringify(payload);
expect(serialized).not.toContain("RJ_session");
expect(serialized).not.toContain("raw-cookie-value");
expect(serialized).not.toContain("csrf-secret");
expect(serialized).not.toContain("adminMfaStepUp");
expect(serialized).not.toContain("redirectTo");
expect(serialized).not.toContain("actor-user-1");
expect(serialized).not.toContain("password");
}
describe("profile current-session settings", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(requireAuth).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue({
userId: user.id,
lng: "en",
lightOrDarkMode: "dark",
theme: "zinc",
csrf: "csrf-secret",
cookies: [
{ category: "REQUIRED", allowed: true },
{ category: "ANALYTICS", allowed: false },
{ category: "FUNCTIONAL", allowed: true },
],
impersonatingFromUserId: "actor-user-1",
impersonatingStartedAt: "2026-05-08T12:00:00.000Z",
} as never);
vi.mocked(getUserSession).mockResolvedValue(sessionMock() as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue(tenant.id);
vi.mocked(getTenant).mockResolvedValue(tenant as never);
vi.mocked(db.user.findUnique).mockResolvedValue(user as never);
vi.mocked(getUserTotpStatus).mockResolvedValue(disabledStatus);
vi.mocked(checkMfaStepUpState).mockReturnValue({
verified: true,
state: { userId: user.id, method: "totp", verifiedAt: "2026-05-08T12:00:00.000Z", redirectTo: "/admin" },
ageMs: 10_000,
});
vi.mocked(commitSession).mockResolvedValue("RJ_session=updated-cookie; Path=/; HttpOnly" as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined);
});
it("loader exposes only redacted facts for the current cookie session", async () => {
const response = await callLoader();
expect(requireAuth).toHaveBeenCalled();
expect(getUserSession).toHaveBeenCalledWith(expect.any(Request));
expect(checkMfaStepUpState).toHaveBeenCalledWith(expect.anything(), user.id);
expect(response).toMatchObject({
mfaStatus: disabledStatus,
currentSession: {
locale: "en",
lightOrDarkMode: "dark",
theme: "zinc",
cookieConsentCount: 2,
impersonationActive: true,
mfaStepUp: { present: true, verified: true, stale: false, method: "totp" },
},
});
expectNoSessionLeak(response);
});
it("marks malformed or stale step-up state as unverified without exposing raw state", async () => {
vi.mocked(checkMfaStepUpState).mockReturnValueOnce({ verified: false, reason: "stale" });
const response = await callLoader();
expect(response).toMatchObject({
currentSession: {
mfaStepUp: { present: true, verified: false, stale: true, reason: "stale" },
},
});
expectNoSessionLeak(response);
});
it("reports absent step-up state without showing a verified session", async () => {
vi.mocked(checkMfaStepUpState).mockReturnValueOnce({ verified: false, reason: "missing" });
const response = await callLoader();
expect(response).toMatchObject({
currentSession: {
mfaStepUp: { present: false, verified: false, stale: false, reason: "missing" },
},
});
});
it("clears only the current session MFA step-up state and commits an updated cookie", async () => {
const session = sessionMock();
vi.mocked(getUserSession).mockResolvedValue(session as never);
vi.mocked(checkMfaStepUpState).mockReturnValueOnce({ verified: true, state: { userId: user.id, method: "totp", verifiedAt: "2026-05-08T12:00:00.000Z" }, ageMs: 1_000 });
const response = await callAction("clearMfaStepUp");
const body = await response.json();
expect(response.status).toBe(200);
expect(validateCSRFToken).toHaveBeenCalledWith(expect.any(Request));
expect(clearMfaStepUpState).toHaveBeenCalledWith(session);
expect(commitSession).toHaveBeenCalledWith(session);
expect(response.headers.get("Set-Cookie")).toBe("RJ_session=updated-cookie; Path=/; HttpOnly");
expect(body).toMatchObject({ success: "Session MFA verification cleared", currentSession: { mfaStepUp: { present: true, verified: true } } });
expectNoSessionLeak(body);
});
it("propagates unauthenticated rejection before reading or mutating session state", async () => {
const rejection = new Response(null, { status: 302, headers: { Location: "/login" } });
vi.mocked(requireAuth).mockRejectedValueOnce(rejection as never);
await expect(callAction("clearMfaStepUp")).rejects.toBe(rejection);
expect(getUserInfo).not.toHaveBeenCalled();
expect(clearMfaStepUpState).not.toHaveBeenCalled();
expect(commitSession).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,433 @@
import { useEffect } from "react";
import { useAppData } from "~/utils/data/useAppData";
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useLoaderData } from "react-router";
import { useActionData } from "react-router";
import {
activateUserTotpPendingSecret,
disableUserTotp,
getUserTotpPendingEnrollment,
getUserTotpStatus,
setUserMfaRecoveryCodes,
setUserTotpPendingSecret,
updateUserPassword,
updateUserProfile,
type UserTotpStatus,
} from "~/utils/db/users.db.server";
import { commitSession, getUserInfo, getUserSession, storage, validateCSRFToken } from "~/utils/session.server";
import { db } from "~/utils/db.server";
import { hashPassword, verifyPassword } from "~/utils/auth/passwordHasher.server";
import { validatePassword as validatePolicyPassword } from "~/services/auth/password-policy.server";
import { getTranslations } from "~/locale/i18next.server";
import { deleteUserWithItsTenants } from "~/utils/services/userService";
import { storeFile } from "~/utils/integrations/storageService";
import { auditRejectedUpload } from "~/utils/integrations/storageAudit.server";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import EventsService from "~/modules/events/services/.server/EventsService";
import { UserProfileUpdatedDto } from "~/modules/events/dtos/UserProfileUpdatedDto";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getTenant } from "~/utils/db/tenants.db.server";
import { UserPasswordUpdatedDto } from "~/modules/events/dtos/UserPasswordUpdatedDto";
import { AccountDeletedDto } from "~/modules/events/dtos/AccountDeletedDto";
import { UserProfileDeletedDto } from "~/modules/events/dtos/UserProfileDeletedDto";
import MyProfileScreen from "~/modules/users/components/MyProfileScreen";
import toast from "react-hot-toast";
import { requireAuth } from "~/utils/loaders.middleware";
import { generateRecoveryCodes } from "~/utils/auth/mfa/recovery-codes.server";
import { startTotpEnrollment, verifyTotpCode } from "~/services/auth/totp.server";
import { checkMfaStepUpState, clearMfaStepUpState } from "~/utils/auth/mfa/step-up.server";
type CurrentSessionMfaStepUp =
| { present: false; verified: false; stale: false; reason: "missing" }
| { present: true; verified: true; stale: false; method: string }
| { present: true; verified: false; stale: boolean; reason: "malformed" | "wrong-user" | "stale" };
export type CurrentSessionSettings = {
locale: string;
lightOrDarkMode: string;
theme: string | null;
cookieConsentCount: number;
impersonationActive: boolean;
mfaStepUp: CurrentSessionMfaStepUp;
};
type LoaderData = {
title: string;
mfaStatus: UserTotpStatus | null;
currentSession: CurrentSessionSettings;
};
function getCurrentSessionMfaStepUp(stepUp: ReturnType<typeof checkMfaStepUpState>): CurrentSessionMfaStepUp {
if (stepUp.verified) {
return { present: true, verified: true, stale: false, method: stepUp.state.method };
}
if (stepUp.reason === "missing") {
return { present: false, verified: false, stale: false, reason: "missing" };
}
return { present: true, verified: false, stale: stepUp.reason === "stale", reason: stepUp.reason };
}
function getCurrentSessionSettings(
userInfo: Awaited<ReturnType<typeof getUserInfo>>,
session: Awaited<ReturnType<typeof getUserSession>>
): CurrentSessionSettings {
const stepUp = checkMfaStepUpState(session, userInfo.userId);
const cookies = Array.isArray(userInfo.cookies) ? userInfo.cookies : [];
return {
locale: userInfo.lng,
lightOrDarkMode: userInfo.lightOrDarkMode || "system",
theme: typeof userInfo.theme === "string" && userInfo.theme.length > 0 ? userInfo.theme : null,
cookieConsentCount: cookies.filter((cookie) => cookie?.allowed).length,
impersonationActive: Boolean(userInfo.impersonatingFromUserId),
mfaStepUp: getCurrentSessionMfaStepUp(stepUp),
};
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
const session = await getUserSession(request);
const data: LoaderData = {
title: `${t("settings.profile.profileTitle")} | ${process.env.APP_NAME}`,
mfaStatus: await getUserTotpStatus(userInfo?.userId),
currentSession: getCurrentSessionSettings(userInfo, session),
};
return data;
};
type ActionData = {
success?: string;
passwordSuccess?: string;
error?: string;
mfaError?: string;
mfaStatus?: UserTotpStatus | null;
otpauthUri?: string;
recoveryCodes?: string[];
currentSession?: CurrentSessionSettings;
};
function mfaJson(
body: { mfaStatus: UserTotpStatus | null; mfaError?: string; otpauthUri?: string; recoveryCodes?: string[]; success?: string },
init?: ResponseInit
) {
return Response.json(body, init);
}
function isSixDigitTotpCode(code: FormDataEntryValue | null): code is string {
return typeof code === "string" && /^\d{6}$/.test(code);
}
export const action: ActionFunction = async ({ request, params }) => {
await requireAuth({ request, params });
await validateCSRFToken(request);
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
const userInfo = await getUserInfo(request);
const form = await request.formData();
const action = form.get("action");
const firstName = form.get("firstName")?.toString();
const lastName = form.get("lastName")?.toString() ?? "";
const avatar = form.get("avatar")?.toString() ?? "";
const passwordCurrent = form.get("passwordCurrent")?.toString();
const passwordNew = form.get("passwordNew")?.toString();
const passwordNewConfirm = form.get("passwordNewConfirm")?.toString();
if (typeof action !== "string") {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
const user = await db.user.findUnique({
where: { id: userInfo?.userId },
include: {
admin: true,
},
});
const tenant = await getTenant(tenantId);
if (!user) {
return Response.json({ error: t("settings.profile.errors.userNotFound") }, { status: 400 });
}
if (!tenant) {
return Response.json({ error: t("settings.profile.errors.accountNotFound") }, { status: 400 });
}
switch (action) {
case "startTotpEnrollment": {
const mfaStatus = await getUserTotpStatus(user.id);
if (typeof passwordCurrent !== "string") {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.currentPasswordRequired") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
const enrollment = startTotpEnrollment(user.email);
await setUserTotpPendingSecret(user.id, enrollment.encryptedSecret);
const updatedMfaStatus = await getUserTotpStatus(user.id);
await EventsService.create({
request,
event: "user.mfa.totp.enrollment.started",
tenantId: null,
userId: user.id,
data: {
user: { id: user.id, email: user.email },
mfaStatus: updatedMfaStatus,
},
});
return mfaJson({ success: t("settings.profile.mfa.enrollmentStarted"), mfaStatus: updatedMfaStatus, otpauthUri: enrollment.otpauthUri });
}
case "confirmTotpEnrollment": {
const mfaStatus = await getUserTotpStatus(user.id);
const code = form.get("code");
if (!isSixDigitTotpCode(code)) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.mfa.enterCode") }, { status: 400 });
}
const pending = await getUserTotpPendingEnrollment(user.id);
if (!pending?.totpPendingSecretEncrypted || !pending.totpPendingCreatedAt) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.mfa.noPendingEnrollment") }, { status: 400 });
}
if (!verifyTotpCode(pending.totpPendingSecretEncrypted, code)) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.mfa.invalidCode") }, { status: 400 });
}
await activateUserTotpPendingSecret(user.id, pending.totpPendingSecretEncrypted);
const recoveryCodeGeneration = generateRecoveryCodes();
await setUserMfaRecoveryCodes(user.id, recoveryCodeGeneration.entries, recoveryCodeGeneration.generatedAt);
const updatedMfaStatus = await getUserTotpStatus(user.id);
await EventsService.create({
request,
event: "user.mfa.totp.enabled",
tenantId: null,
userId: user.id,
data: {
user: { id: user.id, email: user.email },
mfaStatus: updatedMfaStatus,
recoveryCodes: {
generatedCount: recoveryCodeGeneration.codes.length,
remainingCount: recoveryCodeGeneration.entries.filter((entry) => !entry.usedAt).length,
generatedAt: recoveryCodeGeneration.generatedAt,
},
},
});
return mfaJson({ success: t("settings.profile.mfa.enabled"), mfaStatus: updatedMfaStatus, recoveryCodes: recoveryCodeGeneration.codes });
}
case "disableTotpEnrollment": {
const mfaStatus = await getUserTotpStatus(user.id);
if (typeof passwordCurrent !== "string") {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.currentPasswordRequired") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return mfaJson({ mfaStatus, mfaError: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
await disableUserTotp(user.id);
const updatedMfaStatus = await getUserTotpStatus(user.id);
await EventsService.create({
request,
event: "user.mfa.totp.disabled",
tenantId: null,
userId: user.id,
data: {
user: { id: user.id, email: user.email },
mfaStatus: updatedMfaStatus,
},
});
return mfaJson({ success: t("settings.profile.mfa.disabled"), mfaStatus: updatedMfaStatus });
}
case "clearMfaStepUp": {
const session = await getUserSession(request);
clearMfaStepUpState(session);
return Response.json(
{ success: t("settings.profile.mfa.sessionCleared"), currentSession: getCurrentSessionSettings(userInfo, session) },
{ headers: { "Set-Cookie": await commitSession(session) } }
);
}
case "profile": {
const fields = { action, firstName, lastName, avatar, passwordCurrent, passwordNew, passwordNewConfirm };
const fieldErrors = {
firstName: action === "profile" && (fields.firstName ?? "").length < 2 ? t("settings.profile.errors.firstNameRequired") : "",
};
if (Object.values(fieldErrors).some(Boolean)) {
return Response.json({ error: t("shared.invalidForm"), fields: fieldErrors }, { status: 400 });
}
if (typeof firstName !== "string" || typeof lastName !== "string") {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
let avatarStored = avatar
? await storeFile({
bucket: "users-icons",
content: avatar,
id: userInfo?.userId,
scan: {
context: "avatar",
enqueuePostScan: true,
onReject: auditRejectedUpload(request, "tenant.profile.avatar"),
filename: `${userInfo?.userId}.avatar`,
},
})
: avatar;
const profile = await updateUserProfile({ firstName, lastName, avatar: avatarStored }, userInfo?.userId);
if (!profile) {
return Response.json({ error: t("settings.profile.errors.profileUpdateFailed") }, { status: 400 });
}
await EventsService.create({
request,
event: "user.profile.updated",
tenantId: null,
userId: user.id,
data: {
email: user.email,
new: { firstName, lastName },
old: { firstName: user.firstName, lastName: user.lastName },
userId: userInfo?.userId,
} satisfies UserProfileUpdatedDto,
});
return Response.json({
success: t("shared.updated"),
});
}
case "password": {
if (typeof passwordCurrent !== "string" || typeof passwordNew !== "string" || typeof passwordNewConfirm !== "string") {
return Response.json({ error: t("shared.invalidForm") }, { status: 400 });
}
if (passwordNew !== passwordNewConfirm) {
return Response.json({ error: t("account.shared.passwordMismatch") }, { status: 400 });
}
if (!user) return null;
const policyResult = await validatePolicyPassword(passwordNew, { email: user.email });
if (!policyResult.valid) {
const first = policyResult.errors[0];
return Response.json(
{
error: first ? t(first.code, first.args ?? {}) : t("settings.profile.errors.passwordMinLength"),
},
{ status: 400 }
);
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return Response.json({ error: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
const passwordHash = await hashPassword(passwordNew);
await updateUserPassword({ passwordHash }, userInfo?.userId);
await EventsService.create({
request,
event: "user.password.updated",
tenantId: null,
userId: user.id,
data: {
user: { id: user.id, email: user.email },
} satisfies UserPasswordUpdatedDto,
});
return Response.json({
passwordSuccess: t("settings.profile.passwordUpdated"),
});
}
case "deleteAccount": {
if (!user) {
return null;
}
if (user.admin !== null) {
return Response.json(
{
error: t("settings.profile.errors.cannotDeleteAdmin"),
},
{ status: 400 }
);
}
if (typeof passwordCurrent !== "string" || passwordCurrent.length === 0) {
return Response.json({ error: t("settings.profile.errors.currentPasswordRequired") }, { status: 400 });
}
const isCorrectPassword = (await verifyPassword(passwordCurrent, user.passwordHash)).valid;
if (!isCorrectPassword) {
return Response.json({ error: t("settings.profile.errors.invalidPassword") }, { status: 400 });
}
try {
const { deletedTenants } = await deleteUserWithItsTenants(user.id);
const deletedAccounts = await Promise.all(
deletedTenants.map(async (tenant) => {
const data = {
tenant: { id: tenant.id, name: tenant.name },
user: { id: user.id, email: user.email },
} satisfies AccountDeletedDto;
await EventsService.create({
request,
event: "account.deleted",
tenantId: null,
userId: null,
data,
});
return data;
})
);
await EventsService.create({
request,
event: "user.profile.deleted",
tenantId: null,
userId: null,
data: {
id: user.id,
email: user.email,
firstName: user.firstName,
lastName: user.lastName,
deletedAccounts,
} satisfies UserProfileDeletedDto,
});
} catch (error) {
// eslint-disable-next-line no-console
console.error(error);
return Response.json(
{
error: t("shared.unexpectedError"),
},
{ status: 400 }
);
}
const session = await getUserSession(request);
return redirect("/login", {
headers: {
"Set-Cookie": await storage.destroySession(session),
},
});
}
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function ProfileRoute() {
const appData = useAppData();
const loaderData = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
useEffect(() => {
const successMessage = actionData?.success ?? actionData?.passwordSuccess;
if (successMessage) {
toast.success(successMessage);
} else if (actionData?.error) {
toast.error(actionData.error);
}
}, [actionData]);
return (
<EditPageLayout className="pb-20">
<MyProfileScreen
user={appData.user}
mfaStatus={actionData?.mfaStatus ?? loaderData.mfaStatus}
otpauthUri={actionData?.otpauthUri}
recoveryCodes={actionData?.recoveryCodes}
mfaError={actionData?.mfaError}
/>
</EditPageLayout>
);
}
@@ -0,0 +1,74 @@
import { LoaderFunctionArgs, MetaFunction, redirect } from "react-router";
import { Outlet, useLocation, useNavigate, useParams } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { useEffect } from "react";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import TabsVertical from "~/components/ui/tabs/TabsVertical";
import { useTranslation } from "react-i18next";
import UrlUtils from "~/utils/app/UrlUtils";
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
type LoaderData = {
title: string;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.roles.view", tenantId);
if (UrlUtils.stripTrailingSlash(new URL(request.url).pathname) === UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions")) {
throw redirect(UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/users"));
}
const data: LoaderData = {
title: `${t("models.role.plural")} | ${process.env.APP_NAME}`,
};
return data;
};
export default function AdminAccountUsersFromTenant() {
const { t } = useTranslation();
const params = useParams();
const location = useLocation();
const navigate = useNavigate();
useEffect(() => {
if (UrlUtils.stripTrailingSlash(location.pathname) === UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions")) {
navigate(UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/users"));
}
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [location.pathname]);
return (
<div data-ui-id="ui.settings.rolesAndPermissions.page" className="mx-auto max-w-5xl space-y-2 px-4 py-4 sm:px-6 lg:px-8 xl:max-w-7xl">
<div className="grid grid-cols-1 gap-4 lg:grid-cols-12">
<div data-ui-id="ui.settings.rolesAndPermissions.tabs" className="lg:col-span-2">
<TabsVertical
tabs={[
{
name: t("models.user.plural"),
routePath: UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/users"),
},
{
name: t("models.role.plural"),
routePath: UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/roles"),
},
{
name: t("models.permission.plural"),
routePath: UrlUtils.currentTenantUrl(params, "settings/roles-and-permissions/permissions"),
},
]}
/>
</div>
<div className="lg:col-span-10">
<div className="w-full">
<Outlet />
</div>
</div>
</div>
</div>
);
}
@@ -0,0 +1,41 @@
import { LoaderFunctionArgs, MetaFunction, useLoaderData } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getAllPermissions, PermissionWithRoles } from "~/utils/db/permissions/permissions.db.server";
import PermissionsTable from "~/components/core/roles/PermissionsTable";
import { useAppData } from "~/utils/data/useAppData";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
type LoaderData = {
title: string;
items: PermissionWithRoles[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.roles.view", tenantId);
const items = await getAllPermissions("app");
const data: LoaderData = {
title: `${t("models.permission.plural")} | ${process.env.APP_NAME}`,
items,
};
return data;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function PermissionsRoute() {
const data = useLoaderData<LoaderData>();
const appData = useAppData();
return (
<div data-ui-id="ui.settings.rolesAndPermissions.permissions">
<PermissionsTable items={data.items} canCreate={false} canUpdate={false} tenantId={appData.currentTenant.id} />
</div>
);
}
@@ -0,0 +1,325 @@
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,
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("uses global default and tenant-owned app roles for the list loader after requiring builder access", async () => {
const defaultRole = { ...role, id: "role_default", isDefault: true };
vi.mocked(getAllRolesWithUsers).mockResolvedValueOnce([role, defaultRole] as Awaited<ReturnType<typeof getAllRolesWithUsers>>);
const data = await callListLoader();
expect(requireWorkspaceRolesBuilderAccess).toHaveBeenCalledWith({ request, params, tenantId: "tenant_1" });
expect(getAllRolesWithUsers).toHaveBeenCalledWith("app", undefined, "tenant_1");
expect(data).toMatchObject({ items: [role, defaultRole] });
});
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,60 @@
import { LoaderFunctionArgs, MetaFunction, useLoaderData, useNavigate, useOutlet, useParams } from "react-router";
import { t } from "i18next";
import { getTranslations } from "~/locale/i18next.server";
import RolesListView from "~/modules/users/components/RolesListView";
import { getAllRolesWithUsers, RoleWithPermissionsAndUsers } from "~/utils/db/permissions/roles.db.server";
import { useAppData } from "~/utils/data/useAppData";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { requireWorkspaceRolesBuilderAccess } from "~/utils/services/workspaceRoles.server";
import SlideOverWideEmpty from "~/components/ui/slideOvers/SlideOverWideEmpty";
type LoaderData = {
title: string;
items: RoleWithPermissionsAndUsers[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await requireWorkspaceRolesBuilderAccess({ request, params, tenantId });
const { t } = await getTranslations(request);
const items = await getAllRolesWithUsers("app", undefined, tenantId);
const data: LoaderData = {
title: `${t("models.role.plural")} | ${process.env.APP_NAME}`,
items,
};
return data;
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function RolesRoute() {
const data = useLoaderData<LoaderData>();
const appData = useAppData();
const navigate = useNavigate();
const outlet = useOutlet();
const params = useParams();
const canUpdate = getUserHasPermission(appData, "app.settings.roles.set");
return (
<div data-ui-id="ui.settings.rolesAndPermissions.roles" className="space-y-2">
<RolesListView items={data.items} canUpdate={canUpdate} tenantId={appData.currentTenant.id} />
<SlideOverWideEmpty
title={params.id ? t("shared.edit") : t("shared.new")}
open={!!outlet}
onClose={() => {
navigate(".", { replace: true });
}}
className="sm:max-w-lg"
overflowYScroll={true}
>
<div className="-mx-1 -mt-3">
<div className="space-y-4">{outlet}</div>
</div>
</SlideOverWideEmpty>
</div>
);
}
@@ -0,0 +1,118 @@
import { ActionFunction, LoaderFunctionArgs, MetaFunction, redirect, useActionData, useLoaderData, useNavigate, useParams } from "react-router";
import { useEffect } from "react";
import toast from "react-hot-toast";
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/roles-and-permissions/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));
}
} 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/roles-and-permissions/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));
};
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 />;
}
@@ -0,0 +1,180 @@
import { ActionFunction, LoaderFunctionArgs, MetaFunction, useLoaderData } from "react-router";
import { useSubmit } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getAllRoles, getTenantAssignableAppRole, RoleWithPermissions } from "~/utils/db/permissions/roles.db.server";
import { getTenantScopedUsersWithDetails, getUser, UserWithDetails, UserWithRoles } from "~/utils/db/users.db.server";
import UserRolesTable from "~/components/core/roles/UserRolesTable";
import { useEffect, useState } from "react";
import InputSearch from "~/components/ui/input/InputSearch";
import { createUserRole, deleteUserRole } from "~/utils/db/permissions/userRoles.db.server";
import { getTenant, getTenantMember } from "~/utils/db/tenants.db.server";
import { createAdminLog } from "~/utils/db/logs.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { useAppData } from "~/utils/data/useAppData";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import EventsService from "~/modules/events/services/.server/EventsService";
import { RoleAssignedDto } from "~/modules/events/dtos/RoleAssignedDto";
import { RoleUnassignedDto } from "~/modules/events/dtos/RoleUnassignedDto";
import { requireAuth } from "~/utils/loaders.middleware";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { useRootData } from "~/utils/data/useRootData";
type LoaderData = {
title: string;
items: UserWithRoles[];
roles: RoleWithPermissions[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.roles.view", tenantId);
const tenantUsers = await getTenantScopedUsersWithDetails(tenantId);
const roles = await getAllRoles("app");
const items: UserWithDetails[] = [];
tenantUsers.forEach((user) => {
if (!items.find((f) => f.id === user.id)) {
items.push(user);
}
});
const data: LoaderData = {
title: `${t("models.permission.userRoles")} | ${process.env.APP_NAME}`,
items,
roles,
};
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.roles.set", tenantId);
const userInfo = await getUserInfo(request);
const fromUser = await getUser(userInfo.userId);
if (!fromUser) {
return badRequest({ error: t("shared.invalidUser") });
}
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "edit") {
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 (!tenant || !tenantMember || !user || !role || role.type !== "app") {
return badRequest({ error: t("shared.invalidForm") });
}
if (add) {
await createUserRole(userId, roleId, tenantId);
if (fromUser && user && role) {
await EventsService.create({
request,
event: "role.assigned",
tenantId: tenant?.id ?? null,
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.rolesAndPermissions.userRoles.created", `[${tenant?.name}] ${user?.email} - ${role?.name}`);
} else {
if (fromUser && user && role) {
await EventsService.create({
request,
event: "role.unassigned",
tenantId: tenant?.id ?? null,
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.rolesAndPermissions.userRoles.deleted", `[${tenant?.name}] ${user?.email} - ${role?.name}`);
}
return Response.json({});
} else {
return badRequest({ error: t("shared.invalidForm") });
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function AdminAccountUsersFromTenant() {
const data = useLoaderData<LoaderData>();
const appData = useAppData();
const rootData = useRootData();
const [items, setItems] = useState(data.items);
const submit = useSubmit();
const [searchInput, setSearchInput] = useState("");
useEffect(() => {
setItems(data.items);
}, [data]);
const filteredItems = () => {
if (!items) {
return [];
}
return items.filter(
(f) =>
f.email?.toString().toUpperCase().includes(searchInput.toUpperCase()) ||
f.firstName?.toString().toUpperCase().includes(searchInput.toUpperCase()) ||
f.lastName?.toString().toUpperCase().includes(searchInput.toUpperCase()) ||
f.roles.find(
(f) => f.role.name.toUpperCase().includes(searchInput.toUpperCase()) || f.role.description.toUpperCase().includes(searchInput.toUpperCase())
)
);
};
function onChange(item: UserWithRoles, role: RoleWithPermissions, add: any) {
const form = new FormData();
form.set("action", "edit");
form.set("user-id", item.id);
form.set("role-id", role.id);
form.set("add", add ? "true" : "false");
form.set("csrf", rootData.csrf ?? "");
submit(form, {
method: "post",
});
}
return (
<div data-ui-id="ui.settings.rolesAndPermissions.users" className="space-y-2">
<InputSearch value={searchInput} setValue={setSearchInput} />
<UserRolesTable
items={filteredItems()}
roles={data.roles}
onChange={onChange}
tenantId={appData.currentTenant.id}
disabled={!getUserHasPermission(appData, "app.settings.roles.set")}
/>
</div>
);
}
@@ -0,0 +1,99 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
requireAuth: vi.fn(),
getUserInfo: vi.fn(),
validateCSRFToken: vi.fn(),
getActiveSessionByToken: vi.fn(),
listActiveUserSessions: vi.fn(),
revokeUserSession: vi.fn(),
revokeAllUserSessionsExcept: vi.fn(),
markSessionTrusted: vi.fn(),
listTrustedDevices: vi.fn(),
revokeTrustedDevice: vi.fn(),
revokeAllTrustedDevices: vi.fn(),
}));
vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: (...a: unknown[]) => mocks.requireAuth(...a) }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ t: (key: string) => key })) }));
vi.mock("~/utils/session.server", () => ({
getUserInfo: (...a: unknown[]) => mocks.getUserInfo(...a),
validateCSRFToken: (...a: unknown[]) => mocks.validateCSRFToken(...a),
}));
vi.mock("~/services/auth/sessionStore.server", () => ({
getActiveSessionByToken: (...a: unknown[]) => mocks.getActiveSessionByToken(...a),
listActiveUserSessions: (...a: unknown[]) => mocks.listActiveUserSessions(...a),
revokeUserSession: (...a: unknown[]) => mocks.revokeUserSession(...a),
revokeAllUserSessionsExcept: (...a: unknown[]) => mocks.revokeAllUserSessionsExcept(...a),
markSessionTrusted: (...a: unknown[]) => mocks.markSessionTrusted(...a),
}));
vi.mock("~/utils/auth/mfa/trusted-device.server", () => ({
listTrustedDevices: (...a: unknown[]) => mocks.listTrustedDevices(...a),
revokeTrustedDevice: (...a: unknown[]) => mocks.revokeTrustedDevice(...a),
revokeAllTrustedDevices: (...a: unknown[]) => mocks.revokeAllTrustedDevices(...a),
}));
import { action, loader } from "./security";
const params = { tenant: "acme" };
beforeEach(() => {
vi.clearAllMocks();
mocks.getUserInfo.mockResolvedValue({ userId: "u1", sessionToken: "tok-current", csrf: "csrf-1" });
mocks.getActiveSessionByToken.mockResolvedValue({ id: "s1" });
mocks.listActiveUserSessions.mockResolvedValue([
{ id: "s1", lastSeenAt: new Date(), ipAddress: "1.1.1.1", userAgent: "Firefox", deviceLabel: null, approxLocation: null, trustedAt: null },
{ id: "s2", lastSeenAt: new Date(), ipAddress: "2.2.2.2", userAgent: "Safari", deviceLabel: null, approxLocation: null, trustedAt: null },
]);
mocks.listTrustedDevices.mockResolvedValue([{ id: "td1", deviceLabel: null, userAgent: "Firefox", approxLocation: "DE" }]);
});
function postRequest(fields: Record<string, string>) {
const body = new URLSearchParams(fields);
return new Request("https://example.test/acme/settings/security", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body,
});
}
describe("security route loader", () => {
it("builds a ready device-list VM and flags the current session", async () => {
const data = await loader({ request: new Request("https://example.test/acme/settings/security"), params, context: {} } as never);
expect(mocks.requireAuth).toHaveBeenCalled();
expect(data.vm.status).toBe("ready");
if (data.vm.status !== "ready") return;
expect(data.vm.data.devices.find((d) => d.id === "s1")?.isCurrent).toBe(true);
expect(data.vm.data.otherActiveCount).toBe(1);
expect(data.csrf).toBe("csrf-1");
});
});
describe("security route action", () => {
it("revokes a single session by id", async () => {
const res = await action({ request: postRequest({ csrf: "csrf-1", intent: "revoke", sessionId: "s2" }), params, context: {} } as never);
expect(mocks.validateCSRFToken).toHaveBeenCalled();
expect(mocks.revokeUserSession).toHaveBeenCalledWith({ userId: "u1", sessionId: "s2" });
expect((res as Response).status).toBe(302);
});
it("revokes all other sessions except the current one", async () => {
await action({ request: postRequest({ csrf: "csrf-1", intent: "revoke-all" }), params, context: {} } as never);
expect(mocks.revokeAllUserSessionsExcept).toHaveBeenCalledWith({ userId: "u1", sessionId: "s1" });
});
it("marks a session trusted", async () => {
await action({ request: postRequest({ csrf: "csrf-1", intent: "trust", sessionId: "s2" }), params, context: {} } as never);
expect(mocks.markSessionTrusted).toHaveBeenCalledWith({ userId: "u1", sessionId: "s2" });
});
it("forgets a single trusted device by id", async () => {
await action({ request: postRequest({ csrf: "csrf-1", intent: "forget-device", deviceId: "td1" }), params, context: {} } as never);
expect(mocks.revokeTrustedDevice).toHaveBeenCalledWith({ userId: "u1", deviceId: "td1" });
});
it("forgets all trusted devices", async () => {
await action({ request: postRequest({ csrf: "csrf-1", intent: "forget-all-devices" }), params, context: {} } as never);
expect(mocks.revokeAllTrustedDevices).toHaveBeenCalledWith("u1");
});
});
@@ -0,0 +1,84 @@
import { redirect, useLoaderData, type ActionFunctionArgs, type LoaderFunctionArgs, type MetaFunction } from "react-router";
import { buildSessionListVM, type SessionListVM } from "@toolctrl/view-models";
import SecuritySessionsScreen from "~/modules/users/components/SecuritySessionsScreen";
import { getTranslations } from "~/locale/i18next.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import {
getActiveSessionByToken,
listActiveUserSessions,
markSessionTrusted,
revokeAllUserSessionsExcept,
revokeUserSession,
} from "~/services/auth/sessionStore.server";
import { listTrustedDevices, revokeAllTrustedDevices, revokeTrustedDevice } from "~/utils/auth/mfa/trusted-device.server";
// R-P2a S4b + D1 — Settings > Sicherheit: Geräteliste + Revoke + "überall abmelden" + Trust-Device.
// Der Loader baut das VM serverseitig (M013), die Inline-UI unten ist das minimale Swap-Ziel für
// Davids D-P2-Subframe-Screen (über den ui-app-Adapter, M015) — VM und Action-Callbacks bleiben.
// D1: zusätzlich die per Login-2FA als vertrauenswürdig markierten Geräte (TrustedDevice) — widerrufbar
// einzeln / "alle vergessen" (DoD-Screen "Trust-Device-Revoke").
type TrustedDeviceVM = { id: string; label: string | null; approxLocation: string | null };
type LoaderData = { title: string; csrf: string; vm: SessionListVM; trustedDevices: TrustedDeviceVM[] };
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export const loader = async ({ request, params }: LoaderFunctionArgs): Promise<LoaderData> => {
await requireAuth({ request, params });
const { t } = await getTranslations(request);
const userInfo = await getUserInfo(request);
const sessions = await listActiveUserSessions(userInfo.userId);
const current = userInfo.sessionToken ? await getActiveSessionByToken(userInfo.sessionToken) : null;
const vm = buildSessionListVM({
sessions: sessions.map((session) => ({
id: session.id,
lastSeenAt: session.lastSeenAt,
userAgent: session.userAgent,
deviceLabel: session.deviceLabel,
approxLocation: session.approxLocation,
trustedAt: session.trustedAt,
})),
currentSessionId: current?.id ?? null,
nowMs: Date.now(),
});
const trustedDevices: TrustedDeviceVM[] = (await listTrustedDevices(userInfo.userId)).map((device) => ({
id: device.id,
label: device.deviceLabel ?? device.userAgent ?? null,
approxLocation: device.approxLocation,
}));
return { title: `${t("settings.security.title")} | ${process.env.APP_NAME ?? "HiveGrid"}`, csrf: userInfo.csrf ?? "", vm, trustedDevices };
};
export const action = async ({ request, params }: ActionFunctionArgs) => {
await requireAuth({ request, params });
const form = await request.formData();
await validateCSRFToken(request, { formData: form });
const userInfo = await getUserInfo(request);
const userId = userInfo.userId;
if (!userId) {
throw redirect("/login");
}
const current = userInfo.sessionToken ? await getActiveSessionByToken(userInfo.sessionToken) : null;
const intent = form.get("intent");
const sessionId = String(form.get("sessionId") ?? "");
const deviceId = String(form.get("deviceId") ?? "");
if (intent === "revoke" && sessionId) {
await revokeUserSession({ userId, sessionId });
} else if (intent === "revoke-all") {
await revokeAllUserSessionsExcept({ userId, sessionId: current?.id ?? "" });
} else if (intent === "trust" && sessionId) {
await markSessionTrusted({ userId, sessionId });
} else if (intent === "forget-device" && deviceId) {
await revokeTrustedDevice({ userId, deviceId });
} else if (intent === "forget-all-devices") {
await revokeAllTrustedDevices(userId);
}
return redirect(new URL(request.url).pathname);
};
export default function SecurityRoute() {
const { csrf, vm, trustedDevices } = useLoaderData<typeof loader>();
return <SecuritySessionsScreen vm={vm} trustedDevices={trustedDevices} csrf={csrf} />;
}
@@ -0,0 +1,181 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
const mocks = vi.hoisted(() => ({
getTranslations: vi.fn(),
getTenantIdFromUrl: vi.fn(),
verifyUserHasPermission: vi.fn(),
getUserInfo: vi.fn(),
getUser: vi.fn(),
getTenant: vi.fn(),
getOrPersistTenantSubscription: vi.fn(),
getTenantSubscription: vi.fn(),
getStripeCustomer: vi.fn(),
getStripeInvoices: vi.fn(),
getStripePaymentIntents: vi.fn(),
getStripeUpcomingInvoices: vi.fn(),
getStripePaymentMethods: vi.fn(),
createCustomerPortalSession: vi.fn(),
cancelTenantSubscription: vi.fn(),
getPlanFeaturesUsage: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
vi.mock("react-hot-toast", () => ({ default: { error: vi.fn(), success: vi.fn() } }));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/modules/users/components/SubscriptionSettings", () => ({ default: () => null }));
vi.mock("~/utils/helpers/PermissionsHelper", () => ({ getUserHasPermission: vi.fn(() => true) }));
vi.mock("~/utils/data/useAppData", () => ({ useAppData: vi.fn(() => ({ mySubscription: null, currentTenant: { slug: "acme" } })) }));
vi.mock("~/modules/metrics/services/.server/MetricTracker", () => ({
createMetrics: vi.fn(async () => ({
time: async (value: unknown) => await value,
getServerTimingHeader: () => ({}),
})),
}));
vi.mock("~/modules/metrics/utils/defaultHeaders", () => ({ serverTimingHeaders: vi.fn() }));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: (...args: unknown[]) => mocks.getTranslations(...args) }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: (...args: unknown[]) => mocks.getTenantIdFromUrl(...args) }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: (...args: unknown[]) => mocks.verifyUserHasPermission(...args) }));
vi.mock("~/utils/session.server", () => ({
getUserInfo: (...args: unknown[]) => mocks.getUserInfo(...args),
validateCSRFToken: (...args: unknown[]) => mocks.validateCSRFToken(...args),
}));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: (...args: unknown[]) => mocks.getUser(...args) }));
vi.mock("~/utils/db/tenants.db.server", () => ({ getTenant: (...args: unknown[]) => mocks.getTenant(...args) }));
vi.mock("~/utils/db/tenantSubscriptions.db.server", () => ({
getOrPersistTenantSubscription: (...args: unknown[]) => mocks.getOrPersistTenantSubscription(...args),
getTenantSubscription: (...args: unknown[]) => mocks.getTenantSubscription(...args),
}));
vi.mock("~/utils/services/.server/subscriptionService", () => ({
cancelTenantSubscription: (...args: unknown[]) => mocks.cancelTenantSubscription(...args),
getPlanFeaturesUsage: (...args: unknown[]) => mocks.getPlanFeaturesUsage(...args),
}));
vi.mock("~/utils/stripe.server", () => ({
createCustomerPortalSession: (...args: unknown[]) => mocks.createCustomerPortalSession(...args),
createStripeSetupSession: vi.fn(),
deleteStripePaymentMethod: vi.fn(),
getStripeCustomer: (...args: unknown[]) => mocks.getStripeCustomer(...args),
getStripeInvoices: (...args: unknown[]) => mocks.getStripeInvoices(...args),
getStripePaymentIntents: (...args: unknown[]) => mocks.getStripePaymentIntents(...args),
getStripeUpcomingInvoices: (...args: unknown[]) => mocks.getStripeUpcomingInvoices(...args),
getStripePaymentMethods: (...args: unknown[]) => mocks.getStripePaymentMethods(...args),
}));
import { action, loader } from "./subscription";
const tenantId = "tenant-1";
const userId = "user-1";
const params = { tenant: "acme" };
const tenantSubscription = {
stripeCustomerId: "cus_123",
products: [{ stripeSubscriptionId: "sub_123" }],
};
function formRequest(form: FormData) {
return new Request("https://app.example.test/app/acme/settings/subscription", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(form as unknown as Record<string, string>),
});
}
function createForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", "open-customer-portal");
form.set("csrf", "csrf-token");
Object.entries(overrides).forEach(([key, value]) => form.set(key, value));
return form;
}
async function callAction(form: FormData) {
return action({
request: formRequest(form),
params,
context: {},
unstable_pattern: "app.$tenant/settings/subscription",
} as ActionFunctionArgs) as Promise<Response>;
}
describe("tenant subscription settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.getTranslations.mockResolvedValue({ t: (key: string) => key });
mocks.getTenantIdFromUrl.mockResolvedValue(tenantId);
mocks.verifyUserHasPermission.mockResolvedValue(undefined);
mocks.getUserInfo.mockResolvedValue({ userId });
mocks.getUser.mockResolvedValue({ id: userId, email: "user@example.test" });
mocks.getTenant.mockResolvedValue({ id: tenantId, name: "Acme", slug: "acme" });
mocks.getOrPersistTenantSubscription.mockResolvedValue(tenantSubscription);
mocks.getTenantSubscription.mockResolvedValue(tenantSubscription);
mocks.getStripeCustomer.mockResolvedValue({ id: "cus_123" });
mocks.getStripeInvoices.mockResolvedValue([{ id: "in_1" }]);
mocks.getStripePaymentIntents.mockResolvedValue([{ id: "pi_1" }]);
mocks.getStripeUpcomingInvoices.mockResolvedValue([{ id: "in_upcoming" }]);
mocks.getStripePaymentMethods.mockResolvedValue([{ id: "pm_1" }]);
mocks.getPlanFeaturesUsage.mockResolvedValue([{ name: "seats" }]);
mocks.validateCSRFToken.mockResolvedValue(undefined);
mocks.createCustomerPortalSession.mockResolvedValue({ url: "https://billing.stripe.test/session" });
mocks.cancelTenantSubscription.mockResolvedValue(undefined);
});
it("does not call Stripe invoice APIs when invoice permission is denied", async () => {
mocks.verifyUserHasPermission.mockImplementation(async (_request: Request, permission: string) => {
if (permission === "app.settings.subscription.invoices.view") throw new Response("Forbidden", { status: 403 });
});
const response = await loader({
request: new Request("https://app.example.test/app/acme/settings/subscription"),
params,
context: {},
unstable_pattern: "app.$tenant/settings/subscription",
} as LoaderFunctionArgs);
const data = await response.json();
expect(data.customer).toBeNull();
expect(data.myInvoices).toEqual([]);
expect(data.myPayments).toEqual([]);
expect(data.myUpcomingInvoices).toEqual([]);
expect(data.myPaymentMethods).toEqual([]);
expect(data.myFeatures).toEqual([{ name: "seats" }]);
expect(mocks.getStripeCustomer).not.toHaveBeenCalled();
expect(mocks.getStripeInvoices).not.toHaveBeenCalled();
expect(mocks.getStripePaymentIntents).not.toHaveBeenCalled();
expect(mocks.getStripeUpcomingInvoices).not.toHaveBeenCalled();
expect(mocks.getStripePaymentMethods).not.toHaveBeenCalled();
});
it("returns 400 instead of redirecting to an empty customer portal URL", async () => {
mocks.createCustomerPortalSession.mockResolvedValueOnce({ url: "" });
const response = await callAction(createForm());
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ error: "settings.subscription.errors.customerPortalUnavailable" });
});
it("checks delete permission before cancelling a subscription product", async () => {
const response = await callAction(createForm({ action: "cancel", "tenant-subscription-product-id": "tsp_1" }));
expect(response.status).toBe(200);
expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.subscription.update", tenantId);
expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.subscription.delete", tenantId);
expect(mocks.cancelTenantSubscription).toHaveBeenCalledWith("tsp_1", expect.objectContaining({ tenantId, userId }));
});
it("keeps cancel internals out of tenant-facing errors", async () => {
mocks.cancelTenantSubscription.mockRejectedValueOnce(new Error("Stripe raw failure"));
const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
const response = await callAction(createForm({ action: "cancel", "tenant-subscription-product-id": "tsp_1" }));
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ error: "shared.unexpectedError" });
expect(JSON.stringify(data)).not.toContain("Stripe raw failure");
expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
consoleError.mockRestore();
});
});
@@ -0,0 +1,170 @@
import { useEffect } from "react";
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useActionData } from "react-router";
import {
createCustomerPortalSession,
createStripeSetupSession,
deleteStripePaymentMethod,
getStripeCustomer,
getStripeInvoices,
getStripePaymentIntents,
getStripePaymentMethods,
getStripeUpcomingInvoices,
} from "~/utils/stripe.server";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getUser } from "~/utils/db/users.db.server";
import { getTranslations } from "~/locale/i18next.server";
import type Stripe from "stripe";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getOrPersistTenantSubscription, getTenantSubscription } from "~/utils/db/tenantSubscriptions.db.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { cancelTenantSubscription, getPlanFeaturesUsage } from "~/utils/services/.server/subscriptionService";
import { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { serverTimingHeaders } from "~/modules/metrics/utils/defaultHeaders";
import { promiseHash } from "~/utils/promises/promiseHash";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import SubscriptionSettings from "~/modules/users/components/SubscriptionSettings";
import toast from "react-hot-toast";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { useAppData } from "~/utils/data/useAppData";
import { v2MetaFunction } from "~/utils/compat/v2MetaFunction";
export { serverTimingHeaders as headers };
type LoaderData = {
title: string;
customer: Stripe.Customer | Stripe.DeletedCustomer | null;
myInvoices: Stripe.Invoice[];
myPayments: Stripe.PaymentIntent[];
myFeatures: PlanFeatureUsageDto[];
myUpcomingInvoices: Stripe.Invoice[];
myPaymentMethods: Stripe.PaymentMethod[];
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, "app.$tenant.settings.subscription");
let { t } = await getTranslations(request);
const tenantId = await time(getTenantIdFromUrl(params), "getTenantIdFromUrl");
await time(verifyUserHasPermission(request, "app.settings.subscription.view", tenantId), "verifyUserHasPermission");
const userInfoPromise = time(getUserInfo(request), "getUserInfo");
const userPromise = userInfoPromise.then((userInfo) => time(getUser(userInfo.userId), "getUser"));
const tenantPromise = time(getTenant(tenantId), "getTenant");
const canViewInvoicesPromise = time(
verifyUserHasPermission(request, "app.settings.subscription.invoices.view", tenantId).then(
() => true,
() => false
),
"verifyInvoicePermission"
);
const [user, tenant, canViewInvoices] = await Promise.all([userPromise, tenantPromise, canViewInvoicesPromise]);
if (!user) {
return badRequest({ error: t("shared.invalidUser") });
}
if (!tenant) {
return badRequest({ error: t("settings.subscription.errors.invalidTenant", { tenantId }) });
}
const tenantSubscription = await time(getOrPersistTenantSubscription(tenantId), "getOrPersistTenantSubscription");
const { customer, myInvoices, myPayments, myUpcomingInvoices, myPaymentMethods, myFeatures } = await time(
promiseHash({
customer: canViewInvoices ? getStripeCustomer(tenantSubscription.stripeCustomerId) : Promise.resolve(null),
myInvoices: canViewInvoices ? (getStripeInvoices(tenantSubscription.stripeCustomerId) ?? []) : Promise.resolve([] as Stripe.Invoice[]),
myPayments: canViewInvoices
? (getStripePaymentIntents(tenantSubscription.stripeCustomerId, "succeeded") ?? [])
: Promise.resolve([] as Stripe.PaymentIntent[]),
myUpcomingInvoices: canViewInvoices
? getStripeUpcomingInvoices(tenantSubscription.products.filter((f) => f.stripeSubscriptionId).flatMap((p) => p.stripeSubscriptionId!))
: Promise.resolve([] as Stripe.Invoice[]),
myPaymentMethods: canViewInvoices ? getStripePaymentMethods(tenantSubscription.stripeCustomerId) : Promise.resolve([] as Stripe.PaymentMethod[]),
myFeatures: getPlanFeaturesUsage(tenantId, tenantSubscription),
}),
"subscription[getStripeData]"
);
const data: LoaderData = {
title: `${t("app.navbar.subscription")} | ${process.env.APP_NAME}`,
customer,
myFeatures,
myInvoices,
myPayments,
myUpcomingInvoices,
myPaymentMethods,
};
return Response.json(data, { headers: getServerTimingHeader() });
};
type ActionData = {
error?: string;
success?: 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.subscription.update", tenantId);
const userInfo = await getUserInfo(request);
const tenantSubscription = await getTenantSubscription(tenantId);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString();
if (!tenantSubscription || !tenantSubscription?.stripeCustomerId) {
return badRequest({
error: t("settings.subscription.errors.invalidStripeCustomer"),
});
} else if (action === "cancel") {
await verifyUserHasPermission(request, "app.settings.subscription.delete", tenantId);
const tenantSubscriptionProductId = form.get("tenant-subscription-product-id")?.toString() ?? "";
try {
await cancelTenantSubscription(tenantSubscriptionProductId, { t, tenantId, userId: userInfo.userId });
return Response.json({ success: t("settings.subscription.success.cancelled") });
} catch (error) {
// eslint-disable-next-line no-console
console.error(error);
return Response.json({ error: t("shared.unexpectedError") }, { status: 400 });
}
} else if (action === "add-payment-method") {
const session = await createStripeSetupSession(request, tenantSubscription.stripeCustomerId);
return redirect(session?.url ?? "");
} else if (action === "delete-payment-method") {
await deleteStripePaymentMethod(form.get("id")?.toString() ?? "", tenantSubscription.stripeCustomerId);
return Response.json({});
} else if (action === "open-customer-portal") {
const session = await createCustomerPortalSession(request, tenantSubscription.stripeCustomerId);
if (!session?.url) {
return badRequest({ error: t("settings.subscription.errors.customerPortalUnavailable") });
}
return redirect(session.url);
}
};
export const meta: v2MetaFunction<typeof loader> = ({ data }) => (data && "title" in data ? [{ title: data.title }] : []);
export default function SubscriptionRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const appData = useAppData();
useEffect(() => {
if (actionData?.error) {
toast.error(actionData.error);
} else if (actionData?.success) {
toast.success(actionData.success);
}
}, [actionData]);
return (
<EditPageLayout className="mb-12">
<SubscriptionSettings
{...data}
mySubscription={appData.mySubscription}
currentTenant={appData.currentTenant}
permissions={{
viewInvoices: getUserHasPermission(appData, "app.settings.subscription.invoices.view") && data.myInvoices.length > 0,
}}
/>
</EditPageLayout>
);
}
@@ -0,0 +1,17 @@
import fs from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
const routeRoot = path.resolve(process.cwd(), "apps/web/app/routes/app.$tenant/settings");
function readRoute(relativePath: string) {
return fs.readFileSync(path.join(routeRoot, relativePath), "utf8");
}
describe("tenant settings audit log copy", () => {
it("does not append stray braces to role names", () => {
const sources = [readRoute("members.tsx"), readRoute("roles-and-permissions/users.tsx")].join("\n");
expect(sources).not.toContain("${role?.name}}");
});
});
@@ -0,0 +1,79 @@
import fs from "node:fs";
import path from "node:path";
import { describe, expect, it } from "vitest";
const repoRoot = process.cwd();
const sourceFiles = [
"apps/web/app/components/core/tenants/UpdateTenantDetailsForm.tsx",
"apps/web/app/components/core/tenants/DeactivateTenantModal.tsx",
"apps/web/app/components/core/tenants/TenantsTable.tsx",
"apps/web/app/routes/app.$tenant/settings/groups.tsx",
"apps/web/app/routes/app.$tenant/settings/account.tsx",
"apps/web/app/routes/app.$tenant/settings/api/docs.tsx",
"apps/web/app/routes/app.$tenant/settings/api/index.tsx",
"apps/web/app/routes/app.$tenant/settings/api/keys.tsx",
"apps/web/app/routes/app.$tenant/settings/api/keys/$id.tsx",
"apps/web/app/routes/app.$tenant/settings/api/keys/new.tsx",
"apps/web/app/routes/app.$tenant/settings/api/logs.tsx",
"apps/web/app/routes/app.$tenant/settings/audit-export.tsx",
"apps/web/app/routes/app.$tenant/settings/credits.tsx",
"apps/web/app/routes/app.$tenant/settings/logs/events.tsx",
"apps/web/app/routes/app.$tenant/settings/logs/events.$id.tsx",
"apps/web/app/routes/app.$tenant/settings/logs/index.tsx",
"apps/web/app/routes/app.$tenant/settings/members.tsx",
"apps/web/app/routes/app.$tenant/settings/members/edit.$id.tsx",
"apps/web/app/routes/app.$tenant/settings/members/groups/$id.tsx",
"apps/web/app/routes/app.$tenant/settings/members/groups/new.tsx",
"apps/web/app/routes/app.$tenant/settings/members/new.tsx",
"apps/web/app/routes/app.$tenant/settings/notifications.tsx",
"apps/web/app/routes/app.$tenant/settings/plugins.tsx",
"apps/web/app/routes/app.$tenant/settings/plugins.$id.tsx",
"apps/web/app/routes/app.$tenant/settings/plugins.$id.audit.tsx",
"apps/web/app/routes/app.$tenant/settings/policies.tsx",
"apps/web/app/routes/app.$tenant/settings/privacy.tsx",
"apps/web/app/routes/app.$tenant/settings/privacy.delete.confirm.$token.tsx",
"apps/web/app/routes/app.$tenant/settings/profile.tsx",
"apps/web/app/routes/app.$tenant/settings/roles-and-permissions.tsx",
"apps/web/app/routes/app.$tenant/settings/roles-and-permissions/permissions.tsx",
"apps/web/app/routes/app.$tenant/settings/roles-and-permissions/roles.tsx",
"apps/web/app/routes/app.$tenant/settings/roles-and-permissions/roles/$id.tsx",
"apps/web/app/routes/app.$tenant/settings/roles-and-permissions/roles/new.tsx",
"apps/web/app/routes/app.$tenant/settings/roles-and-permissions/users.tsx",
"apps/web/app/routes/app.$tenant/settings/subscription.tsx",
"apps/web/app/routes/app.$tenant/settings/theme.tsx",
"apps/web/app/routes/app.$tenant/settings/groups/new.tsx",
"apps/web/app/routes/app.$tenant/settings/groups/$id.tsx",
];
describe("tenant settings i18n", () => {
it("uses semantic translation keys for visible tenant settings labels", () => {
const source = sourceFiles.map((file) => fs.readFileSync(path.join(repoRoot, file), "utf8")).join("\n");
const roleUsersSource = fs.readFileSync(path.join(repoRoot, "apps/web/app/routes/app.$tenant/settings/roles-and-permissions/users.tsx"), "utf8");
expect(source).toContain("settings.tenant.iconAlt");
expect(source).toContain("settings.tenant.deactivation.title");
expect(source).toContain("settings.tenant.billing.lastInvoice");
expect(source).toContain("models.event.plural");
expect(source).toContain("settings.groups.disabled.title");
expect(source).toContain("settings.members.groups.createTitle");
expect(source).toContain("settings.members.errors.createInvitationFailed");
expect(source).toContain('settings.members.actions.removeConfirm", { email:');
expect(source).toContain("models.permission.count");
expect(roleUsersSource).toContain('title: `${t("models.permission.userRoles")} | ${process.env.APP_NAME}`');
expect(source).toContain("createLocaleFormatters");
expect(source).toContain("formatters.currency");
expect(source).toContain("formatters.number");
expect(source).toContain("formatters.relativeDate");
expect(source).toContain("translateLabel(t, i18n, f.title)");
expect(source).not.toContain("DateUtils");
expect(source).not.toContain("NumberUtils");
expect(source).not.toContain("ui.autogenerated");
expect(source).not.toContain('process.env.APP_NAME ?? "App"');
expect(roleUsersSource).not.toContain('title: `${t("models.role.adminRoles")} | ${process.env.APP_NAME}`');
expect(source).not.toContain("i.types.map((f) => f.title).join");
expect(source).not.toContain("name: f.title");
expect(source).not.toContain("Could not create invitation");
expect(source).not.toContain('settings.members.actions.removeConfirm", { 0:');
expect(source).not.toContain('models.permission.plural")?.toLowerCase');
});
});
@@ -0,0 +1,79 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs } from "react-router";
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
vi.mock("~/utils/services/.server/urlService", () => ({ getTenantIdFromUrl: vi.fn() }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: vi.fn() }));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn() }));
vi.mock("~/utils/db/tenants.db.server", () => ({
getTenantWithProfile: vi.fn(),
updateTenantTheme: vi.fn(),
}));
import { getTranslations } from "~/locale/i18next.server";
import { updateTenantTheme } from "~/utils/db/tenants.db.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { validateCSRFToken } from "~/utils/session.server";
import { action } from "./theme";
function createRequest(form: FormData) {
return new Request("https://app.example.test/acme/settings/theme", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(Array.from(form.entries()).map(([key, value]) => [key, String(value)])),
});
}
function createThemeForm(overrides: Record<string, string> = {}) {
const form = new FormData();
form.set("action", "update-theme");
form.set("theme", "dark");
form.set("themeConfig", "{}");
Object.entries(overrides).forEach(([key, value]) => form.set(key, value));
return form;
}
async function callAction(form: FormData) {
return action({
request: createRequest(form),
params: { tenant: "acme" },
context: {},
unstable_pattern: "app.$tenant/settings/theme",
} as ActionFunctionArgs) as Promise<Response>;
}
describe("tenant theme settings action", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTranslations).mockResolvedValue({ t: (key: string) => key } as never);
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant_1");
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(updateTenantTheme).mockResolvedValue({} as never);
});
it("updates the tenant theme", async () => {
const response = await callAction(createThemeForm());
const data = await response.json();
expect(response.status).toBe(200);
expect(data).toEqual({ success: "shared.updated" });
expect(updateTenantTheme).toHaveBeenCalledWith("tenant_1", { theme: "dark", themeConfig: "{}" });
});
it("keeps theme persistence internals out of action errors", async () => {
vi.mocked(updateTenantTheme).mockRejectedValueOnce(new Error("raw theme failure"));
const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
const response = await callAction(createThemeForm());
const data = await response.json();
expect(response.status).toBe(400);
expect(data).toEqual({ error: "shared.unexpectedError" });
expect(JSON.stringify(data)).not.toContain("raw theme failure");
expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
consoleError.mockRestore();
});
});
@@ -0,0 +1,71 @@
import { ActionFunction, LoaderFunctionArgs, MetaFunction, useLoaderData } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantWithProfile, updateTenantTheme, TenantWithProfile } from "~/utils/db/tenants.db.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import UpdateTenantFormTheme from "~/components/core/tenants/forms/UpdateTenantFormTheme";
import { validateCSRFToken } from "~/utils/session.server";
type LoaderData = {
title: string;
tenant: TenantWithProfile;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.account.view", tenantId);
const { t } = await getTranslations(request);
const tenant = await getTenantWithProfile(tenantId);
if (!tenant) {
throw Error(t("shared.notFound"));
}
const data: LoaderData = {
title: t("settings.theme.metaTitle", { appName: process.env.APP_NAME }),
tenant,
};
return data;
};
type ActionData = {
error?: string;
success?: 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.account.update", tenantId);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString() ?? "";
if (action === "update-theme") {
try {
const theme = form.get("theme")?.toString() || null;
const themeConfig = form.get("themeConfig")?.toString() || null;
await updateTenantTheme(tenantId, { theme, themeConfig });
return Response.json({ success: t("shared.updated") });
} catch (error) {
console.error(error);
return badRequest({ error: t("shared.unexpectedError") });
}
}
return badRequest({ error: t("shared.invalidForm") });
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function ThemeSettingsRoute() {
const data = useLoaderData<LoaderData>();
return (
<EditPageLayout>
<UpdateTenantFormTheme tenant={data.tenant} />
</EditPageLayout>
);
}